Custom Classes in Java

Custom classes in Java allow developers to create their own data types by defining new classes that encapsulate state (attributes) and behavior (methods). This flexibility is fundamental to Java's object-oriented nature, enabling the creation of complex and reusable code. Here's a detailed guide on custom classes in Java, complete with examples.

What is a Class in Java?

A class in Java is a blueprint from which individual objects are created. It defines the properties (fields) and behaviors (methods) that the objects created from the class will have.

Defining a Custom Class

In Java, we use the class keyword and the class name to define a custom class. The class name should be a meaningful identifier that describes the type of object. Curly braces {} enclose the class body, which contains the definitions of the constructors, methods, and fields (behaviours) of the class.

Constructors are unique ways for initialising objects, methods specify the activities that may be performed on the objects, and fields are variables that store the contents of the object. To improve encapsulation and data concealing, access modifiers like public, private, and protected can be used to regulate the visibility and accessibility of the class members.

Here's the basic syntax:

 
public class ClassName {
    // fields
    // constructors
    // methods
}   

Fields (Attributes)

Fields, also known as member variables, are used to store data. These variables define the state of an object.

 
public class Person {
    String name;
    int age;
}   

Constructors

A constructor is a special method that is called when an object is instantiated. Constructors are used to initialize the object's state. If no constructor is defined, Java provides a default constructor.

 
public class Person {
    String name;
    int age;
    // Default constructor
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    // Parameterized constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}   

Methods

Methods define the behaviors of an object. They are used to perform operations and manipulate the object's data.

 
public class Person {
    String name;
    int age;
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Method to display the person's details
    public void display() {
        System.out.println("Name: " + this.name);
        System.out.println("Age: " + this.age);
    }
}   

Example: Custom Class

Let's create a complete example of a custom class Person with fields, constructors, and methods.

Person.java

 
public class Person {
    // Fields
    private String name;
    private int age;
    // Default constructor
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    // Parameterized constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Getter for name
    public String getName() {
        return name;
    }
    // Setter for name
    public void setName(String name) {
        this.name = name;
    }
    // Getter for age
    public int getAge() {
        return age;
    }
    // Setter for age
    public void setAge(int age) {
        this.age = age;
    }
    // Method to display person's details
    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
    // Main method to test the Person class
    public static void main(String[] args) {
        // Creating a Person object using the default constructor
        Person person1 = new Person();
        person1.display();
        // Creating a Person object using the parameterized constructor
        Person person2 = new Person("John Doe", 25);
        person2.display();
        // Modifying the person's details
        person2.setName("Jane Doe");
        person2.setAge(30);
        person2.display();
    }
}   

Output:

 
Name: Unknown
Age: 0
Name: John Doe
Age: 25
Name: Jane Doe
Age: 30

Explanation

In the Person class, fields like name and age are used to store an object's state. The class has two constructors: a parameterized constructor that allows initial values to be provided for name and age, and a default constructor that initialises both fields to "Unknown".

The class's getters and setters are methods that offer regulated access to its fields, making it possible to safely modify and retrieve their values. The object's current state is displayed by printing the person's details using the display() method.

The Person class is created, its state is changed, and its details are shown in the main() method that acts as the program's entry point and shows how objects in Java may be instantiated and interacted with.

Conclusion

In Java, custom classes are an effective means of generating new data types that contain state and behaviour. We can design objects that represent real-world entities and perform operations on their data by defining fields, constructors, and methods. Because of its modular design, Java is an adaptable and manageable language for creating sophisticated applications.

Next TopicDifference-between-java-sql-time-java-sql-timestamp-and-java-sql-date-in-java

← prev next →