Implements vs extends: When to use? What's the difference?

extends is for extending a class.

implements is for implementing an interface

The difference between an interface and a regular class is that in an interface you can not implement any of the declared methods. Only the class that "implements" the interface can implement the methods. The C++ equivalent of an interface would be an abstract class (not EXACTLY the same but pretty much).

Also java doesn't support multiple inheritance for classes. This is solved by using multiple interfaces.

 public interface ExampleInterface {    public void doAction();    public String doThis(int number); } public class sub implements ExampleInterface {     public void doAction() {       //specify what must happen     }     public String doThis(int number) {       //specfiy what must happen     } }

now extending a class

 public class SuperClass {    public int getNb() {         //specify what must happen        return 1;     }     public int getNb2() {         //specify what must happen        return 2;     } } public class SubClass extends SuperClass {      //you can override the implementation      @Override      public int getNb2() {        return 3;     } }

in this case

  Subclass s = new SubClass();  s.getNb(); //returns 1  s.getNb2(); //returns 3  SuperClass sup = new SuperClass();  sup.getNb(); //returns 1  sup.getNb2(); //returns 2

Also, note that an @Override tag is not required for implementing an interface, as there is nothing in the original interface methods to be overridden

I suggest you do some more research on dynamic binding, polymorphism and in general inheritance in Object-oriented programming

I notice you have some C++ questions in your profile. If you understand the concept of multiple-inheritance from C++ (referring to classes that inherit characteristics from more than one other class), Java does not allow this, but it does have keyword interface, which is sort of like a pure virtual class in C++. As mentioned by lots of people, you extend a class (and you can only extend from one), and you implement an interface -- but your class can implement as many interfaces as you like.

Ie, these keywords and the rules governing their use delineate the possibilities for multiple-inheritance in Java (you can only have one super class, but you can implement multiple interfaces).

Generally implements used for implementing an interface and extends used for extension of base class behaviour or abstract class.

extends: A derived class can extend a base class. You may redefine the behaviour of an established relation. Derived class "is a" base class type

implements: You are implementing a contract. The class implementing the interface "has a" capability.

With java 8 release, interface can have default methods in interface, which provides implementation in interface itself.

Refer to this question for when to use each of them:

Interface vs Abstract Class (general OO)

Example to understand things.

public class ExtendsAndImplementsDemo{    public static void main(String args[]){        Dog dog = new Dog("Tiger",16);        Cat cat = new Cat("July",20);        System.out.println("Dog:"+dog);        System.out.println("Cat:"+cat);        dog.remember();        dog.protectOwner();        Learn dl = dog;        dl.learn();        cat.remember();        cat.protectOwner();        Climb c = cat;        c.climb();        Man man = new Man("Ravindra",40);        System.out.println(man);        Climb cm = man;        cm.climb();        Think t = man;        t.think();        Learn l = man;        l.learn();        Apply a = man;        a.apply();    }}abstract class Animal{    String name;    int lifeExpentency;    public Animal(String name,int lifeExpentency ){        this.name = name;        this.lifeExpentency=lifeExpentency;    }    public void remember(){        System.out.println("Define your own remember");    }    public void protectOwner(){        System.out.println("Define your own protectOwner");    }    public String toString(){        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;    }}class Dog extends Animal implements Learn{    public Dog(String name,int age){        super(name,age);    }    public void remember(){        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");    }    public void protectOwner(){        System.out.println(this.getClass().getSimpleName()+ " will protect owner");    }    public void learn(){        System.out.println(this.getClass().getSimpleName()+ " can learn:");    }}class Cat extends Animal implements Climb {    public Cat(String name,int age){        super(name,age);    }    public void remember(){        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");    }    public void protectOwner(){        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");    }    public void climb(){        System.out.println(this.getClass().getSimpleName()+ " can climb");    }}interface Climb{    public void climb();}interface Think {    public void think();}interface Learn {    public void learn();}interface Apply{    public void apply();}class Man implements Think,Learn,Apply,Climb{    String name;    int age;    public Man(String name,int age){        this.name = name;        this.age = age;    }    public void think(){        System.out.println("I can think:"+this.getClass().getSimpleName());    }    public void learn(){        System.out.println("I can learn:"+this.getClass().getSimpleName());    }    public void apply(){        System.out.println("I can apply:"+this.getClass().getSimpleName());    }    public void climb(){        System.out.println("I can climb:"+this.getClass().getSimpleName());    }    public String toString(){        return "Man :"+name+":Age:"+age;    }}

output:

Dog:Dog:Tiger:16Cat:Cat:July:20Dog can remember for 5 minutesDog will protect ownerDog can learn:Cat can remember for 16 hoursCat won't protect ownerCat can climbMan :Ravindra:Age:40I can climb:ManI can think:ManI can learn:ManI can apply:Man

Important points to understand:

1. Dog and Cat are animals and they extended remember() and protectOwner() by sharing name,lifeExpentency from Animal
2. Cat can climb() but Dog does not. Dog can think() but Cat does not. These specific capabilities are added to Cat and Dog by implementing that capability.
3. Man is not an animal but he can Think,Learn,Apply,Climb

By going through these examples, you can understand that

Unrelated classes can have capabilities through interface but related classes override behaviour through extension of base classes.