Interfaces & Abstract Classes

Interface Java’s interfaces are an improvement over multiple inheritance mechanism of C++. While designing a software system in java, Interfaces help us defining the interfaces between the components. Interfaces help us achieve a special kind of multiple inheritance : multiple inheritance of interfaces without multiple inheritance of implementation.

Which is a better design pattern? Multiple inheritance of interfaces or Multiple inheritance of classes (implementations). Interfaces solve Diamond Problem with traditional multiple inheritance.

abstract class Animal { abstract void talk(); } class Frog extends Animal { void talk() { System.out.println("Ribit, ribit."); } } class Dinosaur extends Animal { void talk() { System.out.println("Oh I'm a dinosaur and I'm OK..."); } } // This won't compile, of course, because //Java only supports single inheritance. class Frogosaur extends Frog, Dinosaur { } Animal animal = new Frogosaur(); animal.talk(); When we think of objects, We assume it as programmatic representations of real-world entities. Confused, isn’t it ?

Think Animal would have declared a public instance variable, which Frogosaur would then have inherited from both Dinosaur and Frog. When referring to this variable in a Frogosaur object, which copy of the variable -- Frog's or Dinosaur's -- would have been selected? We solve all these ambiguities in software design using interfaces in Java. Through interfaces, Java allows multiple inheritance of interfaces but not of implementations. Implementation, which includes instance variables and method implementations, is always singly inherited.

Interfaces & Polymorphism We learned, Interface is the Java’s way to solve diamond problem. But is this the only benefit?? Interface also lets us take greater advantage of polymorphism in our designs, which in turn helps us make our software more flexible.

What’s this Polymorphism? A greek word meaning many shapes. In context of Java, a class has many forms: that of the class and any of its subclasses. An Animal, for example, can look like a Dog or a Cat or any other subclass of Animal. It also means using a superclass variable to refer to a subclass object. For Ex:- abstract class Animal { abstract void talk(); } class Dog extends Animal { void talk() { System.out.println("Woof!"); } } class Cat extends Animal { void talk() { System.out.println("Meow."); } } class Interrogator { static void makeItTalk(Animal subject) { subject.talk(); } }

Polymorphism contd. Types : 2 1. Compile-time Polymorphism 2. Runtime Polymorphism Think, In the previous ex. the compiler knows only : an object of some Animal subclass will be made available to makeItTalk(). It means, JVM will decide at runtime which method to invoke based on the class. How is our program going to be flexible this way? Think of adding some more classes as the one below ….. class Bird extends Animal { void talk() { System.out.println("Tweet, tweet!"); } } Do we need to change the makeItTalk() method??

Polymorphism contd. Getting more Polymorphism: Interfaces give us more polymorphism than singly inherited families of classes, because with interfaces we don't have to make everything fit into one family of classes. interface Talkative { void talk(); } abstract class Animal implements Talkative { abstract public void talk(); } class Dog extends Animal { public void talk() { System.out.println("Woof!"); } } class Cat extends Animal { public void talk() { System.out.println("Meow."); } } class Interrogator { static void makeItTalk(Talkative subject) { subject.talk(); } }

Polymorphism contd. Here is the magic!! class Clock { } class CuckooClock implements Talkative { public void talk() { System.out.println("Cuckoo, cuckoo!"); } } class Test { public static void main(String[] args) { CuckooClock cc = new CuckooClock(); Interrogator.makeItTalk(cc); } }

Polymorphism contd. Conclusion :- With single inheritance only, we'd either have to somehow fit CuckooClock into the Animal family, or not use polymorphism. With interfaces, any class in any family can implement Talkative and be passed to makeItTalk(). This is why we say interfaces provide more polymorphism than we can get with singly inherited families of classes.

Using Interfaces Variables declared in the interfaces are implicitly public, static & final. Methods declared in the interfaces are implicitly public & abstract. Following modifiers can’t be applied to the methods declared in an interface :- private, protected, static, final, synchronized Variables declared in an interface can’t be private or protected. An interface can extend one or more interfaces. One or more interfaces can be implemented in a class.

Interfaces & Abstract Classes

Recommended

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to Interfaces & Abstract Classes (20)

More from Bharat17485 (12)

Recently uploaded (20)