extends用于从基类继承时（即扩展其功能）。

implements用于实现接口时。

这里是一个很好的开始：接口和继承。

extends用于扩展类。

implements用于实现接口

接口和常规类之间的区别在于，在接口中不能实现任何声明的方法。只有“实现”接口的类才能实现方法。C++等价的接口将是一个抽象类（不完全相同，但几乎相同）。

此外，java不支持类的多重继承。这通过使用多个接口来解决。

 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
     }
 }

现在扩展类

 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;
     }
 }

在这种情况下

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

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

此外，请注意，实现接口不需要@Override标记，因为原始接口方法中没有任何内容需要重写

我建议您对面向对象编程中的动态绑定、多态性和一般继承进行更多研究

实现用于接口，扩展用于扩展类。

为了用更简单的术语使它更清晰，界面就像它的声音——一个界面——一个模型，你需要应用它，跟随它，以及你的想法。

Extend用于类，在这里，您通过添加更多功能来扩展已经存在的内容。

还有一些注意事项：

一个接口可以扩展另一个接口。

当您需要为特定场景在实现接口或扩展类之间进行选择时，就开始实现接口。因为一个类可以实现多个接口，但只能扩展一个类。

在Java语言中创建自己的新类时使用这两个关键字。

区别：implements意味着您在类中使用Java接口的元素。extends表示您正在创建正在扩展的基类的子类。您只能在子类中扩展一个类，但可以实现任意数量的接口。

有关详细信息，请参阅界面上的oracle文档页面。

这有助于澄清什么是接口，以及使用它们的约定。

类只能“实现”接口。类只“扩展”类。同样，一个接口可以扩展另一个接口。

一个类只能扩展另一个类。一个类可以实现几个接口。

相反，如果您更想知道何时使用抽象类和接口，请参考以下线程：接口与抽象类（通用OO）

我注意到你的个人资料中有一些C++问题。如果您理解C++的多重继承（指从多个其他类继承特性的类）的概念，Java不允许这样做，但它确实有关键字接口，这有点像C++中的纯虚拟类。正如很多人所提到的，你扩展了一个类（而且你只能从一个类扩展），你实现了一个接口——但是你的类可以实现任意多的接口。

也就是说，这些关键字及其使用规则描述了Java中多重继承的可能性（只能有一个超级类，但可以实现多个接口）。

扩展：用于将父类的属性获取到子类中，并且可能包含已定义的方法，这些方法可以在子类中重写。

Implements：这用于通过在子类中定义接口来实现接口（仅具有函数签名而不具有函数定义的父类）。

有一个特殊的条件：“如果我希望一个新接口成为现有接口的子接口怎么办？”。在上述条件下，子接口扩展父接口。

界面是一个对象可以做的动作的描述…例如，当你拨动一个灯开关，灯亮了，你不在乎怎么做，只是它做了。在面向对象编程中，接口是一个对象为了成为“X”而必须具有的所有功能的描述。同样，作为一个例子，任何“像”灯光的东西都应该有turn_on（）方法和turn_off（）方法。接口的目的是让计算机强制执行这些财产，并知道TYPE T的对象（无论接口是什么）必须具有名为X、Y、Z等的函数。

接口是一种编程结构/语法，允许计算机在对象（类）上强制执行某些财产。例如，假设我们有汽车类、滑板车类和卡车类。这三个类中的每一个都应该有一个start_engine（）操作。每个车辆的“引擎如何启动”取决于每个特定的类，但它们必须有一个start_engine动作这一事实是接口的领域。

当子类扩展一个类时，它允许子类继承（重用）和重写在父类型中定义的代码。当类实现接口时，它允许在任何期望接口值的上下文中使用从该类创建的对象。

这里真正的问题是，当我们实现任何东西时，这仅仅意味着我们在使用这些方法。它们的值和返回类型没有任何变化的余地。

但是当我们扩展任何东西时，它就变成了类的扩展。您可以更改它，使用它，重用它，它不一定需要返回与在超类中相同的值。

通常实现用于实现接口，扩展用于扩展基类行为或抽象类。

extends：派生类可以扩展基类。您可以重新定义已建立关系的行为。派生类“是”基类类型

implements：您正在实现合同。实现接口的类“具有”功能。

在java8版本中，接口可以在接口中具有默认方法，这在接口本身中提供了实现。

请参阅此问题以了解何时使用它们：

接口与抽象类（通用OO）

