0

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.

Improve this question
3
  • I'm sorry that your professor is such a dick... he/she is getting caught up in the semantics..the trick here is how your professor defines the verb gains. Commented Dec 8, 2012 at 2:10
  • I'd say: 1) yes. (unless you override everything and never call super - assuming the super constructor has no "behavior") 2) No. interfaces define just names of methods you need to have. 3) No, unless it's an abstract class. 4) No, Interfaces define method names only. Commented Dec 8, 2012 at 2:11
  • It's a real trick question hehe. Commented Dec 8, 2012 at 2:13

7 Answers 7

Reset to default
2

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

There is a closing brace missing on baseMethod().
2

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).

Improve this answer

2 Comments

That doesn't really apply to my question. It's a multiple choice question which I got wrong. Which choice above is correct, and why? I'm assuming 3 and 4 are right out. 1 is the only logical other possibility, but that just doesn't seem right given my train of thought.
It does apply. I'd say 1 is right. You don't HAVE to implement the methods that a superclass holds (only in the case it's abstract in which the next subclass of this class needs to implement the methods). Only with interfaces do you have to do that. An Interface only holds method signatures.
0

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.

Improve this answer

Comments

0

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

Improve this answer

Comments

0

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.

Improve this answer

Comments

0

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

Improve this answer

Comments

0

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.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.