Open In App

Classes and Objects in Java

Last Updated : 22 Sep, 2023
Like Article

In Java, classes and objects are basic concepts of Object Oriented Programming (OOPs) that are used to represent real-world concepts and entities. The class represents a group of objects having similar properties and behavior. For example, the animal type Dog is a class while a particular dog named Tommy is an object of the Dog class.

In this article, we will discuss Java objects and classes and how to implement them in our program.

Java Classes

A class in Java is a set of objects which shares common characteristics/ behavior and common properties/ attributes. It is a user-defined blueprint or prototype from which objects are created. For example, Student is a class while a particular student named Ravi is an object.

Properties of Java Classes

  1. Class is not a real-world entity. It is just a template or blueprint or prototype from which objects are created.
  2. Class does not occupy memory.
  3. Class is a group of variables of different data types and a group of methods.
  4. A Class in Java can contain:
    • Data member
    • Method
    • Constructor
    • Nested Class
    • Interface

Class Declaration in Java

access_modifier class <class_name>
    data member;  
    nested class;

Example of Java Class


// Java Program for class example
class Student {
    // data member (also instance variable)
    int id;
    // data member (also instance variable)
    String name;
    public static void main(String args[])
        // creating an object of
        // Student
        Student s1 = new Student();


// Java program to Illustrate Creation of Object
// Using new Instance
// Main class
class GFG {
    // Declaring and initializing string
    String name = "GeeksForGeeks";
    // Main driver method
    public static void main(String[] args)
        // Try block to check for exceptions
        try {
            Class cls = Class.forName("GFG");
            // Creating object of main class
            // using instance method
            GFG obj = (GFG)cls.newInstance();
            // Print and display
        catch (ClassNotFoundException e) {
        catch (InstantiationException e) {
        catch (IllegalAccessException e) {


// Java program to Illustrate Creation of Object
// Using clone() method
// Main class
// Implementing Cloneable interface
class GFG implements Cloneable {
    // Method 1
    protected Object clone()
        throws CloneNotSupportedException
        // Super() keyword refers to parent class
        return super.clone();
    String name = "GeeksForGeeks";
    // Method 2
    // main driver method
    public static void main(String[] args)
        GFG obj1 = new GFG();
        // Try block to check for exceptions
        try {
            GFG obj2 = (GFG)obj1.clone();
        catch (CloneNotSupportedException e) {

Output 1


Output 2


Output 3


Components of Java Classes

 In general, class declarations can include these components, in order: 

  1. Modifiers: A class can be public or has default access (Refer this for details).
  2. Class keyword: class keyword is used to create a class.
  3. Class name: The name should begin with an initial letter (capitalized by convention).
  4. Superclass(if any): The name of the class’s parent (superclass), if any, preceded by the keyword extends. A class can only extend (subclass) one parent.
  5. Interfaces(if any): A comma-separated list of interfaces implemented by the class, if any, preceded by the keyword implements. A class can implement more than one interface.
  6. Body: The class body is surrounded by braces, { }.

Constructors are used for initializing new objects. Fields are variables that provide the state of the class and its objects, and methods are used to implement the behavior of the class and its objects.
There are various types of classes that are used in real-time applications such as nested classes, anonymous classes, and lambda expressions.

Java Objects

An object in Java is a basic unit of Object-Oriented Programming and represents real-life entities. Objects are the instances of a class that are created to use the attributes and methods of a class.  A typical Java program creates many objects, which as you know, interact by invoking methods. An object consists of : 

  1. State: It is represented by attributes of an object. It also reflects the properties of an object.
  2. Behavior: It is represented by the methods of an object. It also reflects the response of an object with other objects.
  3. Identity: It gives a unique name to an object and enables one object to interact with other objects.

Example of an object: dog

Objects in Java

Java Objects

Objects correspond to things found in the real world. For example, a graphics program may have objects such as “circle”, “square”, and “menu”. An online shopping system might have objects such as “shopping cart”, “customer”, and “product”.  

Note: When we create an object which is a non primitive data type, it’s always allocated on the heap memory.

Declaring Objects (Also called instantiating a class)

When an object of a class is created, the class is said to be instantiated. All the instances share the attributes and the behavior of the class. But the values of those attributes, i.e. the state are unique for each object. A single class may have any number of instances.


Declaring Objects in Java

Java Object Declaration

As we declare variables like (type name;). This notifies the compiler that we will use the name to refer to data whose type is type. With a primitive variable, this declaration also reserves the proper amount of memory for the variable. So for reference variables , the type must be strictly a concrete class name. In general, we can’t create objects of an abstract class or an interface.  

Dog tuffy;

If we declare a reference variable(tuffy) like this, its value will be undetermined(null) until an object is actually created and assigned to it. Simply declaring a reference variable does not create an object.

Initializing a Java object

The new operator instantiates a class by allocating memory for a new object and returning a reference to that memory. The new operator also invokes the class constructor. 



// Class Declaration
public class Dog {
    // Instance Variables
    String name;
    String breed;
    int age;
    String color;
    // Constructor Declaration of Class
    public Dog(String name, String breed, int age,
               String color)
    { = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    // method 1
    public String getName() { return name; }
    // method 2
    public String getBreed() { return breed; }
    // method 3
    public int getAge() { return age; }
    // method 4
    public String getColor() { return color; }
    @Override public String toString()
        return ("Hi my name is " + this.getName()
                + ".\nMy breed,age and color are "
                + this.getBreed() + "," + this.getAge()
                + "," + this.getColor());
    public static void main(String[] args)
        Dog tuffy
            = new Dog("tuffy", "papillon", 5, "white");


Hi my name is tuffy.
My breed,age and color are papillon,5,white


Initialize by using method/function:


public class GFG {
    // sw=software
    static String sw_name;
    static float sw_price;
    static void set(String n, float p)
        sw_name = n;
        sw_price = p;
    static void get()
        System.out.println("Software name is: " + sw_name);
        System.out.println("Software price is: "
                           + sw_price);
    public static void main(String args[])
        GFG.set("Visual studio", 0.0f);


Software name is: Visual studio
Software price is: 0.0

This class contains a single constructor. We can recognize a constructor because its declaration uses the same name as the class and it has no return type. The Java compiler differentiates the constructors based on the number and the type of the arguments. The constructor in the Dog class takes four arguments. The following statement provides “tuffy”, “papillon”,5, and “white” as values for those arguments:

Dog tuffy = new Dog("tuffy","papillon",5, "white");

The result of executing this statement can be illustrated as :

Memory Allocation in Java objects

Memory Allocation of Java Objects

Note: All classes have at least one constructor. If a class does not explicitly declare any, the Java compiler automatically provides a no-argument constructor, also called the default constructor. This default constructor calls the class parent’s no-argument constructor (as it contains only one statement i.e super();), or the Object class constructor if the class has no other parent (as the Object class is the parent of all classes either directly or indirectly). 

Ways to Create an Object of a Class

There are four ways to create objects in Java. Strictly speaking, there is only one way(by using a new keyword), and the rest internally use a new keyword. 

1. Using new keyword

It is the most common and general way to create an object in Java. 


// creating object of class Test
Test t = new Test();

2. Using Class.forName(String className) method

There is a pre-defined class in java.lang package with name Class. The forName(String className) method returns the Class object associated with the class with the given string name. We have to give a fully qualified name for a class. On calling the new Instance() method on this Class object returns a new instance of the class with the given string name.

// creating object of public class Test
// consider class Test present in com.p1 package
Test obj = (Test)Class.forName("com.p1.Test").newInstance();

3. Using clone() method

clone() method is present in the Object class. It creates and returns a copy of the object.

// creating object of class Test
Test t1 = new Test();
// creating clone of above object
Test t2 = (Test)t1.clone();

4. Deserialization

De-serialization is a technique of reading an object from the saved state in a file. Refer to Serialization/De-Serialization in Java

FileInputStream file = new FileInputStream(filename);
ObjectInputStream in = new ObjectInputStream(file);
Object obj = in.readObject();

Creating multiple objects by one type only (A good practice) 

In real-time, we need different objects of a class in different methods. Creating a number of references for storing them is not a good practice and therefore we declare a static reference variable and use it whenever required. In this case, the wastage of memory is less. The objects that are not referenced anymore will be destroyed by the Garbage Collector of Java. 


Test test = new Test();
test = new Test();

In the inheritance system, we use a parent class reference variable to store a sub-class object. In this case, we can switch into different subclass objects using the same referenced variable. 


class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
public class Test
    // using Dog object
    Animal obj = new Dog();
    // using Cat object
    obj = new Cat();

Anonymous Objects in Java

Anonymous objects are objects that are instantiated but are not stored in a reference variable.  

  • They are used for immediate method calls.
  • They will be destroyed after method calling.
  • They are widely used in different libraries. For example, in AWT libraries, they are used to perform some action on capturing an event(eg a key press).
  • In the example below, when a key button(referred to by the btn) is pressed, we are simply creating an anonymous object of EventHandler class for just calling the handle method.
btn.setOnAction(new EventHandler()
    public void handle(ActionEvent event)
        System.out.println("Hello World!");

Difference between Java Class and Objects

The differences between class and object in Java are as follows: 



Class is the blueprint of an object. It is used to create objects. An object is an instance of the class.
No memory is allocated when a class is declared. Memory is allocated as soon as an object is created.
A class is a group of similar objects. An object is a real-world entity such as a book, car, etc.
Class is a logical entity. An object is a physical entity.
A class can only be declared once. Objects can be created many times as per requirement.
An example of class can be a car. Objects of the class car can be BMW, Mercedes, Ferrari, etc.

Previous Article
Next Article

Similar Reads

Understanding Classes and Objects in Java
The term Object-Oriented explains the concept of organizing the software as a combination of different types of objects that incorporate both data and behaviour. Hence, Object-oriented programming(OOPs) is a programming model, that simplifies software development and maintenance by providing some rules. Programs are organised around objects rather
9 min read
Java.util.Objects class in Java
Java 7 has come up with a new class Objects that have 9 static utility methods for operating on objects. These utilities include null-safe methods for computing the hash code of an object, returning a string for an object, and comparing two objects. Using Objects class methods, one can smartly handle NullPointerException and can also show customize
8 min read
Catching Base and Derived Classes as Exceptions in C++ and Java
An Exception is an unwanted error or hurdle that a program throws while compiling. There are various methods to handle an exception which is termed exceptional handling. Let's discuss what is Exception Handling and how we catch base and derived classes as an exception in C++: If both base and derived classes are caught as exceptions, then the catch
4 min read
Sorting Elements of Arrays and Wrapper Classes that Already Implements Comparable in Java
Java provides the Comparable interface to sort objects using data members of the class. The Comparable interface contains only one method compareTo() that compares two objects to impose an order between them. It returns a negative integer, zero, or positive integer to indicate if the input object is less than, equal to, or greater than the current
4 min read
Commonly Used Methods in LocalDate, LocalTime and LocalDateTime Classes in Java
Java provides the three most important classes related to dates namely LocalDate, LocalTime, LocalDateTime which makes the handling of dates in Java very easy as in order to use these classes, we need to import 'java.time' package which is main the main API for dates, times, instants, and durations. Illustration: 1. java.time.* // To include all cl
5 min read
Java Unnamed Classes and Instance Main Methods
Java has introduced a significant language enhancement in Java Enhancement Proposal (JEP) 445, titled "Unnamed Classes and Instance Main Methods". This proposal aims to address the needs of beginners, making Java more accessible and less intimidating. Let's delve into the specifics of this proposal and understand how it simplifies the learning curv
7 min read
Private Constructors and Singleton Classes in Java
Let's first analyze the following question: Can we have private constructors ? As you can easily guess, like any method we can provide access specifier to the constructor. If it's made private, then it can only be accessed inside the class. Do we need such 'private constructors ' ? There are various scenarios where we can use private constructors.
2 min read
equals() on String and StringBuffer objects in Java
Consider the following codes in java: Java Code // This program prints false class GFG { public static void main(String[] args) { StringBuffer sb1 = new StringBuffer(&quot;GFG&quot;); StringBuffer sb2 = new StringBuffer(&quot;GFG&quot;); System.out.println(sb1.equals(sb2)); } } Output: false Java Code // This program prints true class GFG { public
2 min read
Difference Between Equality of Objects and Equality of References in Java
Equality of objects means when two separate objects happen to have the same values/state. Whereas equality of references means when two object references point to the same object. The == operator can be used to check if two object references point to the same object. To be able to compare two java objects of the same class the boolean equals(Object
2 min read
Passing and Returning Objects in Java
Although Java is strictly passed by value, the precise effect differs between whether a primitive type or a reference type is passed. When we pass a primitive type to a method, it is passed by value. But when we pass an object to a method, the situation changes dramatically, because objects are passed by what is effectively call-by-reference. Java
6 min read
Article Tags :
Practice Tags :