{"id":2275,"date":"2026-01-07T06:12:26","date_gmt":"2026-01-07T11:12:26","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=2275"},"modified":"2026-01-07T06:12:29","modified_gmt":"2026-01-07T11:12:29","slug":"interfaces-abstract-classes","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/interfaces-abstract-classes\/","title":{"rendered":"Interfaces and Abstract classes"},"content":{"rendered":"

Abstract classes<\/b><\/h2>\n

In Java language<\/a>, which is covered extensively in a java full stack developer course<\/a>, an abstract class is a class that cannot be instantiated and may or may not contain abstract methods. Both abstract classes and methods are marked with the abstract keyword. Here is an example:<\/p>\n

public abstract<\/span>\u00a0<\/span>class<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\/\/ declare fields<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0String\u00a0<\/span>color<\/span>;<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\/\/declare non-abstract methods<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0String getColor() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>return<\/span>\u00a0<\/span>color<\/span>;<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>void<\/span>\u00a0walk();<\/span><\/p>\n

}<\/span><\/p>\n

As you can see, an abstract method is a method definition without braces and followed by a semicolon. It does not have an implementation. This code doesn’t compile:<\/span><\/p>\n

public abstract class<\/span>\u00a0Chicken {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>void<\/span>\u00a0peck() {};\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

If you want to have default implementation of a method in your abstract class, you have to use non-abstract methods.
\n<\/span>Nonabstract classes cannot contain abstract methods. This code does not compile:<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0Chicken {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>void<\/span>\u00a0peck();\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

Abstract classes cannot be instantiated, but we can create a subclass of them. Subclasses <\/a>usually provide an implementation for the abstract methods of the superclass. If they don’t provide implementation, then they have to be declared also as abstract:<\/span><\/p>\n

public abstract<\/span>\u00a0<\/span>class<\/span>\u00a0Mammal\u00a0<\/span>extends<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>void<\/span>\u00a0walk();<\/span><\/p>\n

}<\/span><\/p>\n

public class<\/span>\u00a0Cat\u00a0<\/span>extends<\/span>\u00a0Mammal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0walk() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“The cat uses 4 four limbs for a walk”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>};<\/span><\/p>\n

}<\/span><\/p>\n

In abstract classes, you can declare fields with or without static and final modifiers. And concrete methods can be not just public, but also default, protected or private.<\/span><\/p>\n

Abstract classes cannot have modifier final. The reason is obvious. Abstract classes are created to be extended by subclasses. The modifier final prohibit class to have subclasses. The following code doesn’t compile:<\/span><\/p>\n

public<\/span>\u00a0<\/span>final<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>class<\/span>\u00a0<\/span>Tortoise<\/span>\u00a0{\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

For the same reason, abstract methods cannot be marked as final. For the same reason, abstract methods cannot be marked as final. Let’s assume that you use modifier final for method. Not it cannot be overridden in subclasses. Therefore, subclasses cannot be concrete. They will be abstract and cannot be instantiated. This code does not compile:<\/span><\/p>\n

public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>class<\/span>\u00a0Cat {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>final<\/span>\u00a0<\/span>void<\/span>\u00a0meow();\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

Also, abstract methods cannot be private. Think a bit and you will understand the reason. Abstract private methods cannot be accessed from another class. Consequently, subclasses of your abstract class that has a private method cannot see it and override it cannot override it. So, this rule makes sense. An example:<\/span><\/p>\n

public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>class<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>private<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>void<\/span>\u00a0run();\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0Panther\u00a0<\/span>extends<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>private<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0}<\/span><\/p>\n

}<\/span><\/p>\n

The method run() from the class Animal is not visible for the class Panther. This means, that the method would be not be overridden by the method run() of the class Panther. The method run() form Animal is unreachable from all classes, except its own class.\u00a0<\/span><\/p>\n

Let’s try to change the methods modifiers to protected:<\/span><\/p>\n

public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>class<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>protected<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>void<\/span>\u00a0run();\u00a0<\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0Panther\u00a0<\/span>extends<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>protected<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0}<\/span><\/p>\n

}<\/span><\/p>\n

Now, this code will work.<\/span><\/p>\n

It is important to remember that non-abstract subclasses have to implement all the abstract methods of the abstract superclass. You can extend an abstract class with another abstract class:<\/span><\/p>\n

public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>class<\/span>\u00a0<\/span>Animal<\/span>\u00a0{<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>public<\/span>\u00a0<\/span>abstract<\/span>\u00a0String getName();<\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0<\/span>Monkey<\/span>\u00a0<\/span>extends<\/span>\u00a0Animal {\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>abstract<\/span>\u00a0<\/span>class<\/span>\u00a0<\/span>Dog<\/span>\u00a0<\/span>extends<\/span>\u00a0Animal {<\/span><\/p>\n

}<\/span><\/p>\n

Interfaces<\/b><\/h2>\n

An interface is one of the ways to achieve abstraction in Java language. It can have fields method declarations and methods, but cannot be instantiated. Here is an example of interface:<\/span><\/p>\n

interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>void<\/span>\u00a0run();\u00a0<\/span><\/p>\n

}<\/span><\/p>\n

Usually, it does not make sense to have variables in interfaces. More practically is to include constants.\u00a0 All fields in an interface are public, even without the use of the access modifier:<\/span><\/p>\n

interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>static<\/span>\u00a0<\/span>final<\/span>\u00a0String\u00a0<\/span>name<\/span>\u00a0=\u00a0<\/span>“Wiki”<\/span>;<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0String\u00a0<\/span>color<\/span>\u00a0=\u00a0<\/span>“white”<\/span>;<\/span><\/p>\n

}<\/span><\/p>\n

