Java Programming Classes And Objects Complete Guide

Chapter: Java Programming - Classes and Objects

Introduction

In Java, everything is associated with classes and objects. A class is like a blueprint or a template for creating objects while an object is an instance of a class.

1. Writing a Simple Class

Let’s start by writing a simple class in Java.

Example Code:

// Define a class named 'Car'
public class Car {
    // Declaring fields (or variables) of the class
    String color;
    String model;

    // Constructor method to initialize values
    public Car(String carColor, String carModel) {
        color = carColor;
        model = carModel;
    }

    // Method to display information about the car
    public void displayInfo() {
        System.out.println("Car Model: " + model);
        System.out.println("Car Color: " + color);
    }
}

Explanation:

• Here, we define a class Car with two fields: color and model.
• A constructor Car(String carColor, String carModel) is provided to initialize these fields.
• A method displayInfo() is used to print out the details of the Car.

2. Creating an Object of the Class

Now let's create an object of our Car class.

Example Code:

// Define the main class
public class Main {
    public static void main(String[] args) {
        // Create an object of Car
        Car myCar = new Car("Red", "Toyota Corolla");

        // Call displayInfo method on the Car object
        myCar.displayInfo();
    }
}

Explanation:

• We create an object of the Car class called myCar. The object is initialized using the constructor method with the arguments "Red" and "Toyota Corolla".
• We then call the displayInfo() method on myCar to print its attributes.

3. Adding Methods to the Class

Methods are used to perform specific activities or functions. Let’s enhance our Car class.

Example Code:

public class Car {
    String color;
    String model;
    int year;

    // Constructor to initialize object
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    // Method to display information about the car
    public void displayInfo() {
        System.out.println("Car Model: " + model);
        System.out.println("Car Color: " + color);
        System.out.println("Car Year: " + year);
    }

    // Method to change the color of the car
    public void repaint(String newColor) {
        color = newColor;
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Red", "Toyota Corolla", 2021);  
        myCar.displayInfo();  // Output before repainting

        myCar.repaint("Blue");  // Change the color
        myCar.displayInfo();  // Output after repainting
    }
}

Explanation:

• A new field year has been added to our Car class.
• The constructor now accepts three parameters for initialization.
• Another method repaint(String newColor) is introduced to modify the color attribute.

4. Access Modifiers

Access modifiers control the visibility of classes, fields, methods, and constructors. Common access modifiers are:

• public: can be accessed from anywhere.
• private: can only be accessed within its own class.
• If no modifier is specified, it becomes default, which means accessible within the same package.

Let's create a class with private fields and public methods to manipulate them.

Example Code:

public class Car {
    // Private fields
    private String color;
    private String model;
    private int year;

    // Constructor to initialize object
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    // Getter for color field
    public String getColor() {
        return color;
    }

    // Setter for color field
    public void setColor(String newColor) {
        color = newColor;
    }

    // Method to display information about the car
    public void displayInfo() {
        System.out.println("Car Model: " + model);
        System.out.println("Car Color: " + color);
        System.out.println("Car Year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Red", "Toyota Corolla", 2021);
        myCar.displayInfo();  // Display initial info

        // Repaint the car using setter method
        myCar.setColor("Blue");
        System.out.println("Updated Color: " + myCar.getColor());

        myCar.displayInfo();  // Display updated info
    }
}

Explanation:

• Fields color, model and year are declared as private inside Car class.
• Public getter and setter methods provide controlled access to the fields.
• In Main class, we use setter and getter to change and retrieve the color.

5. Static Variables and Methods

Static members belong to the class rather than any specific instance.

Example Code:

public class Car {
    // Non-static fields
    String color;
    String model;
    int year;

    // Static variable shared among all instances
    private static int numberOfCars = 0;

