Java Object-Oriented：day10 【 Interfaces】

一、接口概述与生活举例

02、接口的定义基本格式

接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

1、如何定义一个接口的格式：

public interface 接口名称 {
    // 接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。

2、那么接口中可以包含的内容有?

二、抽象方法的使用

1、定义

package day10.demo01;

/*
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表);

注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐。）
3. 方法的三要素，可以随意定义。
 */
public interface MyInterfaceAbstract {

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();

}

注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

2、接口使用步骤：

1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：

public class 实现类名称 implements 接口名称 {
    // ...
}

2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。实现：去掉abstract关键字，加上方法体大括号。
3. 创建实现类的对象，进行使用。

3、抽象方法的使用

1、定义接口

package day10.demo01;

/*
在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型 方法名称(参数列表);

注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐。）
3. 方法的三要素，可以随意定义。
 */
public interface MyInterfaceAbstract {

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这也是抽象方法
    abstract void methodAbs2();

    // 这也是抽象方法
    public void methodAbs3();

    // 这也是抽象方法
    void methodAbs4();

}

2、定义实现类

package day10.demo01;

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {

    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法！ ");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法！ ");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是第三个方法！ ");
    }

    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法！ ");
    }
}

3、定义测试类

package day10.demo01;

public class Demo01Interface {
    public static void main(String[] args) {
        // 错误写法！不能直接new接口对象使用。
        //MyInterfaceAbstract inter = new MyInterfaceAbstract();
        // 创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
        impl.methodAbs3();
        impl.methodAbs4();
    }
}

4、实际运行结果

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=57967:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo01.Demo01Interface
这是第一个方法！ 
这是第二个方法！ 
这是第三个方法！ 
这是第四个方法！ 

Process finished with exit code 0

三、默认方法使用

解决了接口升级问题、因为新添加一个方法会影响生产已经运行方法重写、新加的默认方法不会重写生产已经运行的方法

1、定义接口

package day10.demo02;
//开始忘了选择interface可以手动改
public interface MyInterfaceDefault {
        // 抽象方法
        public abstract void methodAbs();

        // 新添加了一个抽象方法
//    public abstract void methodAbs2();

        // 新添加的方法，改成默认方法
        public default void methodDefault() {
            System.out.println("这是新添加的默认方法");
        }

}

2、定义实现类

package day10.demo02;

public class MyInterfaceDefaultA implements MyInterfaceDefault {
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法， AAA");
    }
}

package day10.demo02;

public class MyInterfaceDefaultB implements MyInterfaceDefault {
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，BBB");

    }
}

3、定义测试类

继承默认方法

package day10.demo02;

public class Demo02Interface {
    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。

        // 调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault(); // 这是新添加的默认方法
    }
}

重写默认方法

package day10.demo02;

public class Demo02Interface {
    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。

        // 调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault(); // 这是新添加的默认方法

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
    }
}

4、实际运行结果

继承默认方法

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=59351:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo02.Demo02Interface
实现了抽象方法， AAA
这是新添加的默认方法

Process finished with exit code 0

重写默认方法

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=59376:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo02.Demo02Interface
实现了抽象方法， AAA
这是新添加的默认方法
实现了抽象方法，BBB
这是新添加的默认方法

Process finished with exit code 0

四、接口的静态方法使用

1、定义接口

package day10.demo02;
/*
从Java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表) {
    方法体
}
提示：就是将abstract或者default换成static即可，带上方法体。
 */
public interface MyInterfaceStatic {
    public static void methodStatic() {
        System.out.println("这是接口的静态方法！ ");

    }
}

2、定义实现类

package day10.demo02;

public class MyInterfaceStaticImpl implements MyInterfaceStatic {

}

3、定义测试类

package day10.demo02;
/*
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数);
 */
public class Demo03Interface {

    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

        // 错误写法！
//        impl.methodStatic();

        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }

}

4、运行结果

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=54254:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo02.Demo03Interface
这是接口的静态方法！ 

