20.【接口】

最新推荐文章于 2022-11-22 17:12:47 发布

LiuszZZ

最新推荐文章于 2022-11-22 17:12:47 发布

阅读量216

点赞数

分类专栏： # Dark horse 文章标签： java

原文链接：http://www.itheima.com/

版权

Dark horse 专栏收录该内容

89 篇文章 0 订阅

订阅专栏

概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK7及以前），默认方法和静态方法（JDK8），私有方法（JDK9）。

接口的定义，它与定义类方式类似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组、类、接口。

接口的使用，它不能创建对象，但是可以被实现（implements类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

在这里插入图片描述

定义方式

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

public interface 接口名称{
	// 抽象方法
	// 默认方法
	// 静态方法
	// 私有方法
}

1. 含抽象方法和常量【jdk7】

抽象方法

抽象方法：使用abstract关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

代码如下：

public interface InterfaceName {
 
	public abstract void method();
}

常量

常量：必须使用 public static final 三个关键字进行修饰。【可省略】

从效果上看，这其实就是接口的【常量】

/*
    格式：
    public static final 数据类型 常量名称 = 数据值; 
 */
public interface InterfaceName {
	public static final int NUM_OF_MY_CLASS = 10;
}

注意

一旦使用final关键字修饰，说明不可改变。
接口当中的常量，可以省略 public static final 这三个关键字（写几个都行）
接口当中的常量，必须进行手动赋值，不能不赋值。
接口当中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

2. 含有默认方法和静态方法【jdk8】

默认方法

使用default修饰，不可省略，接口当中的默认方法，可以解决接口升级的问题。供子类调用或者子类重写。

代码如下：

public interface InterfaceName {
	public default 返回值类型 方法名称(参数列表) {
        方法体
    }
}

静态方法

静态方法：使用static修饰，供接口直接调用。

代码如下：

public interface InterfaceName {
	public static void method2() {
		// 执行语句
	}
}

3. 含有私有方法和私有静态方法【jdk9】

私有方法

使用private修饰，供接口中的默认方法或者静态方法调用。

代码如下：

public interface InterFaceName() {
	private void method() {
		// 执行语句
	}
    private static void methodStatic2() {
       // 执行语句
    }
}

基本的实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。

实现的动作类似继承，格式相仿，只是关键字不同，实现使用implements关键字。

非抽象子类实现接口

必须重写接口中所有抽象方法。
继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

class 类名 implements 接口名 {
	// 重写接口中的抽象方法【必须】
	// 重写接口中的默认方法【可选】
}

抽象方法的使用

在任何的版本中，接口都能定义抽象方法

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

注意

接口当中的抽象方法，修饰符必须是两个固定的关键字：public abscract
这两个关键字修饰符，可以选择性省略。
方法的三要素根据情况随意定义。

不一定是void，不一定没有参数

定义接口

package cn.luis.demo1.I1;

public interface MyInterfaceAbstract {

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

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

    // 这还是一个抽象方法
    public void methodAbs3();

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

}

定义实现类

package cn.luis.demo1.I1;

