Java基础--面向对象高级（4）接口接口：接口就是一个规则，并且是独立继承体系以外的规则（干爹）；书写格式：关键

接口

接口：接口就是一个规则，并且是独立继承体系以外的规则（干爹）；
书写格式：关键字interface来定义

public interface 接口名{...}

使用：接口和类之间的是实现关系，通过implements关键字表示

public class 类名 implement接口{...}

注意点：

接口中成员的特点

成员变量：只能是常量。默认修饰符： public static final；

      **（public static final）** int a ;  
      虚拟机自动加括号里的修饰符

构造方法：没有（接口不能创建对象，因为接口里的都是常量，已经有数值了；构造方法的用途就是给成员变量赋值；
成员方法： jdk7以前只能是抽象方法默认用public abstract 修饰；
```
      jdk9现在已经可以写私有化成员方法了；
      
```

接口和类之间的关系：

示例：

Person：
因为不想让外界创建人的对象，直接创建顶层父类人的对象没有意义；
所以定义为抽象的；

public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

Sporter：
定义抽象方法学习，以供细分职业运动员子类重写使用；

public abstract class Sporter extends Person {

    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

Coach:
定义抽象方法教学，以供细分职业教练子类重写使用；

public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void Coach();
}

LearnEnglish:
定义英语接口，让需要学英语的子类implement；方法

public interface LearnEnglish {
    void English();
}

PingPongSporter:
这里展示Sporter 重写了英语和学习方法；

public class PingPongSporter extends Sporter implements LearnEnglish {
    public PingPongSporter() {
    }

    public PingPongSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("学习乒乓球");
    }

    @Override
    public void English() {
        System.out.println("学习英语");
    }
}

PingPongCoach:
展示教练，重写了教学和英语方法；

public class PingPongCoach extends Coach implements LearnEnglish {
    public PingPongCoach(String name, int age) {
        super(name, age);
    }

    public PingPongCoach() {
    }

    @Override
    public void Coach() {
        System.out.println("教练乒乓球");
    }

    @Override
    public void English() {
        System.out.println("学习英语");
    }
}

Test:
在测试类中创建乒乓运动员对象，并调用学习、英语方法，成功输出；

public class Test {
    public static void main(String[] args) {
        PingPongSporter s = new PingPongSporter("东海帝皇", 18);
        System.out.println(s.getName() + s.getAge());
        s.English();
        s.study();
    }
}

运行结果：

接口在JDK8、JDK9的新特性

红框内容是后加的，在加之前下面的两个代码是正常运行的，加了之后就会报错；
现实中时会有这样的情况，在项目开发中，需要进行版本升级ver2.0；版本升级就需要进行对接口升级添加方法；
类似红框中的方法，加了之后实现接口的代码就会报错；

解决方法就是定义有方法体的方法：

Jdk8以后的新特性：

1.默认方法

书写格式以及注意事项：

如果子类中需要重写默认方法，在子类中重写的时候需要去掉default关键字；

接口A：输出的是methodA

public interface InterA {
    public default void MethodA() {
        System.out.println("methodA");
    }
}

接口实现类：输出的是重写A ----------

public class InterImpl implements InterA {
    public void MethodA() {
        System.out.println("重写A");
    }
}

- Test：输出重写A

public class Test {
    public static void main(String[] args) {
        InterImpl a = new InterImpl();
        a.MethodA();//重写A
    }
}

字面意思，如果InterA和InterB都有一个 public default void Method() {}，那么实现类InterImpl必须对该方法进行重写

这样才不会报错

public class InterImpl implements InterA, InterB {
    @Override
    public void Method() {
        System.out.println("重写Method");
    }
  }

2.静态方法

Inter.method();  √
InterImpl.method ×

3.私有方法(JDK9)

为了抽取静态方法和默认方法重复代码而出现的；
（原先使用一个新的默认public default方法归类重复代码，但这种方式能被外界直接调用），所以使用了private修饰符；

格式：

示例：