Java基础-接口中的默认、静态、私有方法的组成以及注意事项

接口的组成和更新

接口的组成更新：
    常量：
        public static final
    抽象方法：
        public abstract
    默认方法 Java8
    静态方法 Java8 
    私有方法 Java9

接口中的默认方法：

接口中的默认方法：----->主要用于现有接口的升级而不破坏现有的代码

     接口中默认方法得定义：
        格式：
            public default返回值类型方法名（参数列表）{}
        范例：
            public default void show3(){}
    
	需求：
        1.定义一个接口：MyInterface，里面有两个抽象方法
            void show1();
            void show2();
        2.定义接口的两个实现类：
            MyInterfaceImplOne
            MyInterfaceImplTwo
        2.定义测试类：
            MyInterfaceDemo
            在主方法中，按照多态的方式创建对象并使用

接口中默认方法的注意事项：
1. 默认方法不是抽象方法，所以不强制重写。但是可以被重写，重写的时候去点default关键字
2. public可以省略，default不可以省略

MyInterface.java 主文件

  public static void main(String[] args) {
        //按照多态的方式创建对象并使用
        MyInterface my = new MyInterfaceImplOne();
        my.show1();
        my.show2();
        my.show3();
    }

MyInterface.java接口文件

public interface MyInterface {

    void show1();

    void show2();

    //void show3();//如果这样添加的话，在就需要在MyInterfacelmplOne和MyInterfacelmplTwo中重写该方法
    //否则就需要再写一个子接口继承该接口实现其功能

//默认方法，可以重写 在重写得时候需要去掉default,默认方法不会强制实现类去重写默认方法
//    public default void show3(){
//        System.out.println("show3!");
//    }

    default void show3(){//public可以省略
        System.out.println("show3!");
    }
}

MyInterfaceSon.java MyInterface.java接口的子接口文件

public interface MyInterfaceSon extends MyInterface {
    void show3();//系统需要添加功能方法得时候，添加得方法
}

MyInterface.java 接口的实现类 MyInterfaceimplOne.java 文件

public class MyInterfaceImplOne implements MyInterface {
    @Override
    public void show1() {
        System.out.println("One show1!");
    }

    @Override
    public void show2() {
        System.out.println("One show2!");
    }

    @Override
    public void show3() {
        System.out.println("One show3!");
    }
}

MyInterface.java 接口的实现类 MyInterfaceimplTwo.java 文件

public class MyInterfaceImplTwo implements MyInterface {
    @Override
    public void show1() {
        System.out.println("Two show1!");
    }

    @Override
    public void show2() {
        System.out.println("Two show2!");
    }

    @Override
    public void show3() {
        System.out.println("Two show3!");
    }
}

实现结果：

  One show1!
  One show2!
  One show3!

接口中的静态方法：

接口中静态方法的定义格式：
    格式：
        public static 返回值类型 方法名（参数列表）{}
    范例：
        public static void show(){}
 需求：
    1.定义一个接口Inter，里面有三个方法：一个抽象方法，一个默认方法，一个静态方法
        void show();
        default void method(){}
        public static void test(){}
    2. 定义一个接口的实现类：
        InterImpl
    3.定义测试类
        InterDemo
        在主方法中，按照多态的方式创建并使用

接口中的静态方法的注意事项：
1. 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
2. public可以省略，static不能省略

InterDemo.java 主文件

    public static void main(String[] args) {
        //按照多态的方式创建并使用
        Inter i = new InerImpl();
        i.show();
        i.method();
        //i.test();//接口中的静态方法只能由接口实现

        Inter.test();
    }

Inter.java 接口文件

public interface Inter {//Inter接口
    //抽象方法
    void show();

    //默认方法
    default void method(){
        System.out.println("Inter中的默认方法执行了！！");
    }

    //静态方法
//    public static void test(){
//        System.out.println("Inter中的静态方法实现了！！");
//    }

    static void test(){//public关键字可以省略
        System.out.println("Inter中的静态方法实现了！！");
    }
}

Inter.java 接口的实现类 Interlmpl.java 文件

public class InerImpl implements Inter{//Inter接口的实现类

    @Override
    public void show() {
        System.out.println("Inter中的抽象方法show实现了！！");
    }
}

实现结果：

Inter中的抽象方法show实现了！！
Inter中的默认方法执行了！！
Inter中的静态方法实现了！！

接口中的私有方法：

接口中的私有方法定义格式：
    格式1：
        private返回值类型 方法名（参数列表）{}
    范例：
        private void show(){}
    格式2：
        private static 返回值类型 方法名 （参数列表）{}
    范例：
        private static void method(){}
需求：
    1.定义一个接口Inter，里面四个方法：两个默认方法，两个静态方法
        default void show1(){}
        default void show2(){}
        static void method1(){}
        static void method2(){}
    2.定义接口的实现类
        InterImpl
    3.定义测试类：
        InterDemo
        在主方法中，按照多态的方式创建并使用

接口中私有方法的注意事项：
1. 默认方法可以调用私有的静态方法和非静态方法
2. 静态方法只能调用私有的静态方法

InterDemo.java 主文件

    public static void main(String[] args) {
        Inter i = new InterImpl();

        i.show1();
        i.show2();

        Inter.method1();
        Inter.method2();
    }

Inter.java接口文件

public interface Inter {
    //两个默认方法
    default void show1(){
        System.out.println("show1开始执行！！");
//        System.out.println("初级工程师！！");
//        System.out.println("中级工程师！！");
//        System.out.println("高级工程师！！");
        show();
        //method();//默认方法可以调用私有静态方法
        System.out.println("show1结束执行！！");
    }

    default void show2(){
        System.out.println("show2开始执行！！");
//        System.out.println("初级工程师！！");
//        System.out.println("中级工程师！！");
//        System.out.println("高级工程师！！");
        show();
        System.out.println("show2结束执行！！");
    }

    private void show(){//私有方法
        System.out.println("初级工程师！！");
        System.out.println("中级工程师！！");
        System.out.println("高级工程师！！");
    }

    //两个静态方法
    static void method1(){
        System.out.println("method1开始执行！！");
//        System.out.println("初级工程师！！");
//        System.out.println("中级工程师！！");
//        System.out.println("高级工程师！！");
        ///show();//报错  静态方法不能调用非静态方法
        method();
        System.out.println("method1结束执行！！");
    }

    static void method2(){
        System.out.println("method2开始执行！！");
//        System.out.println("初级工程师！！");
//        System.out.println("中级工程师！！");
//        System.out.println("高级工程师！！");
        method();
        System.out.println("method2结束执行！！");
    }

    private static void method() {//私有的静态方法
        System.out.println("初级工程师！！");
        System.out.println("中级工程师！！");
        System.out.println("高级工程师！！");
    }
}

InterImpl.java Inter.java接口实现类

public class InterImpl implements Inter {
	//
}

实现结果：

show1开始执行！！
初级工程师！！
中级工程师！！
高级工程师！！
show1结束执行！！
show2开始执行！！
初级工程师！！
中级工程师！！
高级工程师！！
show2结束执行！！
method1开始执行！！
初级工程师！！
中级工程师！！
高级工程师！！
method1结束执行！！
method2开始执行！！
初级工程师！！
中级工程师！！
高级工程师！！
method2结束执行！！