Mastering Classes and Objects: Step-by-Step for Beginners

Object Oriented Programming Fundamentals (4 Part Series)

1 Unlocking the Power of OOP in Java: A Beginner’s Guide
2 OOP Simplified: Breaking Down the 4 Core Principles
3 Encapsulation and Abstraction in Object-Oriented Programming (OOP)
4 Mastering Classes and Objects: Step-by-Step for Beginners

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

Enter fullscreen mode Exit fullscreen mode

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
}

Enter fullscreen mode Exit fullscreen mode

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");
}

Enter fullscreen mode Exit fullscreen mode

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
    }
}

Enter fullscreen mode Exit fullscreen mode

---

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;
    }
}

Enter fullscreen mode Exit fullscreen mode

usage:

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

Enter fullscreen mode Exit fullscreen mode

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.

final class Constants {
    static final double PI = 3.14159;
}

Enter fullscreen mode Exit fullscreen mode

---

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 Student {
    String name;
    int age;

    Student setName(String name) {
        this.name = name;
        return this;
    }

    Student setAge(int age) {
        this.age = age;
        return this;
    }
}

Enter fullscreen mode Exit fullscreen mode

usage:

Student student = new Student().setName("Alice").setAge(20);

Enter fullscreen mode Exit fullscreen mode

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:

class Singleton {
    // Step 1: Create a private static instance of the class
    private static Singleton instance;

    // Step 2: Make the constructor private
    private Singleton() {
        System.out.println("Singleton Instance Created");
    }

    // Step 3: Provide a public static method to get the instance
    public static Singleton getInstance() {
        if (instance == null) { // Check if instance is not already created
            instance = new Singleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance(); // Creates the instance
        Singleton obj2 = Singleton.getInstance(); // Returns the same instance

        System.out.println(obj1 == obj2); // Output: true (both refer to the same instance)
    }
}

Enter fullscreen mode Exit fullscreen mode

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:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        System.out.println(list);
    }
}

Enter fullscreen mode Exit fullscreen mode

---

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!

Object Oriented Programming Fundamentals (4 Part Series)

1 Unlocking the Power of OOP in Java: A Beginner’s Guide
2 OOP Simplified: Breaking Down the 4 Core Principles
3 Encapsulation and Abstraction in Object-Oriented Programming (OOP)
4 Mastering Classes and Objects: Step-by-Step for Beginners

原文链接：Mastering Classes and Objects: Step-by-Step for Beginners