接口的知识点

抽象类，和接口的区别
    抽象类： 只能被单继承。可以多层继承
    接口： 可以多实现。

-------------抽象类----------------

1 通过学习抽象类引入接口

    抽象： 就是对一类事物抽象的描述，不是具体的。
    抽象的 abstract 关键字修饰    （非具体可实现的）
    
    类被 abstract     修饰
            特点： 变成了抽象类：就不能被实例化
    
    方法被 abstract 修饰
            特点1： 强制子类，重写这个方法。
            特点2： 被抽象的方法，没有方法体。
                public 返回值类型 方法名();

                
    练习：
        Animal 动物类。 被抽象 abstract 修饰，有吃饭的方法eat()
        Cat  Dog 继承于这个 动物类。
            
        测试类，多态的形式创建对象。
            调用他们分别的吃饭的方法。
            
            也可以在测试类中，尝试创建动物类对象。
                用动物类对象，来调用eat 吃饭方法
                验证，抽象类， 不能实例化。方法抽象不可用。
            
    
    面试题：
    注意：
            1. 如果 不想重写抽象类中的抽象方法；            
                    那么这个类也必须是抽象的，否则必须重写。
                    
            2。        抽象类中  不一定有抽象方法
                    有抽象方法的类，一定得是抽象类。或者是接口
                    
                    
                    
2 总结抽象类中，成员的特点：
        抽象类中的成员属性：     可以是变量 也可以是常量
                                不能被抽象 abstract 修饰。
        抽象类中的构造方法：
                                构造方法不能被抽象。
                                抽象类中虽然不能具体实例化，但是有构造方法
                                是为了给子类，初始化数据用的。
                                
        抽象类中的成员方法：     可以被抽象abstract 修饰，也可以不抽象。
                                被抽象的方法，强制子类来重写实现。
                                
                                没被抽象的方法，子类可以选择性的根据需求重写
    练习：
         定义一个抽象类，葵花宝典类。
         
            定义几个类， 令狐冲，岳不群，东方不败。继承于葵花宝典类。
            
            每个人实现 自宫方法。
                
                    
3. 方法修饰词中 抽象关键字 abstract 不能和哪些关键字共存        
        
        abstract 不能和 static 共存
                被abstract修饰的方法，没有方法体。
                而 static修饰的方法，是为了类名直接调用实现方法功能。
                没有方法体的抽象方法，失去了方法功能，也就没有意义。
        
        abstract 不能和 final 共存
                被abstract修饰的方法，是强制子类来重写实现的。
                被final 修饰的方法，是最终的不能被改变的，子类不能重写。
                二者冲突！！！        
        
        abstract 不能和 private 共存
                被abstract修饰的方法，是强制子类来重写实现的。
                被private 修饰的方法，子类压根就访问不到！
                所以二者也是冲突的。

    提问：
            如果一个抽象类中，没有抽象方法！！！
            那么这个抽象类，还有意义吗？ 他有什么作用？
            
        ——>    虽然抽象类，不能创建本类对象。
            
        ——>    但是，可以以   多态的形式创建子类对象。

--------接口----------

1.    类和接口的区别：
            类只能单继承，可以多层继承。（迭代继承）
            接口可以多实现，一个类，能实现多个接口（扩展功能）

    接口关键字：             interface 
    子类实现接口用关键字 ： implements
    
    
    练习： 定义一个HP3电脑类：继承于 HP1
                运行软件的功能，
                
            同时实现一些接口：interface
            
                USB接口：        USBConnection（）
                蓝牙接口：        BlueToothConnection（）
                wifi接口：        WIFIConnection()
                
            让你的电脑实现以上三个接口： implements 
                具备链接usb 设备，蓝牙设备，链接wifi的功能
                

    

2. 接口的特性
    <1>接口的特性:
        接口不可以被实例化 （和抽象类一样）        
        接口中所有方法都是抽象方法，实现类必须实现接口的所有方法
        实现类可以实现多个接口
        接口中的变量都是静态常量

            实现接口的类，如果 不想重写接口中的抽象方法怎么办？
            子类可以为抽象类，那么就不用重写方法了！
        
    <2>类和接口的关系：                     
        接口和接口之间是继承关系    只能单继承
        类和类之间是继承关系    只能单继承        
        类和接口之间是 实现的关系，可以多实现            
        类和接口，不能产生继承关系；
    

  练习： 了解接口的实现，通过特点来完成接口
        需求， 定义一个接口类。 USB  被interface 修饰。
                    定义一个传输数据的方法。
                     sbstract sendData();
        
            定义两个实现类：
                    usb鼠标
                    usb键盘
            
                    必须重写，传输数据的方法。
        
3. 实现类可以实现多个接口
    
        创建一个电脑类。
        
            链接打印机，打印机接口。print()；
            
            链接蓝牙音响，蓝牙接口。 BlueToothConnection
            
            链接usb 鼠标 ，需要有usb接口  USBConnection

        测试类：
            创建电脑对象，
                调用 打印，蓝牙播放音乐 ，鼠标点击方法。

        结论：
        一个类，可以实现多个接口，
        每实现一个接口，就必须重写接口中的方法。

4 .接口中的变量都是静态常量
        在接口中，所有的变量，都是被 public static final 修饰的。
            接口中的所有变量都是常量。l
            
            在接口中，如果你不给你的变量写修饰词，
            底层默认会给你的变量添加 ：  public static final 修饰词

            （建议，永远，自己写上这三个 修饰词）

5.接口中成员的特点
        成员属性：在接口中，所有的变量都是常量，
                    默认的修饰词是public static final
        
        成员方法：所有方法都是抽象方法，要求实现类必须重写。
                   默认的修饰词是 public abstract
        
        构造方法：接口没有构造方法！