JAVA学习笔记（二十八）

最新推荐文章于 2024-09-14 18:46:05 发布

tyryon

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量88

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/tyryon/article/details/127974240

版权

接口的定义基本格式

接口就是多个类的公共规范。

接口是一种引用数据类型，最重要的内容就是其中的:抽象方法

如何定义一个接口的格式:

public interface 接口名称 {

// 接口内容

}

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

如果是Java 7，那么接口中可以包含的内容有:

1.常量

2.抽象方法

如果是Java 8，还可以额外包含有:

3.默认方法静态方法4.

如果是Java 9,还可以额外包含有:

5.私有方法

接口的抽象方法定义

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

格式:public abstract 返回值类型法名称(参数列表);

注意事项:1.接口当中的抽象方法，修饰符必须是两个固定的关键字: public abstract

2.这两个关键字修饰符，可以选择性地省略。 (今天刚学，所以不推荐。)

3.方法的三要素，可以随意定义。

 public interface MyInterfaceAbstract {
     // 这是一个抽象方法
     public abstract void methodAbs1();
     // 这也是抽象方法
     abstract void methodAbs2();
     // 这也是抽象方法
     public void methodAbs3();
     // 这也是抽象方法
     void methodAbs4();
 }

接口的抽象方法使用

接口使用步骤

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

格式

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

2.接口的实现类必须覆盖重写 (实现) 接口中所有的抽象方法。

实现:去掉abstract关键字，加上方法体大括号。

3.创建实现类的对象，进行使用。

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

 public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
     @Override
     public void methodAbs1(){
         System.out.printIn("这是第一个方法!");
     }
     @Override
     public void methodAbs2(){ 
         System.out.printIn("这是第二个方法!");
     }
     @Override
     public void methodAbs3(){ 
         System.out.printn("这是第三个方法!");
     }
     @Override
     public void methodAbs4(){
         System.out.println("这是第四个方法!");
     }
 }

 public static void main(String[] args) {
     // 错误写法!不能直接new接口对象使用。
     //MyInterfaceAbstract inter = new MyInterfaceAbstract();
     // 创建实现类的对象使用
     MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
     impl.methodAbs1();//这是第一个方法!
     impl.methodAbs2();//这是第二个方法!
 }

接口的默认方法定义

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

格式:

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

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

接口的默认方法使用

1.接口的默认方法，可以通过接口实现类对象，直接调用。

2.接口的默认方法，也可以被接口实现类进行覆盖重写。

 public interface MyInterfaceDefault {
     // 抽象方法
     public abstract void methodAbs();
     //新添加了一个抽象方法
     // public abstract void methodAbs2();
     //报错 要全部重写 麻烦
     // 新添加的方法，改成默认方法
     public default void methodDefault() {
         System.out.printIn("这是新添加的默认方法");
     }
 }

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

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

 public class Demo02Interface {
     public static void main(String[] args) {
         // 创建了实现类对象
         MyInterfaceDefaultA a = new MyInterfaceDefaultA();
         a.methodAbs(); //实现了抽象方法，AAA
         // 调用抽象方法，实际运行的是右侧实现类
 
         // 调用默认方法，如果实现类当中没有，会向上找接口
         a.methodDefault(); // 这是新添加的默认方法
         
         System.out.printIn("==========");
 
         MyInterfaceDefaultB b = new MyInterfaceDefaultB();
         b.methodAbs();//实现了抽象方法，BBB
         b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
     }
 }

接口的静态方法定义

从Java 8开始，接口当中允许定义静态方法

格式:

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

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

接口的静态方法使用

注意事项，不能通过接口实现类的对象来调用接口当中的静态方法正确用法:通过接口名称，直接调用其中的静态方法。

格式:

 接口名称.静态方法名(参数);

案例

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

 public static void main(String[] args) {
     // 创建了实现类对象
     MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();//其实不需要
     // 错误写法!
     //impl.methodStatic();
     // 直接通过接口名称调用静态方法
     MyInterfaceStatic.methodStatic();//这是接口的静态方法!
 }

接口的私有方法定义

问题描述:

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

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

 public class Demo03Interface {
     public static void main(String[] args) {
         MyInterfacePrivateA.methodDefault1();
         MyInterfacePrivateA.methodDefault2();
         // 错误写法!
         //MyInterfacePrivateA.methodCommon();
     }
 }

静态私有接口

 public interface MyInterfacePrivateB {
     public static void methodDefault1(){
         System.out.println("静态方法1");
         methodStaticCommon();
     }
     public static void methodDefault2(){
         System.out.println("静态方法2");
         methodStaticCommon();
     }
     private static void methodStaticCommon() {
         System.out.println("AAA");
         System.out.println("BBB");
         System.out.println("CCC");
     }
 }

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

接口的常量定义和使用

接口当中也可以定义“成员变量”，但是必须使用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;
 }

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