Process finished with exit code 0

静态和对象没有关系？没关系、既然跟对象没关系为什么还要new一个对象了

        // 创建了实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();

        // 错误写法！
        //impl.methodStatic();

静态跟谁有关系？跟类有关系

        // 直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();

五、接口的私有方法使用

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

1、定义接口

package day10.demo02;
/*
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案：
从Java 9开始，接口当中允许定义私有方法。
1. 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称(参数列表) {
    方法体
}

2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表) {
    方法体
}
 */
public interface MyInterfacePrivateA {

    public default void methodDefault1() {
        System.out.println("默认方法1");
        methodCommon();
    }

    public default void methodDefault2() {
        System.out.println("默认方法2");
        methodCommon();
    }

    private void methodCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}

package day10.demo02;

public interface MyInterfacePrivateB {
    public static void methodStatic1() {
        System.out.println("静态方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
        System.out.println("静态方法2");
        methodStaticCommon();
    }

    private static void methodStaticCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

2、定义实现类

package day10.demo02;

public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
    public void methodAnother() {
        // 直接访问到了接口中的默认方法，这样是错误的！
//        methodCommon();
    }
}

3、定义测试类

package day10.demo02;

public class Demo04Interface {
    public static void main(String[] args) {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();
        // 错误写法！
//        MyInterfacePrivateB.methodStaticCommon();
    }
}

4、运行结果

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=54466:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo02.Demo04Interface
静态方法1
AAA
BBB
CCC
静态方法2
AAA
BBB
CCC

Process finished with exit code 0

六、接口的常量定义和使用

1、定义接口

package day10.demo02;

/*
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】。
格式：
public static final 数据类型 常量名称 = 数据值;
备注：
一旦使用final关键字进行修饰，说明不可改变。

注意事项：
1. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值；不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）
 */
public interface MyInterfaceConst {

    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 12;

}

2、定义测试类

package day10.demo02;

public class Demo05Interface {
    public static void main(String[] args) {
        // 访问接口当中的常量
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

3、运行结果

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=54675:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo02.Demo05Interface
12

Process finished with exit code 0

七、接口的内容小结

1. 成员变量其实是常量

2. 接口中最重要的就是抽象方法

3. 从Java 8开始，接口里允许定义默认方法

4. 从Java 8开始，接口里允许定义静态方法

5. 从Java 9开始，接口里允许定义私有很乏

八、继承父类并实现多个接口

1、接口是没有静态代码块或者构造方法的。

package day10.demo02;

public interface MyInterfaceA {

    // 错误写法！接口不能有静态代码块
//    static {
//
//    }

    // 错误写法！接口不能有构造方法
//    public MyInterfaceA() {
//
//    }

2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
    // 重写接口中抽象方法【必须】
   // 重写接口中默认方法【不重名时可选】  
}

[ ]：表示可选操作。

1、定义多个接口

package day10.demo02;

public interface MyInterfaceA {

    public abstract void methodA();

}

package day10.demo02;

public interface MyInterfaceB {

    public abstract void methodB();

}

2、定义实现类

package day10.demo02;

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }

3、如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可

1、定义多个接口

package day10.demo02;

public interface MyInterfaceA {
    public abstract void methodA();
    public abstract void methodAbs();
}

package day10.demo02;

public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodAbs();
}

2、定义实现类

package day10.demo02;

public class MyInterfaceImpl /*extends object*/ implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }

    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了AB方法");
    }
}

4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类

1、定义多个接口

package day10.demo02;

public interface MyInterfaceA {
    public abstract void methodA();
    public abstract void methodAbs();
}

package day10.demo02;

public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodAbs();
}

2、定义实现类

package day10.demo02;

public abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB {
    @Override
    public void methodA() {

    }
    

    @Override
    public void methodDefault() {

    }


}

5、如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

1、定义多个接口

package day10.demo02;

public interface MyInterfaceA {
    public default void methodDefault() {
        System.out.println("默认方法AAA");
    }

}

