Class and Object in Java: A Complete Guide with Examples

A class in Java is a user-defined data type that groups variables (data) and methods (functions) into a single unit. It defines the structure and behavior of objects. In other words, a class acts as a blueprint for creating objects that share similar properties and behaviors.

Class Definition in Java

A class is defined using the class keyword, followed by the class name and a pair of curly braces that enclose its members (variables and methods).

Syntax:

class ClassName {

    // Variables (Data Members)


    // Methods (Member Functions)

}

Example:

class Student {

    int id;
    String name;

    void display() {
        System.out.println(id + " " + name);
    }
}

Here:

• Student is the class name.
• id and name are variables (also called data members or fields).
• display() is a method (also called a member function).

This is a basic class definition in Java. The class itself does not occupy memory until objects are created from it.

A Java class is made up of two main components: variables (also called fields or attributes) and methods (also called member functions). These elements define the state and behavior of objects created from the class.

Types of Variables in a Class

1. Instance Variables
   
   • Declared inside a class but outside any method.
   • Each object has its own copy of instance variables.
   • Example: int age; String name;
2. Class Variables (Static Variables)
   
   • Declared with the static keyword inside the class.
   • Shared among all instances of the class.
   • Example: static int studentCount;
3. Local Variables
   
   • Declared inside methods, constructors, or blocks.
   • Only accessible within the method or block where defined.
4. Parameters
   
   • Variables declared in method signatures to receive values when the method is called.

Methods in a Class

Methods define the behavior of the class. They can:

• Access and modify the class’s variables.
• Take parameters and return values.
• Be instance methods (operate on specific objects) or static methods (belong to the class, not any object).

Example

class Student {

    // Instance variables
    private int id;
    private String name;

    // Class (static) variable
    static int count = 0;

    // Constructor
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
        count++;
    }

    // Getter method
    public int getId() {
        return id;
    }

    // Setter method
    public void setId(int id) {
        this.id = id;
    }

    // Instance method
    public void display() {
        System.out.println("ID: " + id + ", Name: " + name);
    }

    // Static method
    public static int getCount() {
        return count;
    }
}

Access Modifiers

• Control the visibility of class members.
  
  • private: Accessible only within the class.
  • public: Accessible from any other class.
  • protected and default (no modifier) offer other levels of access.

Getter and Setter Methods

• Used to access and update private instance variables.
• Promote encapsulation and data security.

An object in Java is a real-world entity and a concrete instance of a class. While a class is just a blueprint or template, an object is the actual, usable version created from that blueprint. Objects represent specific data and allow you to access the variables and methods defined in the class.

Object Definition in Java

An object is created from a class and occupies memory in your program. Each object maintains its own state and can perform actions defined by its class.

In simple words:
An object is a runtime instance of a class.

When you define an object in Java, you are creating a real, working version of a class that you can use in your code.

Key Characteristics of Objects

• State: The data or attributes stored in the object (for example, a car’s color or speed).
• Behavior: The actions or methods the object can perform (for example, a car can accelerate or brake).
• Identity: Each object has a unique reference in memory that distinguishes it from other objects, even if their state is identical.

Real-World Analogy

Think of a class as a blueprint for building a house. The blueprint itself doesn’t occupy land or provide shelter—it’s just a plan. An object is the actual house built from the blueprint. You can build many houses (objects) from the same blueprint (class), and each one can have its own color, size, and features.

How to Create an Object in Java

To create an object in Java, we use the new keyword.

Syntax:

ClassName objectName = new ClassName();

Example:

Student s1 = new Student();

Here:

• Student → Class name
• s1 → Object reference
• new Student() → Creates object

This is how we create an object in Java.

Accessing Class Members Using Objects

Once you have created an object from a class, you can use that object to access the class’s variables (fields) and methods. In Java, this is done using the dot (.) operator.

Syntax

objectName.variableName = value; // To set a variable 
objectName.methodName(); // To call a method

