Java/J2EE and SOA (324 Blogs) Become a Certified Professional
AWS Global Infrastructure

Programming & Frameworks

Topics Covered
  • C Programming and Data Structures (41 Blogs)
  • Comprehensive Java Course (2 Blogs)
  • Java/J2EE and SOA (323 Blogs)
  • Spring Framework (8 Blogs)
SEE MORE

MI-new-launch

myMock Interview Service for Real Tech Jobs

myMock-widget-banner-bg

What are the different types of Classes in Java?

Published on Oct 03,2019 1K Views
5 / 11 Blog from Objects and Classes

MI-new-launch

myMock Interview Service for Real Tech Jobs

myMock-mobile-banner-bg

myMock Interview Service for Real Tech Jobs

  • Mock interview in latest tech domains i.e JAVA, AI, DEVOPS,etc
  • Get interviewed by leading tech experts
  • Real time assessment report and video recording

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:

    • Modifiers
    • Class name
    • Keywords
    • The class body within curly brackets {}

Types of classes in JAVA

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

Output
365

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

Output

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

Output

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

Output

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

Output

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

Output

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.

Comments
0 Comments

Browse Categories

webinar REGISTER FOR FREE WEBINAR
REGISTER NOW
webinar_success Thank you for registering Join Edureka Meetup community for 100+ Free Webinars each month JOIN MEETUP GROUP

Subscribe to our Newsletter, and get personalized recommendations.