接口

最新推荐文章于 2022-10-12 15:12:47 发布

ning96

最新推荐文章于 2022-10-12 15:12:47 发布

阅读量180

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/ning96/article/details/104241157

版权

Java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

接口

生活中的接口：电源接口

接口是一种【公共的规范标准】，只要符合规范标准，及可以大家通用

USB接口：只要符合usb接口的规范，那么各种设备都可以使用

接口的基本定义格式

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

public interface 接口名称{

//接口内容

}

备注：换成了关键字interface之后，编译生成的字节文件仍然是：.java变成.class
如果是java 7，那么接口中可以包含的内容有
- 常量
- 抽象方法
如果是java 8，还可以额外包含有：
- 默认方法
- 静态方法
如果是java 9,还可以额外包含有：
- 私有方法

接口的抽象方法定义

在任何版本的Java中，接口都能定义抽象方法
格式：
- public abstract 返回值类型方法名称（参数列表）；
注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略
3. 方法的三要素，可以随意定义

package Demo11;

public interface MyinterfaceAbstract {

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

接口的抽象方法使用

步骤

接口不能直接使用，必须有一个实现类来实现该接口

格式：
- public class 实现类名称 implements 接口名称{
  
  //…
  
  }
接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
- 实现：去掉abstract关键字，加上方法体大括号

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

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

package Demo11;

public interface MyinterfaceAbstract {

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

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

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

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

package Demo11;

public class MyinterfaceAbstractImpl implements MyinterfaceAbstract {
    //这里不用挨个写，点红线然后alt加回车 全选，再回车
    @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 Demo11;

public class Demo01 {
    public static void main(String[] args) {
        //错误写法！不能字节new接口对象使用
//        MyinterfaceAbstract inter = new MyinterfaceAbstract();

        //创建实现类的对象使用
        MyinterfaceAbstractImpl impl1 = new MyinterfaceAbstractImpl();
        impl1.methodAbs1();
        impl1.methodAbs2();

    }
}

接口的默认方法定义

从Java 8开始，接口里允许定义默认方法
- 格式：
  
  public defalut 返回值类型方法名称（参数列表）{
  
  方法体
  
  }
- 备注：接口中的默认方法可以解决接口的升级问题

使用

接口的默认方法，可以通过接口的实现类，直接调用
接口的默认方法，也可以被接口实现类进行覆盖重写

package Demo11;

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

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

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

package Demo11;

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

package Demo11;

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

    }
}

package Demo11;

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

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

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

接口的静态方法定义

从Java 8开始，接口中允许定义静态方法
格式：
- public static 返回值类型方法名称（参数列表）{
  
  方法体
  
  }
  
  提示：就是将abstract 或者default换成static即可，带上方法体

使用

注意：不能通过接口实现类的对象来调用接口当中的静态方法

正确用法：通过接口名称直接调用其中的静态方法。

格式：

接口名称。静态方法名（参数）

package Demo11;

public interface MyInterfaceStatic {

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

package Demo11;

public class MyIntrerfaceStaticImpl implements MyInterfaceStatic {


}

package Demo11;

public class Demo03Interface {

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

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

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

接口的私有方法定义

问题描述：

需要抽取一个公共方法，用来解决两个默认方法之间重复代码的问题

但是这个共有方法不应该让实现类使用，应该是私有化的

解决方案：

从Java 9 开始，接口当中允许定义私有方法

普通私有方法，解决多个默认方法之间重复代码的问题

格式：

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

方法体

}
静态私有方法，解决多个静态方法之间重复代码的问题

格式：

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

方法体

}

package Demo11;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public interface MyinterfacePrivateA {

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

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

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

}

package Demo11;

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");

    }



}

package Demo11;

public class Deomo04Interface {
    public static void main(String[] args) {
        MyinterfacePrivateB.methodStatic1();
        MyinterfacePrivateB.methodStatic2();

        //错误写法
//        MyinterfacePrivateB.methodCommon();
    }
}

接口的常量定义和使用

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰，从效果上看，这其实就是接口的【常量】
- 格式
  
  public static final 数据类型常量名称 = 数据值；
- 备注：
  - 一旦只用final关键字进行修饰，说明不可变
- 注意事项：
  1. 接口中的常量，可以省略public static final，但是注意，不写也照样是这样
  2. 接口当中的常量，必须进行赋值，不能不赋值
  3. 接口中常量的名称必须是大写，用下划线进行分隔（命名规则）

package Demo11;

public interface MyinterfaceConts {

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

package Demo11;

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


}

接口内容小结

再Java9+版本中，接口的内容可以有

成员变量其实是常量，格式：
- public static final 数据类型常量名称 = 数据值；
- 注意：
  - 常量必须进行赋值，而且一旦赋值不能改变
  - 常量名称必须完全大写，用写下划线进行分割
接口中最重要的就是抽象方法，格式：
- public abstrat 返回值类型方法名称（参数列表）；
- 注意：
  - 实现类必须覆盖重写接口所有的抽象方法，除非实现的是抽象类
从Java 8 开始，接口里允许定义默认方法，格式：
- public default 返回值类型方法名称（参数列表）{方法体}
- 注意：
  - 默认方法也可以被覆盖重写
从Java 8 开始接口里允许定义静态方法，格式：
- public static 返回值类型方法名称（参数列表） {方法体}
- 注意：
  - 应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
从Java 9 开始，接口里允许定义私有方法，格式：
- 普通私有方法：private 返回值类型方法名称（参数列表）{方法体}
- 静态私有方法：private static 返回值类型方法名称（参数列表）{方法体}
- 注意：
  - private 的方法只有接口自己才能调用，不能被实现类或别人使用

继承父类并实现多个接口

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

package Demo12;

public interface MyInterface {

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

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

    public abstract void methodA();

    public abstract void methodAbs();

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

package Demo12;

public interface MyInterfaceB {

    public abstract void methodB();

    public abstract void methodAbs();

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

package Demo12;

import Demo12.MyInterface;
import Demo12.MyInterfaceB;
   //对应上述第四点 少了methodB 所以class前加了abstract
public abstract class MinterfaceAbstract implements MyInterface, MyInterfaceB {
    @Override
    public void methodA() {

    }


    @Override
    public void methodAbs() {

    }

       @Override
       public void methodDefault() {

       }


   }

package Demo12;

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

package Demo12;

public class Zi extends Fu implements MyInterface0{
}

package Demo12;

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

package Demo12;

public class MyInterfaceImpl implements MyInterface,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("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

package Demo12;

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

接口之间的多继承

类和类之间是单继承的，直接父类只有一个
类与接口是多实现的，一个类可以实现多个接口
接口与接口之间是多继承的

ning96

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录