    // Constructor method with counter increment
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
        numberOfCars++;  // Increment count each time a Car is created
    }

    // Non-static method to display information about the car
    public void displayInfo() {
        System.out.println("Car Model: " + model);
        System.out.println("Car Color: " + color);
        System.out.println("Car Year: " + year);
    }

    // Static method to display the number of cars created
    public static void displayTotalCars() {
        System.out.println("Total Cars Created = " + numberOfCars);
    }
}

public class Main {
    public static void main(String[] args) {
        // Create three Car objects
        Car car1 = new Car("Red", "Toyota Corolla", 2021);
        Car car2 = new Car("Black", "Honda Accord", 2022);
        Car car3 = new Car("White", "Ford Fiesta", 2023);

        car1.displayInfo();  // Display car1 attributes
        Car.displayTotalCars();  // Display the total cars created so far
    }
}

Explanation:

• numberOfCars is a static variable shared across all instances of Car.
• Every time a new Car object is created, numberOfCars is incremented.
• The static method displayTotalCars() provides a way to check the total count of Car instances.

6. Inheritance

Inheritance allows a class to inherit fields and methods from another class.

Example Code:

// Superclass
public class Vehicle {
    protected String make; // Accessible to subclasses and classes within the same package

    public Vehicle(String make) {
        this.make = make;
    }

    public void startEngine() {
        System.out.println(make + "'s engine started.");
    }
}

// Subclass extending Vehicle
public class Car extends Vehicle {
    private String color;
    private String model;

    public Car(String make, String color, String model) {
        super(make); // Call the superclass constructor
        this.color = color;
        this.model = model;
    }

    // Override superclass method
    @Override
    public void startEngine() {
        System.out.println(make + " " + model + "'s engine started with a Vroom!");
    }

    public void displayDetails() {
        System.out.println("Car Make: " + make);
        System.out.println("Car Model: " + model);
        System.out.println("Car Color: " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle("Toyota");
        vehicle.startEngine();  // Start Toyota engine

        Car car = new Car("Honda", "Black", "Accord");
        car.startEngine();  // Start Honda Accord engine
        car.displayDetails();  // Display Honda Accord details
    }
}

Explanation:

• Vehicle class is the superclass which contains common attributes like make and methods like startEngine().
• Car class inherits from Vehicle. It uses super(make) to call the superclass constructor.
• Car class overrides startEngine() to provide a specific implementation for cars.
• displayDetails() demonstrates how to access the inherited make field.

7. Polymorphism

Polymorphism allows methods to do different things based on object it is acting upon. Method overriding and method overloading are key concepts of polymorphism.

Example Code:

// Superclass
public class Animal {
    // Method to show what the animal does
    public void speak() {
        System.out.println("Animal speaks");
    }
}

// Subclasses inheriting from Animal
public class Dog extends Animal {
    // Overriding the speak method
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    // Overriding the speak method
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create objects of Dog and Cat
        Dog dog = new Dog();
        Cat cat = new Cat();

        // Use polymorphism to call the overridden speak methods
        dog.speak();  // Outputs "Dog barks"
        cat.speak();  // Outputs "Cat meows"

        // Create an array of Animals and populate it with Dog and Cat objects
        Animal[] animals = new Animal[2];
        animals[0] = new Dog();
        animals[1] = new Cat();

        // Loop through the array and call speak
        for(Animal animal : animals) {
            animal.speak();  // Correct method is called for each object
        }
    }
}

Explanation:

• Animal has a method speak() which is overridden in Dog and Cat.
• When calling speak() through dog or cat reference, the respective subclass method is executed (polymorphism).
• An array of Animal type can hold objects of Dog or Cat due to polymorphism.

Summary

• Classes and Objects: A class defines the blueprint for an object, and objects are instances of a class.
• Fields: Variables defined inside a class.
• Constructor: Special method used to initialize objects.
• Methods: Blocks of code that execute certain tasks, defined inside a class.
• Access Modifiers: Control the visibility of class members.
• Static Members: Shared among all objects of a class.
• Inheritance: A class can inherit methods and fields from a base (super) class.
• Polymorphism: Methods have multiple forms, allowing for more flexible use.