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

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是为了实现一个接口.

这是一个很好的起点:接口和继承.

Answer 4

通常实现用于实现一个接口和延伸用于扩展的基类的行为或抽象类.

extends:派生类可以扩展基类.您可以重新定义已建立关系的行为.派生类" 是一种 "基类类型

实现:您正在实施合同.实现接口" 具有 "功能的类.

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

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

接口与抽象类(通用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. 狗和猫是动物,它们通过分享来扩展remember()和protectOwner()name,lifeExpentencyAnimal
2. 猫可以爬()但是狗没有.狗可以思考()但猫不会.这些特定的功能被添加到Cat并Dog通过实施能力.
3. 人不是动物,但他可以 Think,Learn,Apply,Climb

通过这些例子,您可以理解这一点

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

Answer 5

A class只能"实施"一个interface.一个班级只"扩展"一个class.同样,一个interface可以扩展另一个interface.

A class只能相互延伸class.一个class可以实现几个interface.

如果您更想知道何时使用abstract classes和interfaces,请参阅此主题:Interface vs Abstract Class(general OO)

Answer 6

界面是对象可以执行的操作的描述...例如,当您翻转灯开关时,灯会亮起,您不关心它是怎么做的.在面向对象编程中,接口是对象必须具有的所有函数的描述才能成为"X".同样,作为一个例子,任何"ACTS LIKE"灯光的东西都应该有turn_on()方法和turn_off()方法.接口的目的是允许计算机强制执行这些属性并知道TYPE T的对象(无论接口是什么)必须具有称为X,Y,Z等的函数.

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

Answer 7

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

有关详细信息

Answer 8

• A延伸B:

  A和B都是类或两个接口

• 工具B

  A是类,B是接口

• 其中A是接口而B是类的情况在Java中是不合法的.

Answer 9

Extends:用于将父类的属性获取到基类中,并且可以包含已在子类中重写的已定义方法.

实现:这用于通过在子类中定义接口来实现接口(仅具有函数签名但不定义其定义的父类).

有一个特殊条件:"如果我希望新接口成为现有接口的子接口,该怎么办？".在上述情况下,子接口扩展父接口.

Answer 10

Implements用于Interfaces,extends用于扩展类.

为了使其更容易理解,界面就像声音 - 界面 - 模型,您需要应用,跟随,以及您的想法.

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

还有一些说明:

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

当您需要在实现接口或扩展特定方案的类之间进行选择时,请转到实现接口.因为类可以实现多个接口但只扩展一个类.

Answer 11

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

差异: implements表示您在类中使用Java接口的元素. extends意味着您正在创建要扩展的基类的子类.您只能在子类中扩展一个类,但您可以根据需要实现任意数量的接口.

有关更多详细信息,请参阅界面上的oracle文档页面.

这有助于阐明界面是什么,以及使用它们的惯例.

Answer 12

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

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

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

Answer 13

仅当子类要使用已在SuperClass中声明的某些功能（方法或实例变量）时，或者在我要略微修改SuperClass的功能（方法重写）时，才使用SubClass扩展SuperClass。但是说，例如，我有一个Animal类（SuperClass）和Dog类（SubClass），而我在Animal类中定义的方法很少。doEat（）; ，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 14

在最简单的术语中,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 15

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

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

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

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