package day10.demo02;

public interface MyInterfaceB {

    public default void methodDefault() {
        System.out.println("默认方法BBB");
    }

}

2、定义实现类

package day10.demo02;

public class MyInterfaceImpl /*extends object*/ implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");
    }

    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了AB方法");
    }

    @Override
    public void methodDefault() {       
        System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写了");
        
    }
}

父亲让你做语文作业、母亲让你做数学作业

6、一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

1、定义多个接口

package day10.demo02;

public interface MyInterface {

    public default void method() {
        System.out.println("接口的默认方法");
    }

}

2、定义父子类

package day10.demo02;

public class Fu {

    public void method() {
        System.out.println("父类方法");
    }

}

package day10.demo02;

public class Zi extends Fu implements MyInterface {
}

3、定义测试结果

package day10.demo02;

/*
使用接口的时候，需要注意：

1. 接口是没有静态代码块或者构造方法的。
2. 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
    // 覆盖重写所有抽象方法
}
3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4. 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6. 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
 */
public class Demo01Interface {

    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }

}

4、运行结果

"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=51747:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day10.demo02.Demo01Interface
父类方法

Process finished with exit code 0

九、接口之间的多继承

1、定义父接口

package day10.demo03;

public interface MyInterfaceA {

    public abstract void methodA();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("AAA");
    }

}

package day10.demo03;

public interface MyInterfaceB {

    public abstract void methodB();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("BBB");
    }

}

2、定义子接口

package day10.demo03;
/*
这个子接口当中有几个方法？答：4个。
methodA 来源于接口A
methodB 来源于接口B
methodCommon 同时来源于接口A和B
method 来源于我自己
 */
public interface MyInterface extends MyInterfaceA, MyInterfaceB {

    public abstract void method();

    @Override
    public default void methodDefault() {

    }
}

3、定义实现类

package day10.demo03;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {

    }

    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodCommon() {

    }
}

4、定义测试类

package day10.demo03;
/*
1. 类与类之间是单继承的。直接父类只有一个。
2. 类与接口之间是多实现的。一个类可以实现多个接口。
3. 接口与接口之间是多继承的。

注意事项：
1. 多个父接口当中的抽象方法如果重复，没关系。
2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。
 */

public class Demo01Relations {
}

posted @ 2020-05-16 22:17 活的潇洒80 阅读(229) 评论(0) 编辑收藏举报

刷新页面返回顶部

运维人生

Java Object-Oriented：day10 【 Interfaces】

一、接口概述与生活举例

02、接口的定义基本格式

1、如何定义一个接口的格式：

2、那么接口中可以包含的内容有?

二、抽象方法的使用

1、定义

2、接口使用步骤：

3、抽象方法的使用

三、默认方法使用

1、定义接口

2、定义实现类

3、定义测试类

4、实际运行结果

四、接口的静态方法使用

1、定义接口

2、定义实现类

3、定义测试类

4、运行结果

五、接口的私有方法使用

1、定义接口

2、定义实现类

3、定义测试类

4、运行结果

六、接口的常量定义和使用

1、定义接口

2、定义测试类

3、运行结果

七、接口的内容小结

1. 成员变量其实是常量

2. 接口中最重要的就是抽象方法

3. 从Java 8开始，接口里允许定义默认方法

4. 从Java 8开始，接口里允许定义静态方法

5. 从Java 9开始，接口里允许定义私有很乏

八、继承父类并实现多个接口

1、接口是没有静态代码块或者构造方法的。

2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

1、定义多个接口

2、定义实现类

3、如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可

1、定义多个接口

2、定义实现类

4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类

1、定义多个接口

2、定义实现类

5、如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

1、定义多个接口

2、定义实现类

6、一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

1、定义多个接口

2、定义父子类

3、定义测试结果

4、运行结果

九、接口之间的多继承

1、定义父接口

2、定义子接口

3、定义实现类

4、定义测试类

公告