Calling Object in Java

In Java, object calling can be considered as an important concept related to object-oriented programming (OOP). The process of object calling gets started by the instantiation of a class, which is utilized for representation of a blueprint that can be later utilized for the creation of objects. Let's understand about the process of object calling in Java in detail.

In Java, the new keyword is mainly utilized for creation of an object of a class, invoking the respective constructor and allocating memory along with initialization of object. The object of a particular class is created by using the new keyword which is followed by the class name. The usage of new keyword is mandatory as it used for allocation memory, initializing object of the respective class. An instance of the respective class is created when new keyword is utilized in Java and this instance gets assigned to the reference variable which will be identified as the object name.

Upon successful creation of the object of the class, it can be interacted by invoking the methods of the class using dot operator. Along with methods of the class, other fields can also be accessed by the objects such as variables.

Let's understand about the process of object calling in Java in detail with the help of few example programs in Java.

Example 1:

Filename: 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();
    }
}

Output:

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

Let's understand with the help of another example Java program.

Example 2:

Filename: 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();
        }
    }
}

Output:

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

Next TopicCharacteristics of Constructor in Java

← prev next →