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.
final class Constants {
static final double PI = 3.14159;
}
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;
}
}
usage:
Student student = new Student().setName("Alice").setAge(20);
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)
}
}
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);
}
}
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!
Top comments (0)