java - 实现与扩展：何时使用？有什么不同？

Question

请用通俗易懂的语言或文章的链接进行解释。

Answer 1

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实现接口不需要标签，因为原始接口方法中没有任何内容可以被覆盖

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

Answer 2

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

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

Answer 3

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

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

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

在 java 8 版本中，接口可以在接口中具有默认方法，它在接口本身中提供实现。

请参阅此问题以了解何时使用它们中的每一个：

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

要理解的要点：

1. Dog和Cat是动物，它们通过共享扩展( )remember和()protectOwnername,lifeExpentencyAnimal
2. 猫可以攀登（），但狗不能。Dog 可以 think() 但 Cat 不能。这些特定功能被添加到Cat并Dog通过实现该功能。
3. 人不是动物，但他可以Think,Learn,Apply,Climb

通过这些例子，你可以理解

不相关的类可以通过接口获得能力，但相关类通过基类的扩展覆盖行为。

Answer 4

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

了解更多详情

Answer 5

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

implements用于实现接口时。

这是一个很好的起点：接口和继承。

Answer 6

Aclass只能“实现”一个interface. 一个类只“扩展” a class。同样， aninterface可以扩展 another interface。

Aclass只能扩展另一个class。Aclass可以实现几个interfaces。

相反，如果您对知道何时使用abstract classes 和interfaces 更感兴趣，请参阅此线程：Interface vs Abstract Class (general OO)

Answer 7

界面是对对象可以执行的操作的描述……例如，当您拨动电灯开关时，灯会亮起，您不在乎如何，它就是这样做的。在面向对象的编程中，接口是对对象必须具有的所有功能的描述，以便成为“X”。同样，作为一个例子，任何“像”灯一样的东西都应该有一个 turn_on() 方法和一个 turn_off() 方法。接口的目的是允许计算机强制执行这些属性并知道类型 T 的对象（无论接口是什么）必须具有称为 X、Y、Z 等的函数。

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

Answer 8

Extends : This is used to get attributes of a parent class into child class and may contain already defined methods that can be overridden in the child class.

Implements : This is used to implement an interface (parent class with functions signatures only but not their definitions) by defining it in the child class.

There is one special condition: "What if I want a new Interface to be the child of an existing interface?". In the above condition, the child interface extends the parent interface.

Answer 9

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

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

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

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

Answer 10

• A 扩展 B：

  A 和 B 都是类或都是接口

• A 实现 B

  A是一个类，B是一个接口

• 剩下的 A 是接口而 B 是类的情况在 Java 中是不合法的。

Answer 11

Implements 用于接口，extends 用于扩展类。

为了用更简单的术语使其更清晰，界面就像它听起来 - 一个界面 - 一个模型，你需要应用，遵循，以及你的想法。

扩展用于类，在这里，您通过向其添加更多功能来扩展已经存在的东西。

还有一些注意事项：

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

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

Answer 12

仅当子类想要使用已经在SuperClass中声明的某些功能（方法或实例变量） ，或者我想稍微修改SuperClass的功能（方法覆盖）时，我们才使用SubClass extends SuperClass 。但是说，我有一个 Animal 类（SuperClass）和一个 Dog 类（SubClass），并且我在 Animal 类中定义的方法很少，例如。吃（）；, doSleep (); ... 还有很多。

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

现在，想象一下，有一天某个爱猫的人来到我们的工作区，她试图扩展 Animal 类（猫也吃和睡）。她制作了一个 Cat 对象并开始调用这些方法。

但是，比如说，有人试图制作 Animal 类的对象。你可以告诉猫如何睡觉，你可以告诉狗如何吃东西，你可以告诉大象如何喝水。但是在创建 Animal 类的对象时没有任何意义。因为它是一个模板，我们不想要任何一般的吃法。

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

所以总而言之，接口只不过是一个抽象类（一个纯抽象类），它不包含方法实现，只包含定义（模板）。所以实现接口的人只知道他们有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();

}

Answer 13

用最简单的术语来说，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.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Answer 14

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

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

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

Answer 15

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

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

在这种情况下，您将其留给实现接口的类来关心合同如何履行的细节。只有类可以实现接口。

当您想要替换现有合同的详细信息时使用扩展。这样，您就可以用另一种方式替换履行合同的一种方式。类可以扩展其他类，接口可以扩展其他接口。

Answer 16

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

例子：

1. 使用类扩展

   class Parent{
   
   }
   
   class Child extends Parent {
   
   }
   

2. 使用接口扩展

   interface Parent {
   
   }
   
   interface Child extends Parent {
   
   }
   

3. 工具

   interface A {
   
   }
   
   class B implements A {
   
   }
   

4. 扩展和实现的组合

    interface A {
   
    }
   
    class B {
   
    }
   
    class C implements A, extends B {
   
    }
   

Answer 17

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

当一个类试图声明接口中定义的方法时，使用实现，该类正在扩展。

Answer 18

延伸

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

工具

• 类实现一个或多个接口
• 接口“不能”实现任何东西

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

Answer 19

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