Question

子类具有与其基类描述为IS-A的关系，但基类不与它的子类共享这种关系。我正在徘徊一个接口与它实现类有什么样的关系，因为该类的对象可以传递给接口对象，而接口对象只能访问定义它具体接口的方法。

public class main {
    public static void main(String[]args){

        Nigeria ng = new Nigeria(){};

        //Interface object can accept Nigerias object which is not posible in Inheritance
        Continent continent = ng; 

        //prints Country is in Africa
        continent.Africa(); 

        //continent.language(); will not compile language is not in the interface

        //Print Democratic thought this should print Undefined since it is inialied with default.
        continent.Goverment(); 

    }

}
interface Continent{
    public void Africa();
    default void Goverment(){
        System.out.println("Undefined");
    }
}
class Nigeria implements Continent{
    @Override
    public void Africa(){
        System.out.println("Country is in Africa");
    }   
    public void language(){
        System.out.println("Official Language is English");
    }
    public void Goverment(){
        System.out.println("Democratic");
    }
}

Answer 1

如果您正在寻找英语类似物，那么界面不是“是......”，也不是“有......”的关系，而是更多的“是......”。

接口与使用它的类无关这是关于消费者要求的。

如果您想将其视为任何内容，您可以将其视为形容词。

“他是负责任的”。

嗯，他做了什么？

他完成了任务;他掌握了自己的错误;他说得对。

他是一名飞行员吗？他是外科医生吗？他是医生吗？他是一个孩子，一个父亲，一个伟大的父亲？

你关心吗？

我需要一个负责任的人来帮助我完成这项工作 ResponsiblePerson是否继承了PoliceOfficer？律师是否继承了ResponsiblePerson，因为我确信会有不负责任的律师。

class Lawyer extends Person { }
class ResponsibleLawyer extends Lawyer implements ResponsibleEntity { }


class NeedyPerson extends Person {
  public void acceptHelp (ResponsibleEntity somebody) {
    try {
      somebody.attemptTask( someTask );
    } catch (TaskCompletionError err) {
      somebody.takeOwnership(err);
      somebody.fixMistake(err);
    }
  }
}

公司也可以负责吗？也许我们不经常看到它，但它在理论上是可能的：

class LawFirm extends CorporateEntity { }
class BetterLawFirm extends LawFirm implements ResponsibleEntity { }

somebody可以成为负责任的法人团体吗？好吧，只要该公司机构完成了负责人所做的所有相同的事情，当然。

在另一个示例中，您可能有一个Switchable界面看看这个名字，你可以猜测你所给的东西有一个可以戳的开关那么它有什么方法呢？

on( )
off( )
toggle( )
isOn( )

听起来像是一个有用的设置。

拥有这样的界面有什么好处？
嗯，现在我知道我可以处理一个开关，它的血统并不重要。

如果我想要的只是一个接受开关并用它做某事的课程，为什么我需要创建几十个课程，只是为了用开关接受我的几十个东西？
或者将方法覆盖到污垢中也可以这样做。

class SwitchThrower {
  public void throwSwitch (CoffeeMaker coffeeMaker) { coffeeMaker.on(); }
  public void throwSwitch (LightSwitch lightSwitch) { lightSwitch.on(); }
  public void throwSwitch (GhostTrap ghostTrap) { ghostTrap.on(); }
  public void throwSwitch (TheHeat theHeat) { theHeat.on(); }
  public void throwSwitch (CarIgnition ignition) { ignition.on(); }
}

...

为什么不呢：

class SwitchThrower {
  public void throwSwitch (Switchable switch) { switch.on(); }
}


class LightSwitch implements Switchable {
  private boolean currentlyOn;

  public LightSwitch (boolean initiallyOn) {
    currentlyOn = initiallyOn;
  }

  public LightSwitch () {
    currentlyOn = false;
  }

  public boolean on () {
    currentlyOn = true;
    return currentlyOn;
  }

  public boolean off () {
    currentlyOn = false;
    return currentlyOn;
  }

  public boolean toggle (boolean forceOn) {
    boolean state;
    if (forceOn == true) {
      state = on();
    } else {
      state = off();
    }
    return state;
  }

  public boolean toggle () {
    boolean state;
    if (isOn() == true) {
      state = off();
    } else {
      state = on();
    }
    return state;
  }

  public boolean isOn () {
    return currentlyOn;
  }
}

......等等

正如您所看到的，除了描述实现者的基本功能集之外，接口根本不是关于类的，而是使用者。

在不同的语言中，更加出色的实现是 _Traits _ 。
特征通常类似于接口，但它们具有与之关联的默认行为。

查看我的Switchable和我的LightSwitch，您可以想象实际上所有具有此开关的类都具有相同的方法，具有相同的方法行为...

...那么，为什么我要重新编写所有这些方法，如果我已经在界面中定义签名的麻烦了？
为什么我不能在那里添加默认行为，并将其应用于实现者，除非重写方法？

嗯，这就是Traits / Mix-Ins所允许的。

Answer 2

该关系只是该类实现接口提供的方法的“契约”。

这就是java可以分离 WHAT 对象可以做什么（接口）和 HOW 继承类将如何做。

接口与实现类有什么关系？

2 个答案: