When to use extends and when to use interface?

Question

We can extend a class but we cannot implement a class. We can implement an interface, but cannot extend an interface.

In what cases should we be using extends?

Answer 1

extends keyword is used for either extending a concrete/abstract class. By extending, u can either override methods of parent class / inherit them. A class can only extend class. U can also say interface1 extends intenface2.

implements keyword is used for implementing interface. In this case u have to define all the methods indicated in interface. A class can only implement interface.

Answer 2

extends is used for either extending a base class:

class ClassX extends ClassY {
    ...
}

or extending an interface:

interface InterfaceA extends InterfaceB {
    ...
}

Note that interfaces cannot implement other interfaces (most likely because they have no implementation).

Java doesn't impose any naming conventions for classes vs. interfaces (in contrast to IFoo for interfaces in the .NET world) and instead uses the difference between extends and implements to signify the difference to the programmer:

class ClassA extends ClassB implements InterfaceC, InterfaceD {
    ...
}

Here you can clearly see that you're building upon an existing implementation in ClassB and also implement the methods from two interfaces.

Answer 3

Hi Devil:

Is a matter of uses. Interfaces can be used as a contract with your application and then base classes can be use to extend that interface, so it is loosely couple.

Take for example Injection Dependency pattern:

You first write a contract:

     public interface IProductRepository
     {
        IList<T> GetAllProducts();
     }

Then you extend your contract with a base class:

     public abstract BaseProductRepository : IProductRepository
     {
         public IList<T> GetAllProducts()
         { //Implementation }
     }

Now you have the option to extend base into two or more concrete classes:

     public class InternetProductRepository extends BaseProductRepository;
     public class StoreProductRepository extends BaseProductRepository;

I hope this small examples clears the differences between extend and Implement. sorry that I did not use java for the example but is all OO, so I think you will get the point.

Thanks for reading, Geo

---

I did not complete the code for injection dependency pattern but the idea is there, is also well documented on the net. Let me know if you have any questions.

Answer 4

Like you said. the implement java keyword is used to implement an interface where the extends is used to extend a class.

It depends what you would like to do. Typically you would use an interface when you want to force implementation (like a contract). Similar to an abstract class (but with an abstract class you can have non-abstract methods).

Remember in java you can only extend one class and implement zero to many interfaces for the implementing class. Unlike C# where you can extend multiple classes using :, and where C# only uses the : symbol for both interfaces and classes.

Answer 5

Actually, you can extend an interface - in the case where you're defining another interface.

There are lots of quasi-religious arguments about this issue and I doubt there's a clear right answer, but for what it's worth here's my take on things. Use subclassing (i.e. extends), when your various classes provide the same sort of functionality, and have some implementation details in common. Use interface implementation, in order to signal that your classes provide some particular functionality (as specified by the interface).

Note that the two are not mutually exclusive; in fact if a superclass implements an interface, then any subclasses will also be considered to implement that interface.

In Java there is no multiple inheritance, so that a (sub)class can only have one parent class, and subclassing should be considered carefully so as to choose an appropriate parent if any at all; choosing a parent that reflects just a small amount of the class' abilities is likely to end in frustration later if there are other sensible parent classes. So for example, having an AbstractSQLExecutor with SQL Server and Oracle subclasses makes a lot of sense; but having a FileUtils parent class with some utility methods in, and then subclassing that all over the place in order to inherit that functionality, is a bad idea (in this case you should likely declare the helper methods static, or hold a reference to a FileUtils instance, instead).

Additionally, subclassing ties you to implementation details (of your parent) more than implementing an interface does. I'd say that in general it's better merely to implement the interface, at least initially, and only form class hierarchies of classes in the same or similar packages with a clear hierarchical structure.