Example

Suppose you have a Student class:

class Student {

    int id;
    String name;

    void display() {
        System.out.println("ID: " + id);
        System.out.println("Name: " + name);
    }
}

You can create an object and access its members as follows:

class Main {

    public static void main(String[] args) {

        // Create object
        Student s1 = new Student();

        // Access and assign values to fields
        s1.id = 101;
        s1.name = "Rahul";

        // Call method
        s1.display();
    }
}

Output:

ID: 101 
Name: Rahul

In this example:

• s1.id = 101; assigns a value to the id field of the s1 object.
• s1.name = "Rahul"; assigns a value to the name field.
• s1.display(); calls the display() method, which prints the values.

Summary:

Objects act as a gateway to the data and behavior defined in a class. By using the object’s reference and the dot operator, you can access and manipulate the class’s members in your Java program.

In Java, you can create multiple objects from a single class. Each object is a separate instance with its own state but shares the structure and behavior defined by the class template.

Creating Multiple Objects

You can create as many objects as needed from the same class using the new keyword. Each object will have its own copy of the class’s fields (instance variables).

Example:

Car car1 = new Car(); 
Car car2 = new Car();

Here, both car1 and car2 are different objects of the Car class. They each have their own values for fields like model, color, or year.

Object Reusability

Once created, each object can be reused multiple times throughout your program. You can assign values to their fields, call their methods, and even pass them to other methods or classes.

Interaction with Class Members

• Fields and Methods: Each object can store its own data in fields and perform actions using methods.
• main() Method Usage: Typically, objects are created and manipulated inside the main() method or other methods of your program.
• Object of a Class in Another Class: You can create and use objects of a class inside another class, promoting modularity and code organization.

Example: Multiple Student Objects

Student student1 = new Student(101, "Amit");
Student student2 = new Student(102, "Neha");

student1.display();
student2.display();

The display() function prints the unique characteristics of each Student object, which has its own name and id.

Key Points

• A class may have several independent instances.
• For instance, variables and memory are allocated uniquely to each object.
• Objects can communicate with one another by passing references or invoking methods.
• This approach enables object reusability and makes your code scalable.

Objects in Java can be categorized based on how they are created and used:

Named Objects

1. These are objects that are assigned a reference variable.
2. You can use the reference variable to access the object multiple times throughout your code.

Example:

Student s1 = new Student(); s1.display();

Here, s1 is a named object of the Student class. You can use s1 anywhere in the scope to access the object’s members.

Anonymous Objects

1. An anonymous object is created without assigning it to a reference variable.
2. It is used immediately and cannot be reused since it has no name.
3. Typically used when you only need the object once, such as passing it to a method or calling a method immediately after creation.

Example:

new Student().display();

In this example, a new Student object is created, and its display() method is called right away. After this line, there is no way to access this object again.

1. Use Cases:
   
   • When you need an object for a single operation.
   • Reduces unnecessary reference variables, keeping the code concise.
2. Singleton Objects
   
   • A singleton object refers to a design pattern where only one instance of a class is allowed throughout the application.
   • Useful when exactly one object is needed to coordinate actions across the system (such as configuration managers, loggers, etc.).
   • Achieved by:
     
     • Making the class constructor private.
     • Creating a static instance variable within the class.
     • Providing a public static method to get the instance.

Example:

public class Singleton {

    // Static instance (single object)
    private static Singleton instance;

    // Private constructor
    private Singleton() {
    }

    // Public method to get the instance
    public static Singleton getInstance() {

        if (instance == null) {
            instance = new Singleton();
        }

        return instance;
    }
}

Here, Singleton.getInstance() always returns the same object.

Summary Table

In Practice:

• Use named objects for most programming tasks.
• Use anonymous objects for quick, one-off operations.
• Use the singleton pattern when you need a single, globally accessible instance.

