In Java, classes are the blueprint for creating objects. They define the properties (fields) and behaviors (methods) of objects. Depending on their purpose and usage, Java provides several types of classes. Understanding these class types helps developers structure their programs effectively. Let’s explore the primary types of classes in Java.
1. Regular Classes
These are the most common types of classes used in Java. A regular class defines fields and methods that describe the behavior and state of an object.
Example:
public class Person {
String name;
int age;
public void introduce() {
System.out.println("Hi, my name is " + name + " and I am " + age + " years old.");
}
}
- Usage: Regular classes are used for defining reusable objects with specific attributes and methods.
2. Abstract Classes
An abstract class cannot be instantiated directly. It serves as a base class and often includes one or more abstract methods (methods without implementation).
Example:
abstract class Animal {
abstract void sound(); // Abstract method
public void sleep() {
System.out.println("Sleeping...");
}
}
class Dog extends Animal {
public void sound() {
System.out.println("Woof Woof");
}
}
- Usage: Abstract classes are used when you want to provide partial implementation that subclasses must complete.
3. Final Classes
A final class cannot be subclassed. This is useful when you want to prevent modification of the class behavior.
Example:
final class Constants {
public static final double PI = 3.14159;
}
- Usage: Final classes are often used for utility or constant definitions where inheritance is unnecessary or undesirable.
4. Static Classes
Java does not support standalone static classes like some other languages, but you can have static nested classes. A static nested class is defined within another class and can be accessed without creating an instance of the enclosing class.
Example:
class Outer {
static class Nested {
public void display() {
System.out.println("This is a static nested class.");
}
}
}
- Usage: Static nested classes are useful for logically grouping classes that are closely related.
5. Inner Classes
An inner class is defined within another class and has access to all its members, even private ones.
Example:
class Outer {
private String message = "Hello from the outer class!";
class Inner {
public void display() {
System.out.println(message);
}
}
}
- Usage: Inner classes are used when you need access to the enclosing class’s members or want to logically associate two classes.
6. Anonymous Classes
Anonymous classes are classes without a name. They are declared and instantiated at the same time, often to override methods or implement interfaces.
Example:
interface Greeting {
void sayHello();
}
public class Main {
public static void main(String[] args) {
Greeting greet = new Greeting() {
public void sayHello() {
System.out.println("Hello from an anonymous class!");
}
};
greet.sayHello();
}
}
- Usage: Anonymous classes are typically used for short-lived purposes, such as event handling or simple customizations.
7. Singleton Class
A singleton class ensures that only one instance of the class exists throughout the application. This is achieved by making the constructor private and providing a static method to access the instance.
Example:
class Singleton {
private static Singleton instance;
private Singleton() {} // Private constructor
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
- Usage: Singleton classes are used for managing resources like database connections or configuration settings.
8. POJO Classes
Plain Old Java Object (POJO) classes are simple classes with private fields, public getter and setter methods, and no specific framework dependencies.
Example:
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
- Usage: POJOs are commonly used for data storage and transfer.
9. Data Classes (Record)
Introduced in Java 14, records are a type of class designed to represent immutable data. They automatically generate constructors, getters, equals(), hashCode(), and toString() methods.
Example:
public record Point(int x, int y) {}
- Usage: Records simplify creating classes that are purely for holding data.
10. Wrapper Classes
Java provides wrapper classes to convert primitive types into objects. For example, Integer wraps the primitive int.
Example:
int num = 10;
Integer numObject = Integer.valueOf(num);
- Usage: Wrapper classes are essential when working with collections that only accept objects (like
ArrayList).
Java provides a wide variety of class types to suit different programming needs. From regular and abstract classes to newer features like records, each type has a unique role. Understanding these types can help you write cleaner, more efficient, and maintainable code. Whether you’re creating simple data objects or building complex systems, there’s a Java class type that fits your use case.