Java、Go中的接口及其使用简介

接口的思想和本质：

• 提及接口，熟悉计算机原理的同学应该理解起来会更加容易一些，我们知道，电子计算初期都是通过集成电路中的收发设备进行信息通信，后来，由于系统功能的组件化，大型集成计算器基于冯诺依曼结构，逐渐分块，计算机也被拆分为不同的组成部分，显示器、输入输出设备、控制器【CPU】、内存等，这些组件之间，为了建立统一的通信标准，所以产生了标准的串口协议，使得遵循这些"标准"的设备能够互相进行信息通信。
• 在编程语言中，“接口"同样有着"标准”、"规范"的意义在里面，它对程序具体的行为和功能进行抽象，提供一种通用的、灵活的表达方式，所有实现了接口的类的行为，统一由接口所制定的"标准"约束着，即这些类看起来都有着类似的行为表现。
• 一般来说，你也可以将接口理解为一种类之间的"协议"，接口建立起了类之间的一种"通信"标准，使得这些类有着同样的行为属性。

一、Java中的接口

• 在java中，接口由关键字"interface"标识，对于一个接口来说，它只能确定方法名，参数列表和返回类型，而不提供方法的具体实现【default方法拥有方法体，但是这种情况可以视为和接口实现无关，故不影响一般理解】，即，接口仅仅提供一种实现形式，除了特殊情况外，通常不提供实现。
• Java中的接口所解决或者说优化的类的单继承限制，一个类需要实现多个接口，使得Java的多态真正意义上丰富起来。

二、golang中的接口

• 在golang中，接口类型作为一种抽象类型，同样不含有任务内部细节的实现或操作，仅仅提供一些方法，可以说，Go中的接口就是一组方法的签名。与Java不同的是，Go中的接口是隐性实现，一个类型如果要实现一个接口，不需要申明其实现接口的名称，只需要将接口中的方法实现即可，这种设计使得在结构上保持了原有类型，又达到了功能的拓展。

三、使用区别和示例

• java版本

  import java.util.*;
  
  interface ShopOne{
      public void sellOne();
  }
  
  interface ShopTwo{
      public void sellTwo();
  }
  
  class Shop implements ShopOne, ShopTwo{
  
      @Override
      public void sellOne() {
          System.out.println("shop one sells a banana");
      }
  
      @Override
      public void sellTwo() {
          System.out.println("shop two sells a apple");
      }
  }
  
  
  public class MultipleImpl  {
      public static void main(String[] args) {
          Shop shop = new Shop();
          shop.sellOne();
          shop.sellTwo();
      }
  }
  
  

• golang版本

  import "fmt"
  
  type Animal interface {
  	Roar()
  }
  
  type Cat struct {
  	Name string
  }
  
  func (c *Cat) Roar() {
  	fmt.Println("喵喵喵")
  }
  
  func main() {
  	var cat = &Cat{Name: "cily"}
  	cat.Roar()
  }
  
  

• 趣味话题—java中子类的父类和实现接口拥有相同方法

  • 在Java中，有这么一种情况，子类会继承一个父类，同时实现一个接口，当父类和接口拥有同样的方法时，子类需要实现该方法吗，让我们先看代码

    import java.util.*;
    
    interface T0 {
        public void Run();
        public void Run1();
    }
    
    class T1 {
        public void  Run(){
            System.out.println("T1 Run");
        }
    }
    public class Demo extends T1 implements T0 {
        @Override
        public void Run1() {
            System.out.println("Self Run");
        }
    
        public static void main(String[] args) {
            new Demo().Run1();
        }
    }
    

  • 如上面代码所示，程序能够正常编译，并且运行正常，那么为什么呢？其实，在Java中，由于内存加载机制的存在，如果一个类存在父类，会先加载父类信息，最后才是类本身，因此在本例中，由于Demo继承了T1，而T1和T0拥有同样的方法，即可以认为T1实现了接口，而子类Demo用于父类的方法，因此可以认为子类也实现了接口，所以在本例中，子类不用实现接口方法也能正常编译，当然，如果子类重新了方法Run()，则以子类重写的为主。

  • 那么，你是不是认为Java中的多态存在缺陷呢，我明明需要实现一个接口，结果现在你说父类帮我处理了，我不想这样，非要自己来，可以么？答案是可以的，Java中还存在一种类，帮忙解决这种问题，它就是内部类，我们知道内部类可以拥有独立的表达形势，并且拥有外部访问权限，因此可以使用内部类去实现接口即可。

    import java.util.*;
    
    interface T0 {
        public void Run();
        public void Run1();
    }
    
    class T1 {
        public void  Run(){
            System.out.println("T1 Run");
        }
    }
    public class Demo extends T1  {
        class SubDemo implements T0{
            @Override
            public void Run() {
                System.out.println("exec run");
            }
    
            @Override
            public void Run1() {
                System.out.println("exec run1");
            }
        }
        @Override
        public void Run() {
            System.out.println("exec self run");
            SubDemo demo = new SubDemo();
            demo.Run();
            demo.Run1();
        }
    
        public static void main(String[] args) {
            Demo demo = new Demo();
            //Demo.SubDemo subDemo = demo.new SubDemo();
            demo.Run();
        }
    }