An array of objects in Java allows you to store multiple instances of a class in a single, organized collection. This is especially useful when you need to manage groups of related data, such as a list of students, employees, or products.

Why Use an Array of Objects?

• Efficient Data Management: Easily handle and process large numbers of similar objects.
• Improved Structure: Makes code more understandable and orderly by grouping similar things together.
• Simplified Operations: This allows you to use loops to carry out operations (such as sorting, updating, or searching) on all items. 

How to Create an Array of Objects

Declare the Array:

Specify the class type and the array size.

Example:

Student[] students = new Student[3];

Initialize Each Element:

Use the new keyword to create each object and assign it to an array index.

Example:

students[0] = new Student(1, "Amit");

Access Objects Using a Loop:

Iterate through the array to access or modify each object.

Example: 

for (int i = 0; i < students.length; i++)
{ 
System.out.println(students[i].id + " " + students[i].name); 
}

Example: Array of Student Objects

class Student {

    int id;
    String name;

    Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

public class Main {

    public static void main(String[] args) {

        // Declare and create an array of Student objects
        Student[] students = new Student[3];

        // Initialize each object in the array
        students[0] = new Student(1, "Amit");
        students[1] = new Student(2, "Ravi");
        students[2] = new Student(3, "Neha");

        // Access and display each student's details
        for (int i = 0; i < students.length; i++) {
            System.out.println(
                students[i].id + " " + students[i].name
            );
        }
    }
}

Output:

1 Amit
2 Ravi
3 Neha

Key Points

• Each element in the array holds a reference to a different object.
• Arrays help manage collections of objects efficiently.
• You can use loops to process all objects in the array.

In summary:

‍An array of objects in Java is a powerful tool for managing groups of related data, making your code more organized, scalable, and easier to maintain.

1. Code Reusability: Write code once and create multiple objects from the same class.
2. Better Organization: For clarity and organization, group similar facts and behavior.
3. Security: Encapsulate data to protect and control access.
4. Easy Maintenance: Isolate changes and bugs within specific classes.
5. Real-World Modeling: Represent real entities naturally in code.
6. Scalability: Build modular programs that grow easily with project needs.

Java allocates memory in two primary regions when you create an object:

• Heap Memory:
  The heap contains the actual object, together with its state and data. The heap is a section of memory set aside for dynamic allocation, which means that things remain there until Java's garbage collector removes them.
• Stack Memory:
  The reference variable (the variable you use to access the object) is stored in the stack. This variable holds the memory address (reference) of the object in the heap, not the object itself.

Example:

Student s1 = new Student();

• s1 is a reference variable stored in the stack.
• The new Student object is created in the heap.
• s1 points to the location of the object in the heap.

Visual Summary:

Stack: s1 ─────────┐ │ Heap: Student object ◄─┘

To effectively manage memory and steer clear of problems like memory leaks or NullPointerException, it is essential to comprehend this distinction.

In Java, you can pass objects to methods as parameters. However, it’s important to understand that Java passes the reference to the object (not the actual object itself). This means that any changes made to the object inside the method will affect the original object.

Example:

void show(Student s)
{ System.out.println(s.id); 
}

When you call:

Student student1 = new Student(101, "Alice");
show(student1);

• The reference to student1 is passed to the show method.
• The method can access and modify the actual Student object that student1 refers to.

Key Points:

• Java passes the reference to the object, not a copy of the object.
• Changes made to the object's fields inside the method will persist outside the method.
• However, if you reassign the reference variable inside the method, it won’t affect the original reference outside the method.

Example:

void updateName(Student s) {

    // This change affects the original object
    s.name = "Bob";
}

Summary Table:

Program:

class Employee {

    int id;
    String name;
    double salary;

    Employee(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    void display() {
        System.out.println(id + " " + name + " " + salary);
    }
}

public class Main {

