实施 vs 扩展：何时使用？有什么不同？

请以一种易于理解的语言或一些文章的链接进行解释。

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标记，因为原始接口方法中没有要覆盖的内容

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

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

即，这些关键字和控制其使用的规则描述了 Java 中多重继承的可能性（您只能有一个超类，但可以实现多个接口）。

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

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

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

在 Java 8 发行版中，interface 可以在 interface 中具有默认方法，该方法在 interface 本身中提供实现。

有关何时使用它们中的每一个的信息，请参阅此问题：

接口与抽象类（通用 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

要了解的要点：

狗和猫是动物，它们通过共享Animal name,lifeExpentency来remember （）和protectOwner
猫可以爬（），但狗不能爬。狗可以认为（），而猫则不能。通过实现该功能，可以将这些特定功能添加到Cat and Dog
人不是动物，但他可以Think,Learn,Apply,Climb

通过查看这些示例，您可以了解到

不相关的类可以通过接口具有功能，但是相关的类可以通过扩展基类来覆盖行为。

协慌网

实施 vs 扩展：何时使用？有什么不同？

答案