接口

* 1,接口：
*      接口是更加彻底的抽象。在JDK1.8之前接口中只能是抽象方法和常量
*      接口体现的是规范思想，实现接口的子类必须重写完接口的全部抽象方法
*   接口的定义：
*      修饰符 interface 接口名称{
*          在JDK1.8之前接口中只能是抽象方法和常量
*      }
*   接口成分：
*     在JDK1.8之前接口中只能是抽象方法和常量
*      1，抽象方法
*          接口中的抽象方法可以省略public abstract不写，默认加上
*      2，常量：常量值只有一个，而且在程序运行的过程中不可更改
*          常量一般修饰符是public static final
*          常量的变量名称建议字母全都是大写，多个单词用"_"连接
*          接口中常量是可以省略public static final不写默认会加上
*          public static final String SCHOOL_NAME = "逗逼"；
*
*      小结：
*      接口体现的是规范思想
*      在JDK1.8之前接口中只能是抽象方法和常量
*      接口中的抽象方法  可以省略public abstract不写，默认加上
*      接口中常量   可以省略public static final不写默认会加上
*      除此之外没有其他成分包括构造器
*
* 2,接口的基本实现：
*      子类   继承   父类
*      实现类  实现  接口
*      类与类是继承关系
*      类与接口是实现关系，接口是被类实现的
*      实现接口的类称为;实现类
*   类实现接口的格式
*      修饰符 class 实现类名称 implements 接口1，接口2...{
*
*      }
*   小结;
*      一个类实现接口，这个类称为实现类
*      接口是用来被类实现的，实现的关键字implements接口是可多实现
*      一个类实现接口必须重写完接口中全部的抽象方法，否则这个类要定义成抽象类
*3,接口与接口的多继承
*      类与类单继承：一个类只能继承一个直接父类
*      类与接口多实现：一个类可以同时实现多个接口
*      接口与接口多继承：一个接口可以同时继承多个接口
*

 

public class DemoInterface01 {
    public static void main(String[] args) {
        PingPongMan man = new PingPongMan("逗逼");
        man.run();
        man.competition();
    }
}

interface SportMan{
    //public abstract void run();
    void run();
    void competition();
}

class PingPongMan implements SportMan{
    
    private String name;
    public PingPongMan(String name) {
        this.name = name;
    }
    
    @Override
    public void run() {
        System.out.println(name + "跑");
    }
    
    @Override
    public void competition() {
        System.out.println(name + "比赛");
    }
}

interface Law{
    void rule();
}

interface Go{
    void go();
}

//接口与接口的多继承，用一个接口合并多个借口
interface play extends Law,Go{
    void play();
}

class YaHou implements play{
    
    @Override
    public void rule() {
    
    }
    
    @Override
    public void go() {
    
    }
    
    @Override
    public void play() {
    
    }

  JDK1.8之前的接口中只能是抽象方法和常量
*      JDK1.8开始之后新增的三个方法
*          (1)默认方法：其实就是实例方法
*                --必须用default修饰
*                --默认会加public
*                --只能用接口的是实现类的对象调用
*          (2)静态方法:
*                --可以直接加static修饰
*                --默认会加public修饰
*                --只能用接口的类名本身调用
*          (3)私有方法:1.9才开始支持
*                -- 其实就是私有的实例方法，必须加private修饰
*
*      1，如果实现多个接口，多个接口中存在同名的静态方法并不会冲突
*      原因只能通过各自几口名访问各自的静态方法
*
*      2，当一个类，既继承一个父类(亲爹)，又实现多个接口(干爹)时   //亲爹只有一个，干 *        爹越多越好
*       父类(亲爹)中的成员方法与接口(干爹)中的默认方法重名，子类就近选择执行父类(亲爹) *        的成员方法
*
*      3，当类实现多个接口，多个接口中存在同名的默认方法
*      实现类必须重写这个方法、、大义灭亲，干爹亲爹都不要
*
*      4，接口中，没有构造器，不能创建对象
*      接口时更彻底的抽象，连构造器都没有自然不能创建对象
*
*  面试：抽象类与接口的区别
*      相同点：都有抽象方法，都不能创建对象，都是被子类要么继承，要么实现
*      不同点：
*          抽象类;不仅抽象方法，还有构造器，还有普通成员变量，还有普通方法，还有静态成                   员变量，静态方法，普通类有的都有
*              缺点：单继承
*           接口：只有抽象方法和常量，外加1.8之后的三种方法，虽然没有抽象类丰富，但可以*                多实现
*
*

public class DemoInterface02 {
    public static void main(String[] args) {
        new YaHou1().run();
        
        SportMan1.go();//接口的静态方法只能用接口的类名本身调用
    }
}

interface SportMan1{
    default void run(){
        System.out.println("跑");
    }

    //只能用接口的类名本身调用
    static void go(){
        System.out.println("跑");
    }
    
    //私有方法通常是给私有方法或者默认方法调用的
    private void play(){
        System.out.println("玩");
    }
}
class YaHou1 implements SportMan1{}