    public static void main(String[] args) {

        Employee e1 = new Employee(1, "Ravi", 45000);
        Employee e2 = new Employee(2, "Amit", 50000);

        e1.display();
        e2.display();
    }
}

Output:

1 Ravi 45000 
2 Amit 50000

This is a complete class and object in Java example.

Understanding the distinction between classes and objects is fundamental in Java programming. While they are closely related, their roles are very different.

Class

• Blueprint: A class is a blueprint or template for creating objects. It defines the structure (fields, also called data members or member variables) and behavior (methods) that the objects will have.
• No Memory Allocation: A class itself does not occupy memory for its fields until objects are instantiated.
• Static Members: Can contain static fields and methods that belong to the class itself, not to any specific object.

Example:

class Car 
	{ 
		String model;
		int year;
void drive()
	{ 
	... 
	}
}

Object

• Instance: An object is a real, concrete instance created from a class. When you create an object, memory is allocated for its instance variables.
• Identity: Every object has a distinct identity (memory reference), a state (instance variable values), and the ability to act via methods.
• Access to Data and Methods: Objects use the class’s methods and hold their own data.

Example:

Car myCar = new Car(); 
myCar.model = "Toyota"; 
myCar.year = 2023; 
myCar.drive();

Key Differences Table

Summary

• Class: Explains the characteristics of the items (blueprint).
• Object: According to the description, the object is a real, usable thing (instance).
• You can create multiple objects from a single class, each with its own state but the same structure and behavior.

Key Idea

An object represents a particular instance of that definition in memory using actual data, whereas a class specifies how an entity should appear.

In Java, creating classes and objects is fundamental to building object-oriented programs. This process involves defining a class (the blueprint) and then instantiating objects (the usable entities) from that class.

Defining a Class

A class is defined using the class keyword, followed by the class name and a pair of curly braces that contain its members.

Syntax:

[access_modifier] class ClassName {

    // Attributes (instance variables)


    // Constructor(s)


    // Methods (including getters and setters)

}

• Access Modifiers: Control the visibility of the class and its members (e.g., public, private).
• Attributes: Variables that store the state of each object (also called instance variables).
• Constructor: Special method used to initialize new objects.
• Methods: Define the behavior of the class. Commonly include getter and setter methods to access and modify attributes.

Example:

public class Student {

    private int id;
    private String name;

    // Constructor
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getter methods
    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // Setter methods
    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    // Method to display details
    public void display() {
        System.out.println("ID: " + id + ", Name: " + name);
    }
}

Instantiating Objects

To create (instantiate) an object from a class, use the new keyword along with the class constructor.

Syntax:

ClassName objectReference = new ClassName(parameters);

Example:

public class Main {

    public static void main(String[] args) {

        Student s1 = new Student(101, "Amit");

        s1.display();   // Output: ID: 101, Name: Amit
    }
}

• Student is the class.
• s1 is the object reference.
• new Student(101, "Amit") creates a new object and calls the constructor.

Key Points

• Object Reference: The variable (such as s1) that is used to access the object is called the object reference.
• main Method: The entry point of Java programs, where objects are often created and used.
• Parameters: Values passed to constructors or methods to initialize or operate on objects.

Understanding classes and objects in Java becomes easier when you relate them to real-world entities and situations. Here are some practical examples and analogies of Class and Object in Java Program:

1. Car Class Analogy

Imagine you want to represent cars in a software application.

• Class: The Car class is like a blueprint that defines the properties (fields) and behaviors (methods) of a car.
  
  • Fields: color, model, year
  • Methods: drive(), brake(), displayInfo()

Example: 

class Car {

    String color;
    String model;
    int year;

