13

Java 8 interface default methods vs. non-abstract methods in abstract classes - are there any differences between the two (besides the differences of iface - class, visibility etc.)

Isn't a default method a step back in Java, meaning it's against the essence that Java has advertised for years?!

Parobay
  • 2,549
  • 3
  • 24
  • 36
  • It's a change in direction, for sure. I wouldn't call it a step back, though. – yshavit Nov 22 '13 at 07:32
  • Also, possible duplicate of [Interface with default methods vs Abstract class in Java 8](http://stackoverflow.com/questions/19998454/interface-with-default-methods-vs-abstract-class-in-java-8) – yshavit Nov 22 '13 at 07:33
  • 1
    Yeah, but the *lame*, verbose parts of Java (syntax, clear distinction between iface and class), while by some considered poor, is IMO **the** feature of Java that makes it popular, easy to reason about **and safe for corpos**.. And now they make a Scala out of Java.. I u want functional programming, grab a Haskell -.- – Parobay Nov 22 '13 at 07:34
  • ::shrug:: This strikes me as a pretty far cry from Scala, which is itself pretty far from Haskell. Java still won't have implicits, for instance, and it still will have statements and mutable state. – yshavit Nov 22 '13 at 07:37
  • @yshavit yeah, at least no implicits... – Parobay Nov 22 '13 at 07:37
  • And also, I think the toughest thing to reason about with trait-like behavior is multiple inheritance where the superclasses introduce conflicting implementations of a method. Here again Java is simpler: it doesn't allow it. – yshavit Nov 22 '13 at 07:39
  • @yshavit you can't implement 2 ifaces with default methods of same name/signature? – Parobay Nov 22 '13 at 07:41
  • 5
    Nope. If you try, Java will force you (in the class that implements both methods) to provide your own implementation. That implementation may delegate to one of the others. I believe the syntax will be something like `TheInterfaceIWant.super.theMethod(...)`. See http://www.lambdafaq.org/what-about-the-diamond-problem/ – yshavit Nov 22 '13 at 07:43
  • 1
    @yshavit thank's for the link! – Parobay Nov 22 '13 at 07:45

5 Answers5

9

non-abstract methods in abstract classes will be called when it's concrete subclass calls super() if it is overridden. So there are multiple possibilities. If method is not overridden then the super class method will be executed. if we use super() in the concrete subclass method then the overridden method with the super class method will be executed.

Where as Java 8 interface default methods are completely different. It provided a choice to the developers to implement the method in the implementing class or not. If the function is not implemented then and only then the default method will be executed.

Possible Use Case :

The most important use case for this new feature in the JDK libraries is the possibility to extend existing interfaces without breaking existing implementers: adding a new abstract method to an interface would require all implementing classes to implement that new method.(Source)

Aniket Thakur
  • 66,731
  • 38
  • 279
  • 289
4

The important thing to keep in mind is that default methods don't have access to state, only to behaviour. It is actually a great place to define reasonable, default, behaviour.

Imagine you have an interface:

public interface Plant {
    enum Pace { FAST, SLOW; }

    void grow(Pace pace);
    void growFast();
    void growSlow();
}

It seems reasonable to provide a default behaviour:

default void growFast() { grow(Pace.FAST); }
default void growSlow() { grow(Pace.SLOW); }

This is a simplistic example but shows how default methods can be helpful. In this case, the way growSlow or growFast behaves is part of the interface contract so it makes sense to define their behaviour at the interface level.

However the interface makes no assumption about how the action "grow a plant" is implemented. That could be defined in an abstract class.

assylias
  • 321,522
  • 82
  • 660
  • 783
0

Firstly Default methods allow you to add new methods to interface without breaking existing implementations.

Also take an example of Collections class which is a utility class for Collection interface right.

So using default methods we can now move all the utility methods as default implementation in the Collection itself, which will make more sense than making a separate class for such utilities.

Also you will be able to inherit methods from multiple interfaces, which could not have been done using plain abstract classes.

Narendra Pathai
  • 41,187
  • 18
  • 82
  • 120
0

the big difference is that the constructor can possibly be run in an anonymous class, possibly with checked exceptions. this prevents anonymous classes being functional interfaces, and in turn makes them unavailable to use as the basis for a lambda expression.

aepurniet
  • 1,719
  • 16
  • 24
0

The main differences are: Java 8 default methods of interfaces are public, while non-abstract (concrete) methods of abstract classes can be defined as public, protected or private. Lambda expressions got introduced in Java 8, to use lambda features we need default methods(to preserve backward compatibility), non-abstract methods of abstract classes can not serve the purpose.

Arjun Thakur
  • 351
  • 5
  • 13