请用通俗易懂的语言或文章链接进行解释。
当前回答
通常实现用于实现接口,扩展用于扩展基类行为或抽象类。
extends:派生类可以扩展基类。您可以重新定义已建立关系的行为。派生类“是”基类类型
implements:您正在实现合同。实现接口的类“具有”功能。
在java8版本中,接口可以在接口中具有默认方法,这在接口本身中提供了实现。
请参阅此问题以了解何时使用它们:
接口与抽象类(通用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
需要理解的要点:
狗和猫是动物,它们通过分享名字、生命来延长记忆和保护主人猫能爬,但狗不能。狗会思考,但猫不会。通过实施这些功能,这些特定功能被添加到猫和狗中。人不是动物,但他能思考、学习、应用、攀爬
通过这些示例,您可以理解
不相关的类可以通过接口具有功能,但相关的类通过基类的扩展重写行为。
其他回答
这两个关键字与继承直接关联,这是OOP的核心概念。当我们将某个类继承到另一个类时,我们可以使用extends,但当我们要将某些接口继承到我们的类时,不能使用extends时,我们应该使用implements,并且我们可以使用扩展关键字从另一个接口继承接口。
只有当子类想要使用SuperClass中已经声明的某些功能(方法或实例变量),或者我想要稍微修改SuperClass的功能(方法重写)时,我们才使用SubClass扩展SuperClass。但是,比方说,我有一个Animal类(SuperClass)和一个Dog类(SubClass),我在Animal中定义的方法很少,例如doEat(),doSleep()。。。以及更多。
现在,我的狗类可以简单地扩展Animal类,如果我希望我的狗使用Animal中声明的任何方法,我可以通过创建一个狗对象来调用这些方法。这样我就可以保证我有一只能吃能睡的狗,可以做我想让狗做的任何事情。
现在,想象一下,有一天,一个爱猫的人来到我们的工作场所,她试图扩展动物课程(猫也吃也睡)。她创建了一个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();
}
最简单的说法是,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.htmlhttps://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html
在Java语言中创建自己的新类时使用这两个关键字。
区别:implements意味着您在类中使用Java接口的元素。extends表示您正在创建正在扩展的基类的子类。您只能在子类中扩展一个类,但可以实现任意数量的接口。
有关详细信息,请参阅界面上的oracle文档页面。
这有助于澄清什么是接口,以及使用它们的约定。
extends用于从基类继承时(即扩展其功能)。
implements用于实现接口时。
这里是一个很好的开始:接口和继承。
推荐文章
- 在流中使用Java 8 foreach循环移动到下一项
- 访问限制:'Application'类型不是API(必需库rt.jar的限制)
- 用Java计算两个日期之间的天数
- 如何配置slf4j-simple
- 在Jar文件中运行类
- 带参数的可运行?
- 我如何得到一个字符串的前n个字符而不检查大小或出界?
- 我可以在Java中设置enum起始值吗?
- Java中的回调函数
- c#和Java中的泛型有什么不同?和模板在c++ ?
- 在Java中,流相对于循环的优势是什么?
- Jersey在未找到InjectionManagerFactory时停止工作
- 在Java流是peek真的只是调试?
- Recyclerview不调用onCreateViewHolder
- 将JSON字符串转换为HashMap