JAVA中接口：接口新增方法、注意事项

项目Version2.0需要对Inter接口丰富，加入10个新的抽象方法，此时改了接口就要所有实现类实现这些方法。
项目Version2.0需要扩展功能

public interface Inter {
      ..若干抽象方法
public class InterImplA implements Inter {
}
public class InterImplB implements Inter {
}
}

如何能在丰富接口功能的同时又不对子类代码进行更改呢?

允许接口中直接定义带有方法体的方法

第一种:默认方法

1.类似之前写的普通实例方法:必须用default修饰
2.默认会public修饰。需要用接口的实现类的对象来调用

default void run(){
    System.out.println( "--开始跑--");
}

第二种:静态方法

1.默认会public修饰，必须static修饰。
2.注意:接口的静态方法必须用本身的接口名来调用。

static void inAddr(){
    System.out.println("我们都在黑马培训中心快乐的学习Java! ");
}

第三种:私有方法

1.就是私有的实例方法:，必须使用private修饰，从JDK 1.9才开始有的。
2.只能在本类中被其他的默认方法或者私有方法访问。

private void go(){
    System.out.print1n("--准备--");

1、JDK8开始后新增了那些方法?

1.默认方法:default修饰，实现类对象调用。
2.静态方法:static修饰，必须用当前接口名调用
3.私有方法:private修饰，jdk9开始才有的，只能在接口内部被调用。
4.他们都会默认被public修饰。

JDK8新增的3种方法我们自己在开发中很少使用，通常是Java源码涉及到。现阶段需要理解、识别语法，明白调用关系即可。

package com.itheima.d13_interface_jdk8;

public interface SportMaInter {
    /**
     1、默认方法：其实就是实例方法。
     -- 必须用default修饰，默认会自带public
     -- 必须用接口的实现类的对象来调用
     */
    default void run() {
        System.out.println("这其实就是实例方法。");
    }
    /**
     2、静态方法
     -- 必须static修饰，默认会自带public
     -- 必须用接口名自己调用
     */
    static void inAddr(){
        System.out.println("我们在黑马");
    }

    /**
     3、私有实例方法：
     -- 必须用private修饰
     -- 只能本接口中访问。
     -- 一般给接口中其他的默认方法或者私有实例方法使用的
     */
    private void go(){
        System.out.println("开始跑~~");
    }
}

class PingPongMan implements SportMaInter {
}

class Test{
    public static void main(String[] args) {
        PingPongMan pingPongMan = new PingPongMan();
        pingPongMan.run();
        SportMaInter.inAddr();
    }
}

接口的注意事项

1、接口不能创建对象
2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

package com.itheima.d14_interface_attention;
public class Test {
    public static void main(String[] args) {
        // 目标：了解接口使用的注意事项。
//        1、接口不能创建对象
          // A a = new A();

//        2、一个类实现多个接口，多个接口的规范不能冲突

//        3、一个类实现多个接口，多个接口中有同样的静态方法不冲突。(接口的静态方法只能接口自己调)
           A.test();
           B.test();
//        4、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
          Zi zi = new Zi();
          zi.go();

//        5、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
        Zi2 zi2 = new Zi2();
        zi2.sing();

//        6、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

    }
}
//        6、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
//interface K extends I, J{
//
//}
//interface I{
//    void run();
//}
//
//interface J{
//    String run();
//}



//    5、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
class Zi2 implements GanDie1, GanDie2{
    @Override
    public void sing() {
         GanDie1.super.sing();
         GanDie2.super.sing();
         System.out.println("我唱给大家听了");
    }
}

interface GanDie1{
    default void sing(){
        System.out.println("干爹1让你唱小苹果~");
    }
}

interface GanDie2{
    default void sing(){
        System.out.println("干爹2让你唱征服~");
    }
}


// 4、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
class Zi extends Fu implements GanDie{
    public void go(){
        GanDie.super.run(); // 找干爹这个爸爸的run方法。
    }
}
class Fu {
    public void run(){
        System.out.println("亲爹说赶紧跑路~~");
    }
}
interface GanDie{
    default void run(){
        System.out.println("干爹说留在我身边~~");
    }
}



/**
   接口是干爹。
 */
class C implements A, B{
    @Override
    public void run() {
    }
}

interface B{
    void run();
    static void test(){
    }
}

interface A{
    void run();
    static void test(){
    }
}