《接口》

【14-12】面向对象-接口
/*
抽象类中是可以定义抽象方法的。
当一个抽象类中的方法全是抽象的。
这时，可以通过另一种特殊的形式来体现。

用接口来表示。


abstract class Demo
{
    abstract void show1();
    abstract voud show2();
}

接口该如何定义呢？
*/


/*
接口中的成员已经被限定为固定的几种。

【接口的定义格式先介绍两种】
1，定义变量，但是变量必须有固定的修饰符，public static final所以接口中的变量也称之为常量。
2，定义方法，方法也有固定的修饰符，public abstract
接口中的成员都是公共的。

【接口的特点】
1,接口不可以创建对象。
2，子类必须全部覆盖接口中所有的抽象方法后，子类才可以实例化。
   否则子类是一个抽象类。

*/

interface Demo  //定义一个名为Demo的接口
{
    public static final int NUM = 3;
    public abstract void show1();
    public abstract void show2();
}

//定义子类去覆盖接口中的方法，子类必须和接口产生关系，类与类的关系是继承，类与接口的关系是 实现 通过关键字implements。
class DemoImpl implements Demo //子类实现Demo接口
{
    //重写接口中的方法
    public void show1(){}
    public void show2(){}

}


class InterfaceDemo
{
    public static void main(String[] args)
    {
        DemoImpl d = new DemoImpl();
        d.show1();
        d.show2();
    }
}
//---------------------------------------------
//【接口最重要的体现】
//解决多继承的弊端，将多继承这种机制在java中通过多实现完成了

interface A
{
    public abstract void show1();
    
}

interface B
{
    public abstract void show2();
}

class C implements A,B  //多实现，同时实现多个接口。
{
    public void show1(){}
    public void show2(){}
}

/*是怎样解决多继承时，当多个父类中有相同的功能时，子类调用会产生不确定性的弊端呢？
其实核心原因就是在于多继承父类中功能有主体，而导致调用运行时，不确定运行哪个主体的内容。

为什么多实现就解决了呢？
因为接口中的功能都没有方法体，由子类来明确。

interface A
{
    public abstract void show();
    
}

interface B
{
    public abstract void show();
}

class C implements A,B  //多实现，同时实现多个接口。
{
    public void show(){}
    
}

C c = new C();
c.show();

/*
【基于接口的扩展（继承，接口同时实现）】

class Fu
{
    public void show(){}
}
//子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能
//如果子类想要继续扩展其他类中的功能呢？这时可以通过接口来完成。
interface Inter
{
    public abstract void show1();
}
class Zi extends Fu implements Inter
{
    public void show1()
    {
    
    }

}
接口的出现避免了单继承的局限性。
父类中定义的事物的基本功能。
接口中定义的事物的扩展功能。
*/

*/
//----------------------------------------------------

【14-13】接口出现后的一些小细节

//类与类之间是继承（is a）关系，类与接口之间是实现(like a)关系
 //  接口与接口之间是继承关系。而且可以实现多继承

  interface InterA
  {
      public abstract void show1();
  }

  interface InterAA
  {
      public abstract void show11();
  }

  interface InterB extends InterA,InterAA  //接口的多继承
  {
      public abstract void show2();
  }

  class Test implements InterB
  {
      public void show1(){}
      public void show2(){}
      public void show11(){}
  }

===================================================================================================
其他的一些问题如下：
 /*
  抽象类中是否可以不定义抽象方法
  是可以的，原因是不让改类创建对象。
  */

  interface Inter
  {
      //定义四种显示功能
      public abstract void show1();
      public abstract void show2();
      public abstract void show3();
      public abstract void show4();
  }

   //定义子类，要使用第一种显示方式，
   class InterImpl implements Inter
   {
       //覆盖show1方法
       public void show1()
       {
           System.out.println("show1 run");
          

       }
        //为了创建InterImpl的对象，还需要覆盖其他三种方法
       public void show2(){}
       public void show3(){}
       public void show4(){}
   }

   class InterfaceDemo
   {
       public static void main(String[] args)
       {
           InterImpl in1 = new InterImpl
               in1.show1();
       }
   }
//--------------------------------------------------------------------
   //如果还想实现接口中的方法三，还要再创建一个子类，还要实现接口
   //里面的所有方法，复用性太差。
   //可以将这些不用的方法都单独抽取到一个独立的类中。
   //让这个类去实现接口，并覆盖接口中的所有方法。
   //这个类不知道这些方法具体方法的实现内容。所以只能为了后期子类创建对象提供方便，而进行空实现。
   //而这时，这个类创建对象没有意义，这个类就不需要创建对象，直接将其抽象化
    //这就是没有抽象方法的抽象类。
   //如下类：
  abstract class InterImpl1 implements Inter
   {
       //实现Inter接口中的所有方法。
       public void show1(){}
       public void show2(){}
       public void show3(){}
       public void show4(){}
   }
//这时如果子类去使用显示1方法，让子类继承InterImpl实现类就可以了
class InterImpl11 extends InterImpl
{
    public void show1()
    {
        System.out.pritnln("show1 run")；
    }
}

class InterImpl33 extends InterImpl
{
    public void show3()
    {
        System.out.pritnln("show3 run")；
    }
}
//-------------------------------------------------------------

【14-14】面向对象-接口-接口的思想

接口的思想：

举例：笔记本电脑，USB接口的故事。

1，接口的出现对功能实现的扩展。
2，接口的出现定义了规则。
3，接口的出现降低了耦合性（解耦）

接口的出现，完成了解耦，说明有两方，一方在使用这个规则，另一方在实现这个规则。
比如笔记本电脑使用了这个规则，而外围设备在实现这个规则

【14-15】面向对象-接口-接口和抽象的区别

    
接口和抽象的区别：

描述事物：
犬：按照功能分类 导盲犬，缉毒犬...

犬：
    吼叫();
    吃饭();

class 犬
{
    public abstract void 吼叫();
    public abstract void 吃饭();
}

class 缉毒犬 extends 犬
{
    public void 吼叫(){}
    public void 吃饭(){}
    public void 缉毒(){}
}

//对于缉毒，有可能还有缉毒猪，具备缉毒功能，应该将缉毒功能抽取。
//对缉毒进行描述。
class 缉毒
{
    public abstract void 缉毒(); 
}

//缉毒犬既需要犬功能，又需要缉毒的功能。无法直接多继承。
//是否可以多实现呢？ 可以的。
//犬是一个接口，缉毒也是一个接口，缉毒犬多实现即可。

//类负责描述的是事物的基本功能，接口负责描述事物的扩展功能。
//缉毒犬是犬是犬中的一种，（is a ）关系，
//将犬定义成类 而缉毒呢，是犬的一个扩展功能，这时将缉毒定义成接口。

//就描述如下：

abstract class 犬
{
    public abstract void 吼叫();
    public abstract void 吃饭();
}

interface 缉毒able
{
    public abstract void 缉毒();
}

class 缉毒犬 extends 犬 implements 缉毒able
{
    public void 吼叫(){code...} //重写
    public void 吃饭(){}
    public void 缉毒(){}
}

//小结：
1，抽象类是描述事物的基本功能，可以定义非抽象的方法。
    接口中定义只能是抽象方法，负责功能的扩展。
2，类与类之间是继承关系 is a 关系。
    类与接口之间是实现关系 like a 关系。

如：

门：
open();
close)();

报警门  
class门
{
}

interface 报警
{
}