How can interface achieve 100% abstraction in Java?

Question

I have this conceptual query. We say Interface is used to achieve 100% abstraction i.e. hide all the implementation.

But in Interface, all the methods are declared abstract. There is no implementation.

And when the other class implements the same interface then there is no more abstraction as the implementation is defined in the class which implements it.

Please throw some light on it.

Answer 1

You have a missconception about the abstraction interfaces provide.

1. What is an interface?
An interface is a type ob object containing only (public) method signatures (Can vary from language to language). It provides no implementation (function body) of those methods. It can be seen as a kind of contract an implementing class has to fullfil.

2. What kind of abstraction can be achieved by using interfaces?

(Created with 'Violet UML Editor')

In this structure the class User only knows that the objects in the objects-array have a method with the signature void Display(). How this method is actually implemented is unnknown to User.

The abstraction happening is depicted by the red line. This is the only (pretty powerful) abstraction achieved by interfaces.

The implementation details of the various variants of void Display() are hidden from User. It can just call IDisplayable.Display() and through polymorphism the correct method gets called.

Answer 2

I would like to explain the difference in non programming language.

Assume that you have TV and a Remote. By Remote, you can operate with TV.

Remote had On and Off buttons. When you click on On button, TV will switch on. But you don't know internals of On button implementation . Same is the case with Off button, which switches off TV.

Now Remote is an interface and TV is an implementation object. Map same concepts in java programming language and you will get more clarity.

Remote is interface with On and Off methods. TV implements Remote interface.

Abstraction is hiding details and TV has achieved it. Even in absence of Remote interface, TV can have On and Off buttons and hides the details.

Interface with abstract methods is not necessary to define abstraction. But interface is pure abstract and hides the details of implementation. It exposes contract by hiding internal implementation of implementor.

Have a look at related question

Abstraction VS Information Hiding VS Encapsulation

Answer 3

This statement is true in the following sense:

When we use an interface implementation as an instance of an interface, the implementation is indeed hidden, i.e. there can actually be object of any implementation.

The example:

public <T> Set<T> listToSet(List<T> list) {
    HashSet<T> result = new HashSet<>();
    for (T t: list) {
        result.add(t);
    }
    return result;
}

Here the implications are:

1. The caller can pass any List<T> implementation, and the implementation is hidden from the method's intrinsics, it just knows that what is passed is a List<T>, thus it can be iterated over.

2. The method returns a Set<T>, and the concrete implementation is hidden from the caller, there can be any Set<T> implementation (HashSet<T> in the example).

So, the statement about 100% abstraction is true for the cases when the declared type for a variable or a return type is interface.

Answer 4

In Java interfaces can't contain implementation to ensure the abstraction (but this is not a general OOP requirement), thus when you manipulate an object through an interface type you can't rely on any implementation.

In modern Java, you can provide some default implementation to methods, which is not contradictory with abstraction because you can't use attributes, so the provided code is only "functional" in the sense it only describes generic behavior.

On the other end you have concrete classes that provide full implementation of some interface.

In between you have abstract classes, that provide partial implementation.

A good practice is to hide implementation by:

• providing interface to the user of the concepts
• providing factories to hide the reality of concrete classes

Of course this is an ideal.

Answer 5

I think if don't know anything about implementation just we have requirement specification then we should go for interface and inside interface every method is public and abstract whether declare or not hence interface is also considered 100% pure abstract class

Answer 6

I think below programme will help you to understand about interface and abstraction:

  interface Person{
   void dsplay();
}
class Student implements Person{
   public void dsplay() {
      System.out.println("This is display method of the Student class");
   }
}
class Lecturer implements Person{
   public void dsplay() {
      System.out.println("This is display method of the Lecturer class");
   }
}
public class AbstractionExample{
   public static void main(String args[]) {
      Person person1 = new Student();
      person1.dsplay();
      Person person2 = new Lecturer();
      person2.dsplay();
   }
}