实现与扩展：何时使用？有什么区别？

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

1270554 次浏览
小开

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 happenreturn 1;}
public int getNb2() {//specify what must happenreturn 2;}}
public class SubClass extends SuperClass {//you can override the implementation@Overridepublic int getNb2() {return 3;}}

在这种情况下

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

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

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

小开

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

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

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

还有一些注意事项：

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

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

小开

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

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

有关更多详细信息，请参阅接口上的oracle留档页面。

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

小开

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

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

如果你更有兴趣知道何时使用abstract classes和interfaces，请参阅此线程：接口与抽象类（通用OO）

小开

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

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

小开

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

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

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

小开

接口是对对象可以执行的操作的描述……例如，当你翻转电灯开关时，灯亮了，你不在乎它怎么亮，只关心它亮了。在面向对象编程中，接口是对对象成为“X”必须具备的所有函数的描述。同样，作为一个例子，任何“像灯一样”的东西，都应该有一个turn_on（）方法和一个turn_off（）方法。接口的目的是允许计算机强制执行这些属性，并知道T型的对象（无论接口是什么）必须有名为X、Y、Z等的函数。

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

小开

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

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

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

小开

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

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

实现：您正在实现一个合约。实现接口“有一个”功能的类。

在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:16Cat:Cat:July:20Dog can remember for 5 minutesDog will protect ownerDog can learn:Cat can remember for 16 hoursCat won't protect ownerCat can climbMan :Ravindra:Age:40I can climb:ManI can think:ManI can learn:ManI can apply:Man

需要理解的要点：

  1. 狗和Cat是动物，它们通过从Animal共享name,lifeExpentency来扩展remember（）和protectOwner（）
  2. 猫能爬，但狗不能。狗能思考，但猫不能.通过实现该功能，这些特定功能被添加到Cat和Dog。
  3. 人不是动物，但他可以Think,Learn,Apply,Climb

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

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

小开

  • A扩展B：

    A和B都是类或者都是接口

  • A实现B

    A是类，B是接口

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

小开

我们仅当子类想要使用已经在超类中声明的某些功能（方法或实例变量）时，或者如果我想稍微修改超类（方法覆盖）的功能时，才使用子类扩展超类。但是假设，我有一个动物类（超类）和一个狗类（子类），并且我在动物类中定义的方法很少，例如吃(); , 睡（）；…等等。

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

现在，想象一下，有一天，一个Cat爱好者来到我们的工作区，她试图扩展动物类（猫也吃饭和睡觉）。她创建了一个Cat对象并开始调用这些方法。

但是，假设有人试图制作一个动物类的对象。你可以知道猫是如何睡觉的，你可以知道狗是如何吃的，你可以知道大象是如何喝酒的。但是在制作动物类的对象时，它没有任何意义。因为它是一个模板，我们不想要任何通用的吃饭方式。

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

总之，Interface只不过是一个不包含方法实现而只包含定义（模板）的抽象类（一个纯抽象类）。所以无论谁实现了这个接口，都只知道他们有do的模板（）；和doS的（）；但是他们必须根据自己的需要定义自己的do的（）；和doS的（）；方法。

仅当您想重用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...");}
@Overridepublic void eating() {    
System.out.println("Eating through an interface...");// TODO Auto-generated method stub    
}
@Overridepublic 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();
}
小开

如下图所示，一个类扩展了另一个类，一个接口扩展了另一个接口，但一个类实现了一个接口。输入图片描述

更多细节

小开

在最简单的术语中，延伸用于从类继承，实现用于在您的类中应用接口

延伸：

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。

示例：

  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 {
}
小开

延伸

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

实现

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

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

小开

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

小开

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

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

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

延伸用于替换现有合同的详细信息。这样你就可以用不同的方式替换一种履行契约的方式。类可以扩展其他类，接口可以扩展其他接口。

小开

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

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


提交答案