Java 中调用对象

10 Sept 2024 | 4 分钟阅读

在Java 中，对象调用可以被视为面向对象编程 (OOP) 的一个重要概念。对象调用的过程始于类的实例化，类被用作蓝图，之后可以利用它来创建对象。让我们详细了解 Java 中对象调用的过程。

在 Java 中，new 关键字主要用于创建类的对象、调用相应的构造函数、分配内存以及初始化对象。特定类的对象是通过使用 new 关键字后跟类名来创建的。new 关键字是强制使用的，因为它用于为相应类的对象分配内存和初始化对象。当在 Java 中使用 new 关键字时，会创建一个相应类的实例，该实例会被赋值给引用变量，该变量将被识别为对象名。

成功创建类对象后，可以通过使用点运算符调用类的方法来与之交互。除了类的方法，对象还可以访问其他字段，例如变量。

让我们通过几个 Java 示例程序来详细了解 Java 中对象调用的过程。

示例 1

文件名： ObjectClass.java

// Java program for demonstrating the features and functionalities of object calling in Java. 
import java.util.ArrayList;
import java.util.List;
interface ObjectInterface {
    void interface_Method();
}
abstract class ObjectCalling {
    abstract void abstract_Method();
    void nonAbstract_Method() {
        System.out.println("Non-abstract method in ObjectCalling Class");
    }
}
public class ObjectClass {
    public static class ChildClass extends ObjectCalling {
        private int number;
        private List<String> texts;
        // Constructor
        public ChildClass(int number) {
            this.number = number;
            this.texts = new ArrayList<>();
        }
        // Instance method
        public void base_Number() {
            System.out.println("BaseNumber: " + number);
        }
        // Method that returns a value
        public int add_BaseNumber(int value) {
            number += value;
            return number;
        }
        // Method to add a message to the collection
        public void add_Text(String message) {
            texts.add(message);
        }
        // Getter method for texts
        public List<String> get_Text() {
            return texts;
        }
        // Implementation of abstract method
        @Override
        void abstract_Method() {
            System.out.println("Abstract method implementation in ChildClass");
        }
    }
    public static class ClassDerived extends ChildClass implements ObjectInterface {
        private String derived_Messages;
        // Constructor
        public ClassDerived(int number, String message) {
            super(number);
            this.derived_Messages = message;
        }
        // New method in the derived class
        public void displayDerivedMessage() {
            System.out.println("DerivedMessage: " + derived_Messages);
        }
        // Implementation of the interface method
        @Override
        public void interface_Method() {
            System.out.println("Interface method implementation in ClassDerived");
        }
    }
    public static void main(String[] args) {
        ChildClass o1 = new ChildClass(10);
        ClassDerived o2 = new ClassDerived(20, "Hello");
        o1.base_Number(); 
        o2.base_Number();
        o2.displayDerivedMessage(); 
        // Returning a value from a method
        int newBaseNumber = o1.add_BaseNumber(5);
        System.out.println("New BaseNumber: " + newBaseNumber);
        // Chaining method calls
        // int result = o2.add_BaseNumber(5).add_BaseNumber(3);
        // System.out.println("Result: " + result); // Output: Result: 28
        ObjectInterface obj1 = new ClassDerived(30, "Polymorphism");
        obj1.interface_Method(); // Output: Interface method implementation in ClassDerived
        o1.add_Text("Message 1");
        o1.add_Text("Message 2");
        // Displaying texts from the collection
        System.out.println("Messages:");
        for (String message : o1.get_Text()) {
            System.out.println(message);
        }
        o2.abstract_Method(); 
        o2.nonAbstract_Method();
    }
}

输出

BaseNumber: 10
BaseNumber: 20
DerivedMessage: Hello
New BaseNumber: 15
Interface method implementation in ClassDerived
Messages:
Message 1
Message 2
Abstract method implementation in ChildClass
Non-abstract method in ObjectCalling Class

让我们通过另一个 Java 示例程序来理解。

示例 2

文件名： ObjectCalling.java

// Java program for demonstrating the features and functionalities of object calling in Java.
import java.util.ArrayList;
import java.util.List;
class Animal_Class {
    private String name;
    public Animal_Class(String name) {
        this.name = name;
    }
    // Getter method for name
    public String getName() {
        return name;
    }
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
    @Override
    public String toString() {
        return "Animal_Class{name='" + name + "'}";
    }
}
class Mammal_Animal extends Animal_Class {
    private int numberOfLegs;
    // Constructor
    public Mammal_Animal(String name, int numberOfLegs) {
        super(name);
        this.numberOfLegs = numberOfLegs;
    }
    // Overridden method to make a sound
    @Override
    public void makeSound() {
        System.out.println("Mammal sound");
    }
    // Overridden toString method
    @Override
    public String toString() {
        return "Mammal Animal{name='" + getName() + "', numberOfLegs=" + numberOfLegs + '}';
    }
}
// Bird_Animal class, extending Animal_Class
class Bird_Animal extends Animal_Class {
    private boolean canFly;
    // Constructor
    public Bird_Animal(String name, boolean canFly) {
        super(name);
        this.canFly = canFly;
    }
    // Overridden method to make a sound
    @Override
    public void makeSound() {
        System.out.println("Bird Animal sound");
    }
    // Overridden toString method
    @Override
    public String toString() {
        return "Bird_Animal{name='" + getName() + "', canFly=" + canFly + '}';
    }
}
public class ObjectCalling {
    public static void main(String[] args) {
        Animal_Class genericAnimal = new Animal_Class("Animal Class");
        Mammal_Animal dog = new Mammal_Animal("Dog", 4);
        Bird_Animal sparrow = new Bird_Animal("Sparrow", true);
        System.out.println(genericAnimal);
        genericAnimal.makeSound(); 
        System.out.println(dog); 
        dog.makeSound(); 
        System.out.println(sparrow);
        sparrow.makeSound();
        // Demonstrating polymorphism using a list of animals
        List<Animal_Class> animals = new ArrayList<>();
        animals.add(genericAnimal);
        animals.add(dog);
        animals.add(sparrow);
        System.out.println("Polymorphic behavior in a list:");
        for (Animal_Class animal : animals) {
            System.out.println(animal);
            animal.makeSound();
        }
    }
}

输出

Animal_Class{name='Animal Class'}
Generic animal sound
Mammal Animal{name='Dog', numberOfLegs=4}
Mammal sound
Bird_Animal{name='Sparrow', canFly=true}
Bird Animal sound
Polymorphic behavior in a list:
Animal_Class{name='Animal Class'}
Generic animal sound
Mammal Animal{name='Dog', numberOfLegs=4}
Mammal sound
Bird_Animal{name='Sparrow', canFly=true}
Bird Animal sound

下一个主题Java 中的构造函数特性

Java 中调用对象

示例 1

示例 2

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中调用对象

示例 1

示例 2

相关帖子

Goldbach Number in Java

Java 程序将所有零移到数组开头

GC Overhead Limit Exceeded

Java 中的 cint

Java 中用于先序遍历的 Morris 遍历

Java 中的 XOR 逻辑运算符

Java IDEs

How to Compile and Run Java Program

Java 中从第一个节点到最后一个节点的受限路径数量

Java 中变量的生命周期

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器