    void displayInfo() {
        System.out.println(
            "Model: " + model +
            ", Color: " + color +
            ", Year: " + year
        );
    }
}

• Object: Each specific car (like a red 2019 Toyota Camry) is an object created from the Car class. Each object has its own state (values for color, model, year) and can perform actions (methods).

2. Customer Example

A Customer class might have fields such as name, email, and balance, and methods like deposit() or withdraw(). Each customer in your program is an object with its own data and behaviors.

3. Software Objects as Real-World Entities

Java software objects may conduct actions (methods) and retain their own state (fields), just like a real customer or automobile has distinct traits and behaviors. A Book object, for instance, may contain an author, title, and the function displayInfo() to print its information.

4. Reflection and Dynamic Class Loading

Java's dynamic class loading and reflection features enable you to build and modify objects at runtime in more complex situations. Frameworks like Spring, for example, make advantage of these characteristics to generate objects from configuration files or annotations instead of encoding the class names in your source code.

5. State and Behavior

• State: The data stored in an object’s fields (e.g., a car’s color or a customer’s balance).
• Behavior: The actions or methods the object can perform (e.g., a car can accelerate, a customer can withdraw funds).

Summary Analogy

Consider an object as the food you make using a recipe, and a class as a recipe. Although the ingredients in each meal may vary significantly (state), they all adhere to the same guidelines (behavior).

When dealing with Java classes and objects, even seasoned engineers may make mistakes. Writing cleaner, more dependable code may be achieved by being aware of some typical pitfalls:

1. Forgetting the new Keyword

To create an object in Java, you must use the new keyword along with the class constructor. Omitting new will not instantiate an object and can lead to compilation errors.

Incorrect:

Student student1 = Student("Alice", 20);

Correct:

Student student1 = new Student("Alice", 20);

2. Not Initializing Variables

Runtime problems and unexpected null values might arise from not initializing instance variables, which can lead to bugs. Your variables should always have values assigned to them, either directly or via constructors.

3. Using Wrong Access Modifiers

Making fields public rather than private or using other improper access modifiers might violate encapsulation and grant unauthorized access to your class internals. When necessary, give public getter/setter methods and use private for fields.

4. Null Reference Usage

Accessing methods or fields of an object that hasn’t been properly instantiated leads to NullPointerException. Prior to usage, always make sure your objects are initialized.

Example:

Student student2; 
student2.introduce(); // This will throw NullPointerException if student2 is not initialized

5. Not Understanding Constructors

Constructors are special methods used to initialize new objects. Forgetting to define a constructor, or misunderstanding how constructors work, can result in objects with uninitialized or incorrect values. Always use constructors to set up your object’s initial state.

Avoiding these common mistakes will significantly improve your code quality and reduce runtime errors.

Understanding when to use classes and objects is as important as knowing how to use them. Here are some scenarios where classes and objects are essential:

1. Modeling Real-World Entities

Whenever you need to represent real-world things (like students, books, cars, employees), classes and objects are the best fit. Each entity can be modeled as a class, and each specific instance as an object.

2. Managing Large Projects

Using classes to organize your code makes it more manageable and modular for intricate or large-scale projects. Classes assist in decomposing complexity into broken down into manageable chunks.

3. Implementing OOP Concepts

Object-oriented principles like encapsulation, inheritance, and polymorphism depend on classes and objects. Use them to leverage the full power of Java’s OOP capabilities.

4. Writing Reusable Code

Writing code once and using it again is made possible via classes. Objects may be created as required, which improves maintainability and cuts down on repetition.

In summary:

Use classes and objects in Java whenever you want to model data and behavior in a structured, reusable, and scalable way. Almost every professional Java project relies on these foundational concepts.

When working with classes and objects in Java, following best practices not only leads to clean, maintainable code but also helps avoid common pitfalls such as memory leaks or naming inconsistencies. The following fundamental guidelines and conventions will help you navigate your Java programming journey:

1. Naming Conventions

• Class Names: Class names should be in PascalCase. A capital letter appears at the beginning of each word.
  StudentRecord, StringBuilder, and Car are a few examples.
• Object and Variable Names: Use camelCase for objects, methods, and variables.
  For instance, employeeId, myStringBuffer, and studentList.
• Consistency: To make your project easier to understand and manage, follow these guidelines consistently.

2. Managing Instance Variables

• Encapsulation: Offer public getter and setter methods and make your instance variables private. This way, you allow controlled access, and at the same time, you protect your data.
• Initialization: Make sure you initialize instance variables always, by either assigning a value directly or through constructors, so that you will not get any unexpected null values.

3. Object-to-Object Communication

• Objects should interact via methods and not by directly accessing each other’s fields. This is not only good for maintaining encapsulation but also for having modular code.
• Define common behaviors that multiple classes can implement or inherit using interfaces or abstract classes.

4. Memory Management and Avoiding Memory Leaks

• Dereferenced Objects: Make sure that no references to an item remain when it is no longer required so that the garbage collector may recover the memory.
• Memory Leaks: Be cautious with long-lived objects or static references that might unintentionally hold onto objects, preventing them from being garbage collected.
• For large or frequently changing strings, use StringBuilder or StringBuffer instead of regular strings to optimize memory usage and performance.

5. Using StringBuilder and StringBuffer

• StringBuilder is preferred for most cases involving string manipulation due to its speed (not thread-safe).
• StringBuffer should be used when thread safety is required.

6. Upcasting and Downcasting

• Upcasting: Assigning a subclass object to a superclass reference is safe and often used for polymorphism. 

Example:

Animal animal = new Dog();

• Downcasting: Casting a superclass reference back to a subclass type should be done with caution and usually after an instanceof check to avoid ClassCastException.

Example:

if (animal instanceof Dog) 
{ 
Dog dog = (Dog) animal;
}

7. Import and Package Statements

• Package Statements: Before any import statements appear at the start of your source file, always define your package.
• Import Statements: Prior to the class definition and following the package declaration, put imports. To maintain the cleanliness and speed of your codebase, just import the necessary items. 

8. Organizing Code

• Group related classes into packages to improve organization and avoid naming conflicts.
• Keep each class in its own file, and ensure the file name matches the public class name.

9. Use of Static and Instance Members

• For data and behavior that are shared across all instances, use static variables and methods.
• For information specific to each object, use instance variables.

10. Documentation and Readability

• Use comments and JavaDoc to explain complex logic, class responsibilities, and method purposes.
• Write self-explanatory code, good naming and structure reduce the need for excessive comments.

By following these best practices and tips, you’ll write Java code that is robust, efficient, and easy to maintain, ensuring your classes and objects work together seamlessly and your programs remain scalable and reliable.

Classes and objects in Java are the two essential components of object-oriented programming. A class lays down the blueprint for the structure and the behavior of an object; an object is a tangible instance of the class stored in memory. By having a good grip on class definition, object creation, constructor usage, and data management, you will be able to write programs that are scalable, reusable, and clean. Mastering this concept makes it easier to understand advanced OOP features like inheritance and polymorphism.

Points to Remember

• A class is a blueprint, and an object is its real instance. The class defines the structure, and the object holds actual data.
• Use the new keyword to create an object in Java, which allocates memory in the heap and initializes the object.
• Each object has its own state and identity, even if created from the same class; objects store separate data.
• Constructors initialize objects they assign initial values to instance variables when an object is created.
• Encapsulation is key keep instance variables private and using getter/setter methods for controlled access.

1. What is the main difference between a class and an object in Java?

Essentially, a class is a blueprint that outlines properties and methods, whereas an object is a real instance of that class with specific values.

2. How do you create an object in Java?

An object is created by invoking the constructor of the class using the new keyword, e. g. , Student s = new Student();.

3. Why are constructors important in Java classes?

Constructors set up the new objects by giving initial values to instance variables at the time of creation.

4. What is an array of objects in Java?

An array of objects stores multiple instances of a class in a single array, making it easier to manage and process related data.

5. Why should class variables be kept private?

Keeping variables private supports encapsulation, protects data from unauthorized access, and improves code security and maintainability.