CODEWITHSUNDEEP
javadefault-method
Kathiresa
Kathiresa

Reputation: 441

Adding methods or not adding methods to interface?

In Java 8, we can have default implementations for methods in interfaces, in addition to declarations which need to be implemented in the concrete classes.

Is it a good design or best practice to have default methods in an interface, or did Java 8 come-up with that only to provide more support on older APIs? Should we start with using default methods in new Java 8 projects?

Please help me to understand what is good design here, in detail.

Upvotes: 11

Views: 3256

Answers (3)

Michael Gantman
Michael Gantman

Reputation: 7792

Default method in Interface has some limitations. You can not have data variables in Interface. In general the reason default methods were added for the following reason. Say in your previous version you wrote a class that implements an interface "A".In your next version you decided that it would be good idea to add a method to your interface "A". But you can not do so since any class that implements "A" now will not have that extra method and thus will not compile. This would be a MAJOR backwards compatibility breakdown. So in Java 8 you can add a default method implementation into interface so all classes that implemented old version of "A" will not be broken but will fall back on default implementation. So use this feature sparingly, only if indeed you need to expand your existing interface.

Upvotes: 0

khakishoiab
khakishoiab

Reputation: 10768

In earlier java versions it wasnt possible beacuase you had abstract classes to use concrete and declared methods only but. Java 8 introduces “Default Method” or (Defender methods) new feature, which allows developer to add new methods to the interfaces without breaking the existing implementation of these interface. It provides flexibility to allow interface define implementation which will use as default in the situation where a concrete class fails to provide an implementation for that method.

Let consider small example to understand how it works:

public interface oldInterface {
    public void existingMethod();
        default public void newDefaultMethod() {
        System.out.println("New default method"
              " is added in interface");
    }
}

The following class will compile successfully in Java JDK 8

public class oldInterfaceImpl implements oldInterface {
    public void existingMethod() {
        // existing implementation is here…
    }
}

Why Defaut Method? Reengineering an existing JDK framework is always very complex. Modify one interface in JDK framework breaks all classes that extends the interface which means that adding any new method could break millions of lines of code. Therefore, default methods have introduced as a mechanism to extending interfaces in a backward compatible way.

NOTE:

However we can achive this backward compatability.but its always recommended to use interfaces with delarations only that is what they are best used for.

For simple example if You have an interface Human_behaviour you can utilize all the actions of this interface like to_Walk(); to_Eat() ,to_Love(),to_Fight() say for example in every implementing class in a unique way for every human object.Like

One Human can Fight using Swords and another Object using guns and so forth. Thus Interface is a blessing but may always be used as per the need.

Upvotes: -1

GhostCat
GhostCat

Reputation: 140427

Prior java8, you were looking towards versioned capabilities when talking about "reasonable" ways of extending interfaces:

You have something like:

interface Capability ...

interface AppleDealer {
  List<Apples> getApples();
}

and in order to retrieve an AppleDealer, there is some central service like

public <T> T getCapability (Class<T> type);

So your client code would be doing:

AppleDealer dealer = service.getCapability(AppleDealer.class);

When the need for another method comes up, you go:

interface AppleDealerV2 extends AppleDealer { ...

And clients that want V2, just do a getCapability(AppleDealerV2.class) call. Those that don't care don't have to modify their code!

Please note: of course, this only works for extending interfaces. You can't use this approach neither to change signatures nor to remove methods in existing interfaces.

Thus: just adding a new method to an interface; and having default to implement that method right there; without breaking any existing client code is a huge step forward!

Meaning: why wouldn't you use default methods on existing interfaces? Existing code will not care. It doesn't know about the new defaulted methods.

Upvotes: 2

Related Questions