Introduction to Classes and Objects

In programming, a class is like a blueprint, and an object is like a house built from that blueprint. Think of a class as a plan that defines the structure and behavior of an object. An object, on the other hand, is a specific instance of that class that exists in memory. By using classes and objects, we can organize and reuse code effectively.

For example:

class Car {
    String color;
    String model;
    void start() {
        System.out.println("Car is starting");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // Object created
        myCar.color = "Red";
        myCar.start();
    }
}

Here, the Car _class is a blueprint, and _myCar is an object created from that blueprint.

Components of a Class

A class is made up of several components. Let’s break them down:

Class Name

The class name is used to identify the class. It should follow naming
conventions:

• Start with an uppercase letter.
• Use camel case (e.g., Car, StudentDetails).
• Avoid Acronyms and Abbriviation.

Attributes (Fields)

Attributes are variables inside the class that represent the properties of an object.

class Car {
    String color; // Attribute
    String model; // Attribute
}

Methods

Methods are functions inside a class that define the behavior of an object. For example, a method can make a car start:

void start() {
    System.out.println("Car is starting");
}

Return Types
Methods can return values(int,long,string etc). The void keyword is used when a method doesn’t return anything:

void displayInfo() {
    System.out.println("This is a car.");
}

Access Modifiers
Access modifiers control the visibility of class members. For detailed information, read my blog on Access Modifiers here.

Constructors
A constructor is a special method used to initialize objects. To know more about it read this.

Components of an Object

An object has three main components:

• State

The state of an object is defined by its attributes. For example, a car’s color and model define its state.

• Behavior

The behavior of an object is defined by its methods. For example, starting and stopping a car are behaviors.

• Identity

Each object has a unique identity, which is its reference or memory address in the system.

Example:

class Car {
    String color;
    void displayInfo() {
        System.out.println("Car color: " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.color = "Blue"; // State
        myCar.displayInfo(); // Behavior
    }
}

Special Components of a Class

• Static Fields and Methods

Static fields and methods belong to the class, not any specific object. For example:

class MathUtils {
    static int square(int x) {
        return x * x;
    }
}

usage:

int result = MathUtils.square(5); // No object needed

In simple word it means, you do not have to initialize a object to use the static method in a class.

• Final Classes and Variables

The final keyword is used to make variables constant, prevent method overriding, or restrict inheritance. This keyword can be used in three context:

• final variable => To create constant contact variable.
• final method => To prevent method overloading.
• final class => prevent inheritance.

class Car {
    String color;
    String model;
    void start() {
        System.out.println("Car is starting");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // Object created
        myCar.color = "Red";
        myCar.start();
    }
}

Advanced Class Concepts

Object Class

Object class in Java is present in java.lang package. Every class in Java is directly or indirectly derived from the Object class. If a class does not extend any other class then it is a direct child class of the Java Object class and if it extends another class then it is indirectly derived. It provides useful methods like:

• toString(): Converts an object to a string.

• equals(): Checks if two objects are equal.

Builder Classes

Builder classes help create objects step by step, especially when objects have many attributes:

class Car {
    String color; // Attribute
    String model; // Attribute
}

usage:

void start() {
    System.out.println("Car is starting");
}

Singleton Class
A Singleton class ensures that only one instance of the class is created throughout the program's execution. It is commonly used when you need a single, shared resource, such as a configuration manager or a database connection.

The key steps to create a Singleton class are:

Make the constructor private so no other class can instantiate it.
Create a static method to provide access to the instance.
Use a static field to hold the single instance of the class.

Example:

void displayInfo() {
    System.out.println("This is a car.");
}

Explanation:
The constructor is private, so you cannot create an object of Singleton class using new.
The getInstance() method checks if the instance is null. If it is, a new instance is created. Otherwise, the existing instance is returned.
This ensures that only one object is created, no matter how many times getInstance() is called.

In-Built Packages

Packages group related classes. Some common in-built packages in Java include:

• java.util: Contains utility classes like ArrayList, HashMap.

• java.io: Provides classes for input and output operations.

• java.lang: Includes core classes like String, Math.

Example:

class Car {
    String color;
    void displayInfo() {
        System.out.println("Car color: " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.color = "Blue"; // State
        myCar.displayInfo(); // Behavior
    }
}

Real-Life Applications of Classes and Objects

Student Management: A Student class with attributes like name, age and methods like enroll().

Bank System: A BankAccount class with attributes like balance and methods like deposit(), withdraw().

Conclusion

Classes and objects are fundamental building blocks of object-oriented programming. They help organize code, make it reusable, and represent real-world entities in software. By understanding their components and practicing with small projects, you can lay a strong foundation for mastering object-oriented programming. Happy coding!

The above is the detailed content of Mastering Classes and Objects: Step-by-Step for Beginners. For more information, please follow other related articles on the PHP Chinese website!