理解事物的榜样。

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;
    }
}

输出：

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

需要理解的要点：

狗和猫是动物，它们通过分享名字、生命来延长记忆和保护主人猫能爬，但狗不能。狗会思考，但猫不会。通过实施这些功能，这些特定功能被添加到猫和狗中。人不是动物，但他能思考、学习、应用、攀爬

通过这些示例，您可以理解

不相关的类可以通过接口具有功能，但相关的类通过基类的扩展重写行为。

A延伸B：A和B都是类或都是接口A机具BA是类，B是接口剩下的A是接口而B是类的情况在Java中是不合法的。

只有当子类想要使用SuperClass中已经声明的某些功能（方法或实例变量），或者我想要稍微修改SuperClass的功能（方法重写）时，我们才使用SubClass扩展SuperClass。但是，比方说，我有一个Animal类（SuperClass）和一个Dog类（SubClass），我在Animal中定义的方法很少，例如doEat（），doSleep（）。。。以及更多。

现在，我的狗类可以简单地扩展Animal类，如果我希望我的狗使用Animal中声明的任何方法，我可以通过创建一个狗对象来调用这些方法。这样我就可以保证我有一只能吃能睡的狗，可以做我想让狗做的任何事情。

现在，想象一下，有一天，一个爱猫的人来到我们的工作场所，她试图扩展动物课程（猫也吃也睡）。她创建了一个Cat对象并开始调用这些方法。

但是，比方说，有人试图成为Animal类的对象。你可以分辨猫是如何睡觉的，你可以分辨狗是如何进食的，你也可以分辨大象是如何喝水的。但它在制作Animal类的对象时没有任何意义。因为这是一个模板，我们不想要任何一般的饮食方式。

因此，我更倾向于创建一个抽象类，没有人可以实例化，但可以用作其他类的模板。

总之，Interface只是一个抽象类（纯抽象类），它不包含方法实现，只包含定义（模板）。因此，实现接口的人只知道他们有doEat（）的模板；和doSleep（）；但他们必须定义自己的doEat（）；和doSleep（）；方法。

只有当您想要重用SuperClass的某些部分时（但请记住，您始终可以根据需要重写SuperClass的方法），才可以进行扩展，并且当您需要模板并且希望自己定义模板时（根据需要），才可实现。

我将与您分享一段代码：您可以尝试使用不同的输入集并查看结果。

class AnimalClass {

public void doEat() {
    
    System.out.println("Animal Eating...");
}

public void sleep() {
    
    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {
    
    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();
    
    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {
    
    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub
    
}

@Override
public void herbiEating() {
    
    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub
    
}


}

定义的接口：

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

如下图所示，一个类扩展另一个类，一个接口扩展了另一个接口，但一个类实现了一个接口。

有关详细信息

最简单的说法是，extends用于从类继承，implements用于在类中应用接口

延伸：

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

机具：

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

如果您仍然感到困惑，请阅读以下内容：https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.htmlhttps://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

当您想要子类/接口中的父类/接口的属性时，使用extends；当您想要类中的接口的属性的时候，使用implements。

例子：

使用类扩展类父级{}类Child扩展Parent{}使用接口扩展接口父级{}接口子级扩展父级{}机具接口A{}B类实现A{}延伸和机具的组合接口A{}B类{}C类实现A，扩展B{}

延伸

类只扩展一个类接口扩展了一个或多个接口

工具

类实现一个或多个接口接口“不能”实现任何内容

抽象类也像类一样，具有扩展和实现

这两个关键字与继承直接关联，这是OOP的核心概念。当我们将某个类继承到另一个类时，我们可以使用extends，但当我们要将某些接口继承到我们的类时，不能使用extends时，我们应该使用implements，并且我们可以使用扩展关键字从另一个接口继承接口。

类和接口都是契约。它们提供应用程序其他部分所依赖的方法和财产。

当您对本合同的实现细节不感兴趣时，可以定义一个接口。唯一需要关心的是契约（接口）是否存在。

在这种情况下，您可以让实现接口的类来关注合同如何履行的细节。只有类才能实现接口。

extends用于替换现有合同的详细信息。通过这种方式，您可以用不同的方式取代一种履行合同的方式。类可以扩展其他类，接口可以扩展其他接口。

在Java中，类（子类）扩展了另一个类（超级类），并可以覆盖超级类中定义的方法。

当一个类试图声明接口中定义的方法时，使用implements。