A class is as important for coding in Java as it is important for us to breathe to stay alive. You may be working with a basic class in Java or you might be a beginner, don’t worry, I have got you all covered. In this article on “Types of classes in Java” will help you get in-depth knowledge about the various types of classes used in Java programming.
I’ll be discussing these following topics:
Before proceeding with the types of classes, let’s understand What are classes in Java?
What are classes in Java?
A class in Java is a template that is used to create and define objects, object data types, and methods. Classes as a whole are categories and objects are items within each category. A class declaration constitutes of the following parts:
Let us now understand the different types of classes in Java.
POJO Class
POJO stands for “Plain Old Java Object”. A class which contains only private variables and setter and getter methods to use those variables is called POJO class. It is a pure data structure that has fields and may override some methods from Object (e.g. equals) or some other interface like serializable but does not have the behavior of its own.
Properties of POJO class –
- Public setter and getter methods are a must while writing a POJO class.
- All instance variables should be private.
- It should not extend pre-specified classes.
- It should not implement pre-specified interfaces.
- Should not contain pre-specified annotations.
- It may not have a no-argument constructor.
Example
class POJO {
private int value=365;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
public class Test {
public static void main(String args[]){
POJO p = new POJO();
System.out.println(p.getValue());
}
}
Static Class
In Java, static is a keyword used to describe how objects are managed within the memory. A static object belongs specifically to the class, instead of instances of that class. The sole purpose of the class is to provide blueprints of its inherited classes. A static class can contain static members only. You cannot create an object for a static class.
Example
public class Bank
{
private static String note = "Bank";
public static class SBISavings
{
public void displayOutput()
{
System.out.println(" SBISaving is: " + note);
}
}
}
public static void main(String[] args)
{
//creating instance of static class Bank.
SBISavings bs = new Bank.SBISavings();
//calling the method
bs.displayOutput();
} Output
SBISavings is: Bank
Example: Using a Static class to add two numbers.
import java.util.Scanner;
class staticclasses
{
static int s;
// static variable
static void met(int a, int b)
{
// static method
System.out.println("static method to calculate sum");
s = x + y;
System.out.println(x + "+" + y);
// print two numbers
}
static class MyNestedClass
{
// static class
static
{
// static block
System.out.println("static block inside a static class");
}
public void disp()
{
int x1, y1;
Scanner sc = new Scanner(System.in);
System.out.println("Enter two numbers");
x1 = sc.nextInt();
y1 = sc.nextInt();
met(x1, y1);
// calling static method
System.out.println("Sum of the two numbers-" + s);
// print the result in static variable
}
}
}
public class Test
{
public static void main(String args[])
{
staticclasses.MyNestedClass mnc = new staticclasses.MyNestedClass();
// object for static class
mnc.disp();
// accessing methods inside a static class
} Output
static block inside a static class
Enter two numbers 11 13
static method to calculate sum
11+13
Sum of the two numbers-24
Concrete Class
Any normal class which does not have any abstract method or a class having an implementation for all of its methods is basically a concrete class. They cannot have any unimplemented methods. A concrete class can extend its parent class, an abstract class or implement an interface if it implements all their methods. It is a complete class that can be instantiated.
Example
public class Concrete { // Concrete Class
static int sum(int x, int y) {
return a + b;
}
public static void main(String args[]) {
int p = sum(6, 8);
System.out.println("Sum: " + p);
}
}
Sum: 14
Abstract Class
An abstract class is declared with an abstract keyword and have zero or more abstract methods. These classes are incomplete classes, therefore, to use an abstract class we strictly need to extend the abstract classes to a concrete class. It can have constructors and static methods as well. It can have final methods which will force the subclass to keep the body of the method unhung.
The above image has three classes Shape, Rectangle and Circle. The shape is abstract whereas Rectangle and Circle are concrete classes which inherit Shape class. This is because the Rectangle and Circle implement area() method.
Example code to show how Concrete class can extend an Abstract class
// Java program to illustrate concrete class
//This is an interface
interface X
{
int product(int x, int y);
}
// This is an abstract class
abstract class Product implements X
{
// this method calculates
// product of two numbers
public int product(int x, int y)
{
return x * y;
}
}
// This is a concrete class that implements
class Main extends Product
{
// main method
public static void main(String args[])
{
Main ob = new Main();
int p = ob.product(20, 10);
// print product
System.out.println("Product: " + p);
}
} Product: 200
Final Class
Once a variable, method or a class is declared as final, it’s value remains the same throughout. The final keyword in a method declaration indicates that the method cannot be overridden by any subclasses i.e., a class that has been declared final cannot be subclassed. This helps a lot while creating an immutable class like the String class. A class cannot make a class immutable without making it final.
Example
final class BaseClass {
void Display() {
System.out.print("This is the Display() method of BaseClass.");
}
}
class DerivedClass extends BaseClass { //Compile-time error - can't inherit final class
void Display() {
System.out.print("This is Display() method of DerivedClass.");
}
}
public class FinalClassDemo {
public static void main(String[] arg) {
DerivedClass d = new DerivedClass();
d.Display();
}
}
Output
cannot inherit from final BaseClass
Compile-time error – can’t inherit final class
Inner class
Inner class means the class which is a member of another class. There are four types of inner classes in java.
1) Nested Inner class
2) Method Local inner classes
3) Anonymous inner classes
4) Static nested classes
Nested Inner class
It can access any private instance variable of an outer class. Like any other instance variable, we can have access modifiers private, protected, public and default modifier.
An Example to show demonstrate Inner class:
class Outer {
// Simple nested inner class
class Inner {
public void show() {
System.out.println("This is inside a nested class method ");
}
}
}
class Main {
public static void main(String[] args) {
Outer.Inner in = new Outer().new Inner();
in.show();
}
}
This is inside a nested class method
Method Local inner classes
An inner class can be declared within a method of an outer class.
Example
class Outer {
void outerMethod() {
System.out.println("This is outerMethod");
// Inner class is local to outerMethod()
class Inner {
void innerMethod() {
System.out.println("This is innerMethod");
}
}
Inner y = new Inner();
y.innerMethod();
}
}
class MethodDemo {
public static void main(String[] args) {
Outer x = new Outer();
x.outerMethod();
}
}
This is outerMethod
This is innerMethod
Anonymous inner classes
Anonymous inner classes are declared without any name. They can be created in two ways.
Example: As a subclass of a specified type
class Demo {
void show() {
System.out.println("This is show method of super class");
}
}
class FlagDemo {
// An anonymous class with Demo as base class
static Demo d = new Demo() {
void show() {
super.show();
System.out.println("This is Flag1Demo class");
}
};
public static void main(String[] args){
d.show();
}
)
Output
This is show method of a superclass
This is Flag1Demo class
In the above code, there are two class Demo and FlagDemo. Here demo acts as a superclass and anonymous class acts as a subclass and both classes have a method show(). In the anonymous class show(), the method is overridden.
Example: As an implementer of the specified interface
class Flag2Demo {
// An anonymous class that implements Hello interface
static Hello h = new Hello() {
public void show() {
System.out.println("This is an anonymous class");
}
};
public static void main(String[] args) {
h.show();
}
}
interface Hello {
void show();
}
This is an anonymous class
Static nested classes
Static nested classes are like a static member of the outer class.
class Outer {
private static void outerMethod() {
System.out.println("inside outerMethod");
}
// A static inner class
static class Inner {
public static void main(String[] args) {
System.out.println("inside inner class Method");
outerMethod();
}
}
}
Output
inside inner class Method
inside outerMethod
This brings us to the end of this ‘Types of Classes in Java’ article. You have learned about the different types of Classes present in Java along with a few examples.
If you find this “Types of Classes in Java” article relevant, check out the Java Certification Training by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe. Edureka’s Java J2EE and SOA training and certification course is designed for students and professionals who want to be a Java Developer. The course is designed to give you a head start into Java programming and train you for both core and advanced Java concepts along with various Java frameworks like Hibernate & Spring.
Got a question for us? Please mention it in the comments section of this “Types of Classes in Java” blog and we will get back to you as soon as possible.