Interfaces contain declarations of methods. After JDK 8, there is a possibility to include methods with implementation, they have to be static or default. After JDK 9,\u00a0 methods in interfaces can be also private. For example:<\/span><\/p>\n

interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>default<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>jump();<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>private<\/span>\u00a0<\/span>void<\/span>\u00a0jump() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is jump!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

As you can see, there is just one reason to create private methods, they can be used in other methods of their interface.<\/span><\/p>\n

Implementing interfaces<\/b><\/h2>\n

For interface implementation, the keyword implements are used. Let’s look at the example:<\/span><\/p>\n

public\u00a0<\/span>interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>public\u00a0<\/span>void<\/span>\u00a0run();<\/span><\/p>\n

}<\/span><\/p>\n

public\u00a0<\/span>class<\/span>\u00a0Monkey\u00a0<\/span>implements<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

The class has to implement all defined methods of the interface.\u00a0 If it does not implement all methods, you have to declare it as abstract. This code snippet will compile because class Monkey is abstract:<\/span><\/p>\n

public\u00a0<\/span>interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>public\u00a0<\/span>void<\/span>\u00a0run();<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0<\/span>public\u00a0<\/span>String getName();<\/span><\/p>\n

}<\/span><\/p>\n

abstract<\/span>\u00a0<\/span>class<\/span>\u00a0Monkey\u00a0<\/span>implements<\/span>\u00a0Animal {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

Any class can implement any number of interfaces. In this case, the names of all interfaces must be comma-separated. If your class is concrete it has to provide all methods from all interfaces that it implements. Here is an example:<\/span><\/p>\n

public<\/span>\u00a0<\/span>interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public\u00a0<\/span>void<\/span>\u00a0run();<\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>interface<\/span>\u00a0Mammal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>interface<\/span>\u00a0BananaLover {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public\u00a0<\/span>void<\/span>\u00a0eatBanana();<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

public<\/span>\u00a0<\/span>class<\/span>\u00a0Monkey\u00a0<\/span>implements<\/span>\u00a0Animal, Mammal, BananaLover {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0eatBanana() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is eating banana!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

Interfaces<\/a> cannot be marked as final, because it cannot be instantiated directly. The keyword final prohibits inheritance.<\/span><\/p>\n

One interface can extend another interface or interfaces. In this case, the interface inherits all of the abstract methods as its own abstract methods. A concrete class that implements an interface has to implement all inherited by the interface declarations of methods:<\/span><\/p>\n

interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0run();<\/span><\/p>\n

}<\/span><\/p>\n

interface<\/span>\u00a0Mammal\u00a0<\/span>extends<\/span>\u00a0Animal{<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

interface<\/span>\u00a0BananaLover\u00a0<\/span>extends<\/span>\u00a0<\/span>Mammal<\/span>{<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0eatBanana();<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

class<\/span>\u00a0Monkey\u00a0<\/span>implements<\/span>\u00a0BananaLover {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0eatBanana() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is eating banana!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

One interface can extend multiple interfaces:<\/span><\/p>\n

interface<\/span>\u00a0Monkey\u00a0<\/span>extends<\/span>\u00a0Animal,\u00a0<\/span>Mammal, BananaLover{ \u00a0 \u00a0\u00a0<\/span><\/p>\n

}<\/span><\/p>\n

All interface variables are public, static and final. Therefore, they have to be initialized. If you try to define variable as private or protected the compiler error will be generated. You can skip public static, final modifiers for variables <\/a>in interface.<\/span><\/p>\n

public<\/span>\u00a0<\/span>interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>String\u00a0<\/span>NAME<\/span>\u00a0=\u00a0<\/span>“Wiki”<\/span>;<\/span><\/p>\n

}<\/span><\/p>\n

This is equal to this code snippet:<\/span><\/p>\n

public<\/span>\u00a0<\/span>interface<\/span>\u00a0<\/span>Animal<\/span>\u00a0{<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public static final String\u00a0<\/span>NAME<\/span>\u00a0=\u00a0<\/span>“Wiki”<\/span>;<\/span><\/p>\n

}<\/span><\/p>\n

Default interface methods.<\/b><\/h2>\n

Starting from JDK 8, there is a possibility to provide a default implementation to methods in interfaces. This type of methods is called a default:<\/span><\/p>\n

public<\/span>\u00a0<\/span>interface<\/span>\u00a0<\/span>Animal<\/span>\u00a0{<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>default<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

Classes that implement this interface can override this default to implementation or can provide their own.<\/span><\/p>\n

We can have a situation with two interfaces that have default methods with the same signature. Let’s assume that some class implements both interfaces. This code does not compile:<\/span><\/p>\n

interface<\/span>\u00a0Animal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>default<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

interface<\/span>\u00a0Mammal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>default<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

class<\/span>\u00a0Monkey\u00a0<\/span>implements<\/span>\u00a0Animal, Mammal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\/\/DOES NOT COMPILE<\/span><\/p>\n

}<\/span><\/p>\n

In this case, the compiler will ask to override the method run() in class that implements Animal and Mammal interfaces. This code will compile:<\/span><\/p>\n

class<\/span>\u00a0Monkey\u00a0<\/span>implements<\/span>\u00a0Animal, Mammal {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>@Override<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0run() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Animal is running!”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

Static interface methods<\/b><\/h2>\n

Since JDK 8, there is a possibility to create static methods in interfaces. It works the same as static methods in classes. Static interface methods cannot be inherited. Thi code does not compile:<\/span><\/p>\n

interface<\/span>\u00a0Jump {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>static<\/span>\u00a0<\/span>int<\/span>\u00a0getHeight() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>return<\/span>\u00a01;<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

class<\/span>\u00a0Kangaroo\u00a0<\/span>implements<\/span>\u00a0Jump {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>public<\/span>\u00a0<\/span>void<\/span>\u00a0jump() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Jumping height “<\/span>\u00a0+\u00a0<\/span>getHeight<\/span>());\u00a0<\/span>\/\/ DOES NOT COMPILE<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

To fix this code you need to use the interface name when you use static method:<\/span><\/p>\n

public<\/span>\u00a0<\/span>void<\/span>\u00a0jump() {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Jumping height “<\/span>\u00a0+\u00a0<\/span>Jump.<\/span>getHeight<\/span>());<\/span><\/p>\n

}<\/span><\/p>\n

Now, the code will work.<\/span><\/p>\n

Nested interfaces<\/b><\/h2>\n

In Java language is possible to create an interface inside another interface. The syntax of the interface and its implementation will look like this:<\/span><\/p>\n

interface<\/span>\u00a0OuterInterface {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>interface<\/span>\u00a0Inner<\/span>Interface<\/span>\u00a0<\/span>{<\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

class<\/span>\u00a0ImplementingClass\u00a0<\/span>implements<\/span>\u00a0Outer<\/span>Interface<\/span>.InnerInterface {<\/span><\/p>\n

}<\/span>\u00a0<\/span><\/p>\n

We can also create declare an interface inside a class:<\/p>\n

class<\/span>\u00a0OuterClass {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>interface<\/span>\u00a0InnerInterface {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n

class<\/span>\u00a0ImplementingClass\u00a0<\/span>implements<\/span>\u00a0OuterClass.InnerInterface {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

}<\/span><\/p>\n

Functional interfaces<\/b><\/h2>\n

Functional interfaces are any interfaces that contain just one abstract method. Its implementation can be a lambda expression. Default and static methods do not count as abstract. You must use the annotation FunctionalInterface for such kind of interfaces:<\/span><\/p>\n

@FunctionalInterface<\/span><\/p>\n

interface<\/span>\u00a0MyFunctionalInterface {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>void<\/span>\u00a0testMethod();<\/span><\/p>\n

}<\/span><\/p>\n

class<\/span>\u00a0ImplementingClass {<\/span>\u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>void<\/span>\u00a0main(String\u00a0<\/span>arg<\/span>[]) {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>MyFunctionalInterface\u00a0<\/span>functionalInterface<\/span>\u00a0= () -> {<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>System.<\/span>out<\/span>.println(<\/span>“Lambda in action”<\/span>);<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>\u00a0 \u00a0\u00a0<\/span><\/span>};<\/span><\/p>\n

\u00a0 \u00a0\u00a0<\/span><\/span>}<\/span><\/p>\n

}<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

Abstract classes In Java language, which is covered extensively in a java full stack developer course, an abstract class is a class that cannot be instantiated and may or may not contain abstract methods. Both abstract classes and methods are marked with the abstract keyword. Here is an example: public abstract\u00a0class\u00a0Animal { \u00a0 \u00a0\u00a0\/\/ declare […]<\/p>\n","protected":false},"author":1,"featured_media":2409,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[42],"tags":[451,454,450,58,453,452],"class_list":["post-2275","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-tutorials","tag-abstract-class","tag-functional-interfaces","tag-interfaces","tag-java","tag-nested-interfaces","tag-static-interface"],"_links":{"self":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2275","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/comments?post=2275"}],"version-history":[{"count":1,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2275\/revisions"}],"predecessor-version":[{"id":33910,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2275\/revisions\/33910"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media\/2409"}],"wp:attachment":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media?parent=2275"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/categories?post=2275"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/tags?post=2275"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}