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

我建议你对面向对象编程中的动态绑定，多态和一般继承做更多的研究

Answer 2

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

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

Answer 3

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

implements用于实现界面。

这是一个很好的起点：Interfaces and Inheritance。

Answer 4

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

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

实施：您正在实施合同。实现“ ”界面的类具有 “功能。

使用java 8发行版，接口可以在接口中使用默认方法，它在接口本身提供实现。

有关何时使用每个问题，请参阅此问题：

Interface vs Abstract Class (general 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

要理解的重点：

Dog 和 Cat 是动物，他们通过remember分享protectOwner（）和name,lifeExpentency（） 1}}
猫可以爬（）但是狗没有。狗可以思考（）但猫不会。通过实施该功能，这些特定功能将添加到Animal和Cat。
男人不是动物，但他可以Dog

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

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

Answer 5

class只能“实施”interface。一个类仅“扩展”class。同样，interface可以扩展另一个interface。

class只能扩展另一个class。 class可以实现多个interface。

如果您更想知道何时使用abstract class es和interface s，请参阅此主题：Interface vs Abstract Class (general OO)

Answer 6

界面是对象可以执行的操作的描述...例如，当您打开灯开关时，指示灯亮起，您不关心它是怎么做的。在面向对象编程中，接口是对象必须具有的所有函数的描述，以便成为＆＃34; X＆＃34;。再一次，作为一个例子，任何＆＃34; ACTS LIKE＆＃34;一个灯，应该有turn_on（）方法和turn_off（）方法。接口的目的是允许计算机强制执行这些属性并知道TYPE T的对象（无论接口是什么）必须具有称为X，Y，Z等的函数。

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

Answer 7

A扩展B：

A和B都是类或两个接口
A实现B

A是一个类，B是一个接口
A是接口而B是类的其余情况在Java中是不合法的。

Answer 8

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

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

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

Answer 9

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

了解更多details

Answer 10

Implements用于Interfaces，extends用于扩展类。

为了让它更容易理解，界面就像声音 - 界面 - 模型，你需要应用，跟随你的想法。

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

还有一些说明：

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

当您需要选择实现接口或扩展特定场景的类时，请转到实现接口。因为一个类可以实现多个接口，但只扩展一个类。

Answer 11

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

真正的问题是，虽然我们正在实施任何事情，但这只是意味着我们正在使用这些方法。它们的值和返回类型没有变化的余地。

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

Answer 12

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

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

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

这有助于澄清界面是什么，以及围绕使用它们的惯例。

Answer 13

用最简单的术语来说，扩展用于从类继承，实现用于应用接口在你的班级

<强>延伸：

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

只有当子类想要使用已在 SuperClass SubClass extends SuperClass >，或者如果我想略微修改 SuperClass （方法覆盖）的功能。但是，例如，我有一个Animal类（ SuperClass ）和一个Dog类（ SubClass ），我在Animal类中定义的方法很少，例如。 doEat （）; ， doSleep （）; ......还有更多。

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

现在，想象一下，有一天，一些猫爱好者进入我们的工作区，她试图扩展动物类（猫也吃饭和睡觉）。她创建一个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();

}

Answer 15

Extends用于子类/接口中的父类/接口的属性，implements用于类中的接口的属性。

示例：

使用类扩展

父类{

}

班级子女扩展了父母{

}
使用界面扩展

父界面{

}

界面孩子扩展了父母{

}
实现

界面A {

}

B类实现A {

}

扩展和实现的组合

interface A{

}

class B

{

}

class C implements A,extends B{

}

Answer 16

扩展

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

实现

类实现一个或多个接口
接口“无法”实现任何内容

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

Answer 17

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

如果您对此合同的实施细节不感兴趣，则定义一个接口。唯一要关心的是合同（接口）存在。

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

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

Answer 18

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

Answer 19

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

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

Implements vs extends：何时使用？有什么不同？

19 个答案: