Java基础十--接口

Java基础十--接口

一、接口的定义和实例

 /*
 abstract class AbsDemo
 {
     abstract void show1();
     abstract void show2();
 }

  8 当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
  9 另一种形式定义和表示，就是 接口 interface。
 */

 //定义接口使用的关键字不是class，是interface.
 //interface编译后还是.class文件，其实本质上还是class.

 /*
 接口和类中是实现，接口和接口之间是多继承，为什么可以多继承，因为没有方法体，能否多继承的实质看有没有方法体
 */

 /*
 对于接口当中常见的成员：而且这些成员都有固定的修饰符。
 21 1，全局常量: public  static final
 22
 23 2，抽象方法。public abstract

 修饰词你自己不写的话程序给你加上。所以我们都写上，那样阅读性强。

 由此得出结论，接口中的成员都是公共的权限.

 继承没有实现成员变量，方法也是抽象方法，没有函数体的方法，所以实现接口和继承类不冲突，因为接口和类里面的东西不一样
 */
 interface Demo
 {
     public static final int NUM = 4;//static和final和public你不写程序会给你默认加上

     public abstract void show1();//public和abstract你不写程序会给你默认加上
     public abstract void show2();
 }
 //类与类之间是继承关系，类与接口直接是实现关系。
 /*
 接口不可以实例化。

 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
 否则，这个子类就是一个抽象类。

 */

 class DemoImpl implements /*实现*/Demo
 {
     public void show1()
     {}

     public void show2()
     {

     }
 }

 /*
 在java中不直接支持多继承，因为会出现调用的不确定性。
 所以java将多继承机制进行改良，在java中变成了多实现。

 一个类可以实现多个接口。 

 */

 interface A
 {
     public void show();
 }

 interface Z
 {
     public int add(int a,int b);
 }

 class Test implements A,Z//多实现
 {

     public int add(int a,int b)
     {
         return a+b+3;
     }
     /**/
     public void show(){}

 }

 /*
 一个类在继承另一个类的同时，还可以实现多个接口。

 */
 class Q
 {
     public void method()
     {}
 }

 abstract class Test2 extends Q implements A,Z
 {

 }
 /*
 接口的出现避免了单继承的局限性。

 */

 interface CC
 {
     void show();
 }
 interface MM
 {
     void method();
 }

 interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。
 {
     void function();
 }

 class WW implements QQ
 {
 //覆盖3个方法。
     public void show(){}
     public void method(){}
     public void function(){}
 }

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

         Test t = new Test();
         t.show();

 //        DemoImpl d = new DemoImpl();
 //        System.out.println(d.NUM);
 //        System.out.println(DemoImpl.NUM);
 //        System.out.println(Demo.NUM);
     }
 }

二、接口和抽象类的区别

 /*
 抽象类和接口的异同点：

 相同点：
     都是不断向上抽取而来的。

 不同点：
     1，抽象类需要被继承，而且只能单继承。
        接口需要被实现，而且可以多实现。
     2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
        接口中只能定义抽象方法，必须由子类去实现。
     3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
        接口的实现是 like a 关系，在定义体系额外功能。

 犬按功能分：有导盲犬，搜爆犬。

 abstract class 犬
 {
     abstract void 吼叫();
 }

 //abstract class 导盲
 interface 导盲
 {
     abstract void 导盲();
 }

 class 导盲犬 extends 犬 implements 导盲
 {
     public void 吼叫()
     {
     }
     public void 导盲(){}
 }

 //在不同的问题领域中，有不同的分析方式。
 学员：
     学习。
     抽烟学员

 烟民。

 */

 class InterfaceDemo
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
     }
 }

三、接口实例

usb接口实例

 /*
 2 笔记本电脑使用。
 3 为了扩展笔记本的功能，但日后出现什么功能设备不知道。
 4
 5 定义一个规则，只要日后出现的设备都符合这个规则就可以了。
 6 规则在java中就是接口。

 */
 interface USB// 暴露的规则。
 {
     public void open();
     public void close();
 }

 class BookPC
 {
     public static void main(String[] args)
     {
         useUSB(new UPan());//功能扩展了。
         useUSB(new UsbMouse());
     }

     //使用规则。
     public static void useUSB(USB u)//接口类型的引用，用于接收(指向)接口的子类对象。//USB u= new UPan();
     {
         if(u!=null)
         {
             u.open();
             u.close();
         }
     }
 }
 //一年后。------------------------------
 //实现规则。也就是连接接口

 //这些设备和电脑的耦合性降低了。

 class UPan implements USB
 {
     public void open()
     {
         System.out.println("upan open");
     }
     public void close()
     {
         System.out.println("upan close");
     }

 }

 class UsbMouse implements USB
 {
     public void open()
     {
         System.out.println("UsbMouse open");
     }
     public void close()
     {
         System.out.println("UsbMouse close");
     }

 }

 /*
 class Mouse
 {
 }

 class BookPC
 {
     public static void main(String[] args)
     {
         useMouse(new Mouse());
     }
     public static void useMOuse(Mouse m)
     {
         m.open();
     }
     public static void useMOuse(Mouse m)
     {
         m.open();
     }
 }
 */

 先暴露接口，使用接口的时候再实现接口，就可以做到功能的扩展。