package cn.china;
abstract class AbsDemo{
    abstract void show1();
    abstract void show2();
}
/**
 *当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
 *另一种形式定义和表示，就是 接口 interface
 *
 *定义接口使用的关键字不是class，是interface。
 **/
interface Demo5{
    public static final int NUMBER=4;
    public abstract void show1();
    public abstract void show2();
}
/**
 * 类与类之间是继承关系，类与接口是实现关系。
 * 接口不能实例化
 * 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化
 * 否则，这个子类就是一个抽象类*/
class DemoImpl implements Demo5{
    public void show1(){}
    public void show2(){}
}
/**
 * 对于接口当中常见的成员，而且这些成员都有固定的修饰符
 * 1、全局常量：public static final
 * 2、抽象方法 public abstract
 * 由此得出结论，接口中的成员都是公共的权限。*/

/**
 * java中不支持多继承，因为会出现调用的不确定性。
 * 所以java将多继承进行改良，java中变成多实现。
 * 一个类可以实现多个接口*/
interface Aa{
    public abstract void show6();
    
}
interface Bb{
    public abstract void show6();
}
class Test1 implements Aa,Bb{
    public void show6(){
        
    }
    
}
/**
 * 一个类在继承另一个类的同时，还可以实现多个接口
 * 接口与接口*/
class q{
    public void method(){}
}
 class Test2 extends q implements Aa,Bb{
    public  void show6(){
        
    }
    interface cc{
        void showa();
    }
    interface mm{
        void showb();
    }
    interface qq extends cc,mm{//接口与接口可以多继承关系，而且接口可以多继承
        void function();
    }
    class ww implements qq{
        public void showa(){}
        public void showb(){}
        public void function(){}
    }
}
 /**
  * 抽象类与接口的异同点：
  * 相同点：都是不断向上抽取而来的
  * 不同点：
  * 1、抽象类需要被单继承abstract，接口需要被多实现implements
  * 2、抽象类中可以定义抽象方法和非抽象方法，此类继承后可以直接使用非抽象方法。
  * 接口中只能定义抽象方法，必须由子类去实现
  * 3、抽象类是 is a关系在定义该体系共性能容；接口是like a关系，定义体系的额外功能。
  * 
  * 例： 学生有学习功能  可以被提取定义抽象类  ；
  * 学生抽烟功能， 是额外功能  使用interface 接口定义
  * 
  * 例：
  * 犬按功能分，有导盲犬，搜救犬
  * abstract class 犬{
  * abstract void 吼叫();
  * }
  * class 导盲犬 extends 犬 implements 导盲{
  * public void 吼叫(){}
  * public void 导盲(){}
  * }
  * interface 导盲{
  * abstract void 导盲();
  * }*/
 //在不同的问题领域中，有不同的分析方式。
 /**
  * 笔记本电脑使用，
  * 为了扩展笔记本功能，担日后出现什么功能设备不知道
  * 
  * 定义一个规则，只要日后出现的设备都符合这个规则就可以了
  * 规则在java中就是接口 interface*/
// class Mouse{
//     
// }
//class Bookpc{
//    public static void main(String[]args){
//        useMouse(new Mouse());
//    }
//    public static void useMouse(Mouse m){
//        m.open();
//    }
//}
 interface USB{ //暴漏规则
     public abstract void open();
     public abstract void close();
 }
 public class Interface{
        public static void main(String[]args){
//            DemoImpl D=new DemoImpl();
//            System.out.println(D.NUMBER);
//            System.out.println(DemoImpl.NUMBER);
//            System.out.println(Demo.NUMBER);
            // TODO Auto-generated method stub
//            Test1 t=new Test1();
//            t.show6();

            //useUSB(null);
            UPan U=new UPan();
            useUSB(U);//功能扩展了
        }
        //使用规则
        public static void useUSB(USB u){//接口类型的引用，用于接收（指向）接口子类的对象。
            u.open();
            u.close();
        }
        //实现规则
    class UPan implements USB{
            public void open(){
                System.out.println("UPan open");
            }
            public void close(){
                System.out.println("UPan close");
            }
            
        }
 }