/*
    普通的类，在类名称后面加上implements + 要实现的类名称,就变成了实现类。
 */
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {

    // 实现类必须覆盖重写接口中所有的抽象方法 (快捷键：在类名称那行：alt+回车)
    @Override
    public void methodAbs1() {
        System.out.println("这是第1个方法");
    }

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

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

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

定义测试类

package cn.luis.demo1.I1;

public class Demo01Interface {

    public static void main(String[] args) {
        // error 不能直接new接口对象使用。
//        MyInterfaceAbstract my = new MyInterfaceAbstract();

        // 创建实现类的对象进行使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();

    }
}

结果:

这是第1个方法
这是第2个方法

常量的使用

一旦赋值，不可修改。

public：大家都可用 static：接口名.num final:不可变

代码：

MyInterfaceConst

public interface MyInterfaceConst {

    public static final int NUM_OF_MY_CLASS = 10;
}

Demo05InterfaceConst

public class Demo05InterfaceConst {

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

结果：

默认方法的使用

默认方法会被实现类继承类下来，可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

可以通过接口实现类对象直接调用。
也可以被接口实现类进行覆盖重写。

备注：接口当中的默认方法，可以解决接口升级的问题。

定义接口：

package cn.luis.demo1.I2;

public interface MyInterfaceDefault {

    public default void methodDefault() {  // public是灰色的，说明可以省略不写
        System.out.println("主接口的默认方法");
    }
}

定义实现类：

MyInterfaceDefaultA

package cn.luis.demo1.I2;

public class MyInterfaceDefaultA implements MyInterfaceDefault {
  
}

MyInterfaceDefaultB

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

定义测试类：

package cn.luis.demo1.I2;

public class Demo02Interface {
    public static void main(String[] args) {

        // 创建了实现类对象
        MyInterfaceDefaultA interA = new MyInterfaceDefaultA();
        // 调用默认方法，如果实现类当中没有，会向上找接口的。
        interA.methodDefault();  // 从主接口中来的
        System.out.println("==================");

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

    }
}

结果：

主接口的默认方法
==================
实现类B覆盖重写了接口的默认方法

静态方法的使用

静态与.class文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。

就是将abstract或者default换成static即可，带上方法体。

注意

不能通过接口实现类的对象来调用接口当中的静态方法。
因为一个接口类可以实现多个接口，静态方法可能会产生冲突。

定义接口：

package cn.luis.demo1.I3;

public interface MyInterfaceStatic {

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

定义实现类：

package cn.luis.demo1.I3;

public class MyInterfaceStaticImpl implements MyInterfaceStatic {

}

定义测试类：

package cn.luis.demo1.I3;

/*
    正确用法：
    	通过接口名称，直接调用其中的静态方法。
    格式：
    	接口名称.静态方法(参数);
 */
public class Demo03Interface {

    public static void main(String[] args) {

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

        // error!
//        impl.methodStatic();

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

结果：

这是接口的静态方法！

私有方法的使用

私有方法：只有默认方法可以调用。

私有静态方法：默认方法和静态方法可以调用。

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

问题

需要抽取一个公共方法，用来解决两个默认方法之间的重复代码问题。
但是这个公共方法不应该让实现类使用，应该是私有化的。

定义接口：

MyInterfacePrivateA

package cn.luis.demo1.I4;

public interface MyInterfacePrivateA {

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

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

    // 把相同的代码抽取出来
/*    public default void methodCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }*/

    // 只有1、2方法可以使用  (不能让所有用到此接口的人调用到它)
    private void methodDefaultCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

MyInterfacePrivateB

package cn.luis.demo1.I4;

public interface MyInterfacePrivateB {

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

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

    // 只有1、2方法可以使用  (不能让所有用到此接口的人调用到它)
    private static void methodStaticCommon() {
        System.out.println("大大大");
        System.out.println("小小小");
        System.out.println("变变变");
    }

}

定义实现类：

package cn.luis.demo1.I4;

public class MyInterfacePrivateImpl implements MyInterfacePrivateA {

    public void methodAnother() {
        // 直接访问到了接口中的默认方法，这样是错误的！(这个方法不应该被实现类调用)
//        methodDefaultCommon();
    }
}

定义测试类：

package cn.luis.demo1.I4;

public class Demo04Interface {

    public static void main(String[] args) {
        MyInterfacePrivateB.methodStatic1();
        MyInterfacePrivateB.methodStatic2();
        // 错误写法！
//        MyInterfacePrivateB.methodStaticCommen();
        System.out.println("=========================");
        MyInterfacePrivateImpl ml = new MyInterfacePrivateImpl();
        ml.methodDefault1();
        ml.methodDefault2();
        // 错误写法！
//        ml.methodDefaultCommon();
        System.out.println("=========================");
//        ml.methodStatic1();

    }
}

结果：

静态方法1
大大大
小小小
变变变
静态方法2
大大大
小小小
变变变
=========================
默认方法1
AAA
BBB
CCC
默认方法2
AAA
BBB
CCC

变形

MyInterfacePrivateC

package cn.luis.demo1.I4;

public interface MyInterfacePrivateC {

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

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

    // 只有1、2方法可以使用  (不能让所有用到此接口的人调用到它)
    private static void methodStaticCommon() {
        System.out.println("大大大");
        System.out.println("小小小");
        System.out.println("变变变");
    }

}

MyInterfacePrivateImpl

package cn.luis.demo1.I4;

public class MyInterfacePrivateImpl implements MyInterfacePrivateC {

    public void methodAnother() {
        // 直接访问到了接口中的默认方法，这样是错误的！(这个方法不应该被实现类调用)
//        methodDefaultCommon();
    }
    
}

Demo04Interface

package cn.luis.demo1.I4;

public class Demo04Interface {

    public static void main(String[] args) {
		MyInterfacePrivateImpl ml = new MyInterfacePrivateImpl();
        ml.methodDefault1();
        System.out.println("=========================");
        MyInterfacePrivateC.methodStatic2();
    }
}

结果：

默认方法1
大大大
小小小
变变变
=========================
静态方法2
大大大
小小小
变变变

总结

在Java 9+版本中，接口的内容可以有

1. 成员变量其实是常量

格式

[public] [static] [final] 数据类型 常量名称 = 数据值;

注意

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

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

格式：

[public] [abstract] 返回值类型 方法名称(参数列表);

注意：

实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

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

格式：

[public] default 返回值类型 方法名称(参数列表) { 方法体 }

注意：

默认方法也可以被覆盖重写

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

格式：

[public] static 返回值类型 方法名称(参数列表) { 方法体 }

注意：

通过接口名称进行调用，不能通过实现类对象调用接口静态方法

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

格式：

普通私有方法

private 返回值类型 方法名称(参数列表) { 方法体 }

静态私有方法

private static 返回值类型 方法名称(参数列表) { 方法体 }

注意：

private的方法只有接口自己才能调用，不能被实现类或别人使用。

LiuszZZ

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
20.【接口】

概述接口，是Java语言中一种引用类型，是方法的集合，如果说类内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK7及以前），默认方法和静态方法（JDK8），私有方法（JDK9）。接口的定义，它与定义类方式类似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。引用数据类...
复制链接

扫一扫