CODEWITHSUNDEEP
javainheritanceinterface
Mirrana
Mirrana

Reputation: 1731

Extending an object vs Implementing an interface

Trying to understand a question I got wrong on a test:

How does inheritance differ from implementing interfaces?

  1. With inheritance, a class gains behavior from its superclass.
  2. With interfaces, a class gains behavior from the interface it implements. (this is the one I chose)
  3. With inheritance, a class must implement the methods defined by its superclass.
  4. With interfaces, a class gains both instance variables and behaviors from the interface it implements.

The way I was thinking is that interfaces define behavior, while superclasses define characteristics... or are they the same? Or am I completely backwards in my understanding?

Edit: I guess I should specify that I do know the difference between interfaces and inheritance. I'm just wondering about the two options which use the term behavior. I don't know if the prof was nitpicking about terminology, or if he asked the question poorly.

I know that when you implement an interface, you have to implement all the methods as defined in the interface. As such, I would say that the interface defines the behavior that a class must have, but extending another superclass (although it does also define some behaviors (more can be given to the subclass), it doesn't seem to fit as strongly as the interface defining behaviors. If the class implements an interface, you can be sure that it has certain behaviors.

Maybe the question was meant to ask whether or not the interface itself has the code for the behavior, or if it's just the definition - which if worded that way, I would have known the answer.

Upvotes: 0

Views: 878

Answers (7)

Ryan Maloney
Ryan Maloney

Reputation: 552

I think some of your misunderstanding might stem purely from semantics. Perhaps a more straightforward way of describing an interface is that it defines an API but does not provide an implementation of that API. One caveat is that I will use Java for my example but in a language like C++, implementing an interface is inheritance of a special sort - namely inheriting from a class consisting of pure virtual functions.

In Java, for instance, you might have an EventListener interface defined as:

public interface IEventListener {
    public void handleEvent(Event event);
}

The interface does not, to use the question's verbiage, say anything about how a class that implements the IEventListener interface will behave when it receives an event it only ensures that any class implementing this interface will have the characteristic of being able to receive an event of type Event.

Inheritance, on the other hand, allows super classes to also inherit behavior (implementation). For instance, consider the following Java base class:

public abstract BaseClass {
    public void baseMethod(int value) {
        System.out.println(int);
}

public class SubClass extends BaseClass {
}

Any class that inherits from BaseClass gains both the API (characteristics) of BaseClass and also the implementation (behavior). In other words not only can you invoke instanceOfSubClass.baseMethod(1), a characteristic, doing so will result in the behavior defined in the BaseClass, namely 1 being printed to the console.

So your answer (2) is incorrect because interfaces do not specify behavior (implementation) only API (characteristics). Inheritance can handle both.

I think the point of the question is to explain that inheritance is specifically useful when you want to share behavior and not just API. That said, implementation (behavior) can also be shared via composition and such a strategy is often better - see Item 16 in Bloch's Effective Java for an excellent discussion.

Upvotes: 2

Lethal Left Eye
Lethal Left Eye

Reputation: 378

You gain behavior and implementation from inheritance. Remember that a subclass inherits all non-constructor and private methods from it's superclass. This means that you may inherit functionality (implementation) of certain methods.

With implementation you gain just behavior. All you are doing with implementation is signing a contract with the compiler, saying that you promise to override all abstract methods defined in the implemented class or interface.

I hope this helped.

Upvotes: 0

mre
mre

Reputation: 44240

with inheritance, you get a cat. with an interface, you get the skeleton of a cat.

Upvotes: 0

FieryDragon87
FieryDragon87

Reputation: 69

The correct answer is 1. The answer you chose (option 2) is wrong because interfaces technically do not have any behavior. They are just a list of abstract methods. You can consider them more as a template on which you can base your classes. For example, suppose a project is split into two parts, which need to be integrated at the end. Each team could use a common interface to base their classes on, so that integration would be a much easier job.

Upvotes: 0

Edmon
Edmon

Reputation: 4872

This is a very common OO design question in Java.

Sincerely recommend this very good article on this topic that explains it well:

http://www.javaworld.com/javaqa/2001-04/03-qa-0420-abstract.html

Upvotes: 0

OmniOwl
OmniOwl

Reputation: 5709

When you implement an Interface, you don't necessarily care much for the implementation. Also remember that you can implement as many interfaces as you want, since they only specify contracts but not how to fulfill them. The creator of the interface lets you take care of that.

When you extend an Object it's usually because you need some functionality which an already existing object already got the majority of, but will only need that bit extra. Or you want to redefine some of the existing behaviour of an already existing object.

To give you the answer: 1 is right. You don't HAVE to implement the methods of a superclass (Inheritance). Only when it's abstract the next subclass of this superclass needs to implement the methods (like in an interface).

Upvotes: 2

Lunfel
Lunfel

Reputation: 2667

An object implementing an x Interface tells the object that it must do all actions (methods) listed in the definition of an interface. So in the object that implements x, you need to implements all actions. An interface cannot be instanciated.

But when you inherit from an object y, the object y may already have an implementation of some actions. if not the method will be marked as abstract (in java) and you need to implement it in your inherited object.

Upvotes: 0

Related Questions