为了账号安全,请及时绑定邮箱和手机立即绑定

实现VS扩展:何时使用?有什么关系呢?

/ 猿问

实现VS扩展:何时使用?有什么关系呢?

慕姐5112350 2019-07-17 19:07:38

实现VS扩展:何时使用?有什么关系呢?

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



查看完整描述

3 回答

?
慕码人8056858

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

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


查看完整回答
反对 回复 2019-07-17
?
慕雪6173905

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

例如,这些关键字及其使用规则描述了在Java中进行多重继承的可能性(您只能拥有一个超类,但可以实现多个接口)。


查看完整回答
反对 回复 2019-07-17
?
慕运维8079593

一般实施器用于实现界面延展用于延拓基类行为或摘要班级,等级。

延展派生类可以扩展基类。你可以重新定义一个既定关系的行为。派生类““基类类型

实施器:您正在执行一项合同。实现接口的类“有一个“能力。

使用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. 是动物

    remember

    ()和

    protectOwner

    ()分享

    name,lifeExpentency

    从…

    Animal

  2. 猫会爬,狗不会爬。狗会思考,但猫不会

    ..这些特定功能被添加到

    Cat

    Dog

    通过实现这种能力。
  3. 人不是动物,但他可以Think,Learn,Apply,Climb

通过阅读这些例子,您可以理解

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


查看完整回答
反对 回复 2019-07-17

添加回答

回复

举报

0/150
提交
取消
意见反馈 邀请有奖 帮助中心 APP下载
官方微信