实现vs扩展:什么时候使用？有什么关系呢？
实现vs扩展:什么时候使用？有什么关系呢？
提问于 2012-06-01 02:25:47
请用通俗易懂的语言或某篇文章的链接解释。
回答 19
Stack Overflow用户
回答已采纳
发布于 2012-06-01 02:27:30
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标记，因为原始接口方法中没有要覆盖的内容
我建议您进一步研究面向对象编程中的动态绑定、多态性和一般继承
Stack Overflow用户
发布于 2012-06-01 02:36:47
我注意到你的个人资料中有一些C++问题。如果您理解C++的多重继承概念(指从多个其他类继承特征的类)，那么它不允许这样做，但它确实有关键字interface，这有点像C++中的纯虚拟类。正如许多人所提到的，您可以对一个类进行extend (并且只能从一个扩展开始)，并且可以对一个接口进行implement --但是您的类可以实现任意多个接口。
也就是说，这些关键字及其使用规则勾勒出了Java中多重继承的可能性(您只能有一个超类，但您可以实现多个接口)。
Stack Overflow用户
发布于 2016-01-24 22:59:02
通常，实现了用于实现接口的，而扩展了用于扩展基类行为或抽象类的。
扩展了：派生类可以扩展基类。您可以重新定义已建立的关系的行为。派生类"is a“基类类型
实现了：您正在实现一个契约。实现接口“”的类具有功能。
在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要理解的要点：
- 狗和猫是动物，它们通过共享
Animal - Cat的
protectOwner()扩展了remember()和name,lifeExpentency()，但狗不能。狗会思考()，而猫不会。通过实现capability. - Man不是动物，但他可以
Think,Learn,Apply,Climb
，将这些特定功能添加到Cat和Dog中
通过这些示例，您可以理解
无关的类可以通过接口具有功能，但是相关的类通过基类的扩展覆盖行为。
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/10839131
复制相关文章
相似问题
腾讯云开发者
