接口---相关操作

接口—相关操作

接口使用步骤

接口MyInterfaceAbstract

package cn.xiaoge.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();

}

实现类MyInterfaceAbstractImplements

package cn.xiaoge.day10.demo01;

public class MyInterfaceAbstractImplements 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("这是第四个方法");
    }
}

执行路口

package cn.xiaoge.day10.demo01;

/*
接口就是多个类的公共规范.
接口是一种引用数据类型, 最重要的内容就是其中的: 抽象方法.

如何定义一个接口的格式:
public interface 接口名称 {
    // 接口名称
}

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

如果是Java 7, 那么接口中可以包含的内容有:
1. 常量
2. 抽象方法

如果是Java 8, 还可以额外包含有:
3. 默认方法
4. 静态方法

如果是Java 9, 还可以额外包含有:
5. 私有方法

接口使用步骤:
1. 接口不能直接使用, 必须有一个"实现类"来"实现"该接口.
格式:
public 返回值类型 实现类名称 implements 接口名称{
    // ...
}
2. 接口的实现类必须覆盖重写接口中所有的抽象方法.
实现: 去掉abstract关键字, 加上方法大括号.
3. 创建实现类的对象, 进行使用.

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

public class Demo01Interface {

    public static void main(String[] args) {
        // 错误写法! 不能直接new接口对象使用.
        // MyInterfaceAbstract inter = new MyInterfaceAbstract();

        // 创建实现类的对象使用
        MyInterfaceAbstractImplements myInterfaceAbstractImplements = new MyInterfaceAbstractImplements();
        myInterfaceAbstractImplements.methodAbs1();
        myInterfaceAbstractImplements.methodAbs2();
        myInterfaceAbstractImplements.methodAbs3();
        myInterfaceAbstractImplements.methodAbs4();

    }

}

// 运行结果
这是第一个方法
这是第二个方法
这是第三个方法
这是第四个方法

接口默认方法

MyInterfaceDefault接口

package cn.xiaoge.day10.demo01;

/*
从Java 8开始, 接口里允许定义默认方法:
格式:
public default 返回值类型 方法名称(参数列表){
    方法体
}

备注: 接口当中的默认方法, 可以解决接口升级问题.
 */

public interface MyInterfaceDefault {

    // 抽象方法
    public abstract void methodAbs();

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

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

}

实现类MyInterfaceDefaultB

package cn.xiaoge.day10.demo01;

public class MyInterfaceDefaultB implements MyInterfaceDefault {

    @Override
    public void methodAbs() {

        System.out.println("实现了抽象方法, BBB");

    }

    @Override
    public void methodDefault() {
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}

实现类MyInterfaceDefaultA

package cn.xiaoge.day10.demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault {

    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法, AAA");
    }

}

执行路口

package cn.xiaoge.day10.demo01;

/*
1. 接口的默认方法, 可以通过接口实现类对象, 直接调用.
2. 接口的默认方法, 也可以被接口实现类进行覆盖重写.
 */

public class Demo02Interface {

    public static void main(String[] args) {
        // 创建实现类
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();
        a.methodAbs(); // 调用抽象方法, 实现运行的是右侧实现类
        // 调用默认方法, 如果实现类中没有, 会向上找接口.
        a.methodDefault();  // 这是新添加的默认方法

        System.out.println("==========================");

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

}

// 运行结果
实现了抽象方法, AAA
这是新添加的默认方法
==========================
实现了抽象方法, BBB
实现类B覆盖重写了接口的默认方法

接口静态方法

接口MyInterfaceStatic

package cn.xiaoge.day10.demo01;

/*
从Java 8开始, 接口当中允许定义静态方法.
格式:
public static 返回值类型 方法名称(参数列表){
    方法体
}
提示: 就是将abstract或者default换成static即可, 带上方法体.

 */

public interface MyInterfaceStatic {

    public static void methodStatic() {
        
        System.out.println("这是接口的静态方法!");
    }

}

实现类

package cn.xiaoge.day10.demo01;

public class MyInterfaceStaticImplements implements MyInterfaceStatic {
}

执行路口

package cn.xiaoge.day10.demo01;

/*
注意事项: 不能通过接口实现类的对象来调用接口当中的静态方法.
正确用法: 通过接口名称, 直接调用其中的静态方法.
格式:
接口名称.静态方法名(参数);
 */

public class Demo03Interface {

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

        // 错误写法! 接口的静态方法只能用  接口名.静态方法
        // impl.methodStatic();

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

}

// 运行结果
这是接口的静态方法!

私有方法

接口MyInterfacePrivateA

package cn.xiaoge.day10.demo01;

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

解决方案:
从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");
    }

}

接口MyInterfacePrivateB

package cn.xiaoge.day10.demo01;


public interface MyInterfacePrivateB {

    public static void methodStatic1() {
        System.out.println("默认方法1");
        MyInterfacePrivateB.methodStaticCommon();
    }

    public static void methodStatic2() {
        System.out.println("默认方法2");
        MyInterfacePrivateB.methodStaticCommon();
    }

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

}

实现类MyInterfacePrivateAImpl

package cn.xiaoge.day10.demo01;

public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {


}

执行路口

package cn.xiaoge.day10.demo01;

public class Demo04Interface {

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

}

// 执行结果
System.out.println("默认方法1");
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");

System.out.println("默认方法2");
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");

接口常量

接口MyInterfaceConst

package cn.xiaoge.day10.demo01;

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

注意事项:
1. 接口当中的常量, 可以省略public static final, 注意: 不写也照样是这样.
2. 接口当中的常量, 必须进行赋值: 不能不赋值.
3. 接口中常量的名称, 使用完全大写的字母, 用下划线进行分割.(推荐命名规则).
 */

public interface MyInterfaceConst {

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

}

执行路口

package cn.xiaoge.day10.demo01;

public class Demo05Interface {

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

}

// 执行结果
10

接口小结

在Java 8+版本中, 接口的内容可以有:

1. 成员变量其实是常量, 格式:
[public] [static] [final] 数据类型 常量名称 = 数据值;     []扩起来的关键字可以省略不写

注意:
    常量必须进行赋值, 而且一旦赋值不能改变.
    常量名称完全大写, 用下划线进行分隔.

2. 接口中最重要的就是抽象方法, 格式:
[public] [abstract] 返回值类型  方法名称(参数列表);
注意: 实现类必须覆盖重写接口所有的抽象方法, 除非实现类是抽象类.

3. 从Java 8+开始, 接口里允许定义默认方法, 格式:
[public] default 返回值类型 方法名称(参数列表) {
    方法体
}
注意: 默认方法也可以被覆盖重写

4. 从Java 8+开始, 接口里允许定义静态方法, 格式:
[public] static 返回值类型 方法名称(参数列表) {
    方法体
}
注意: 应该通过接口名称进行调用, 不能通过实现类对象调用接口静态方法

5. 从Java 9+开始, 接口里允许定义私有方法, 格式:
普通私有方法:
    private 返回值类型 方法名称(参数列表) {
        方法体
    }
静态私有方法:
    private static 返回值类型 方法名称(参数列表) {
        方法体
    }
注意: private方法只有接口自己才能调用, 不能被实现类使用或别人使用.

程序使我快乐

发布了275 篇原创文章 · 获赞 89 · 访问量 2万+

私信关注

接口—相关操作

猜你喜欢