Explanation of the definition of interface inheritance as described in GoF book
- by Geek
I am reading the first chapter of the Gof book. Section 1.6 discusses about class vs interface inheritance:
Class versus Interface Inheritance
It's important to understand the difference between an object's class
and its type. An object's class defines how the object is
implemented.The class defines the object's internal state and the
implementation of its operations.In contrast,an object's type only
refers to its interface--the set of requests on which it can respond. An
object can have many types, and objects of different classes can have
the same type.
Of course, there's a close relationship between class and type. Because
a class defines the operations an object can perform, it also defines
the object's type . When we say that an object is an instance of a
class, we imply that the object supports the interface defined by the
class.
Languages like c++ and Eiffel use classes to specify both an object's
type and its implementation. Smalltalk programs do not declare the
types of variables; consequently,the compiler does not check that the
types of objects assigned to a variable are subtypes of the variable's
type. Sending a message requires checking that the class of the
receiver implements the message, but it doesn't require checking that
the receiver is an instance of a particular class.
It's also important to understand the difference between class
inheritance and interface inheritance (or subtyping). Class inheritance
defines an object's implementation in terms of another object's
implementation. In short, it's a mechanism for code and representation
sharing. In contrast,interface inheritance(or subtyping) describes when
an object can be used in place of another.
I am familiar with the Java and JavaScript programming language and not really familiar with either C++ or Smalltalk or Eiffel as mentioned here. So I am trying to map the concepts discussed here to Java's way of doing classes, inheritance and interfaces.
This is how I think of of these concepts in Java:
In Java a class is always a blueprint for the objects it produces and what interface(as in "set of all possible requests that the object can respond to") an object of that class possess is defined during compilation stage only because the class of the object would have implemented those interfaces. The requests that an object of that class can respond to is the set of all the methods that are in the class(including those implemented for the interfaces that this class implements).
My specific questions are:
Am I right in saying that Java's way is more similar to C++ as described in the third paragraph.
I do not understand what is meant by interface inheritance in the last paragraph. In Java interface inheritance is one interface extending from another interface. But I think the word interface has some other overloaded meaning here. Can some one provide an example in Java of what is meant by interface inheritance here so that I understand it better?
