JAVA_面向对象_接口

最新推荐文章于 2024-07-21 22:27:18 发布

kaichenkai

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量227

点赞数

分类专栏： java开发之路文章标签： java interface

本文链接：https://blog.csdn.net/m0_37714245/article/details/88151939

版权

java开发之路专栏收录该内容

8 篇文章 0 订阅

订阅专栏

接口定义

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

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

定义格式：
```
public interface MyInterfaceAbstract {
    // 这是一个抽象方法(public abstract 可省略)
    public abstract void methodAbs();
}
```
如果是java 7，那么接口中可以包含：常量、抽象方法

如果是java 8，还可以包含：默认方法、静态方法

如果是java 9，还可以额外包含：私有方法

使用接口

接口不能直接使用，必须有一个实现类来实现该接口
实现类必须覆盖重写接口中所有的抽象方法(去掉 abstract 关键字，加上方法体大括号)

如果实现类没有覆盖重写接口中所有的抽象方法，那么这个实现类必须是抽象类
创建实现类对象，进行调用操作

// 实现类
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
    @Override
    public void methodAbs(){
        System.out.println("first method execute");
    }

    public static void main(String[] args){
        // 创建实现类对象，进行方法调用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs();  // first method execute
    }
}

默认方法定义(默认方法有方法体)

remarks:

接口当中的默认方法，可以解决接口升级的问题
可以通过实现类对象，直接调用
也可以在实现类中进行覆盖重写

// 接口
public interface MyInterfaceDefault {
    // 抽象方法
    public abstract void methodAbs();

    // 默认方法(public 可省略)
    public default void methodDefault(){
        System.out.println("this is the newly added default method");
    }
}

// 实现类A
public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs(){
        System.out.println("abstract method execute");
    }

    public static void main(String[] args){
        MyInterfaceDefaultA defaultA = new MyInterfaceDefaultA();
        // 调用静态方法
        defaultA.methodAbs();  // abstract method execute

        // 调用默认方法，如果实现类中没有，就去找接口中的
        defaultA.methodDefault();  // this is the newly added default method
    }
}

// 实现类B
public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs(){
        System.out.println("abstract method execute");
    }

    // 覆盖重写的默认方法
    public void methodDefault(){
        System.out.println("cover to rewrite");
    }

    public static void main(String[] args){
        MyInterfaceDefaultB defaultB = new MyInterfaceDefaultB();
        defaultB.methodDefault();  // cover to rewrite
    }
}

默认方法扩展：解决两个默认方法之间重复代码的问题，需要抽取一个共有方法

public interface MyInterfaceDefault{
    // 默认方法1(public 可省略)
    public default void methodDefaultA(){
        System.out.println("this is default method A");
        methodCommon();
    }

    // 默认方法2
    public default void methodDefaultB(){
        System.out.println("this is default method B");
        methodCommon();
    }

    // 共有方法，这个共有方法也是可以被实现类进行调用的
    public default void methodCommon(){
        System.out.println("this is common default method");
    }
}

public class MyInterfaceDefaultImpl implements MyInterfaceDefault{
    public void methodAnother(){
        // 直接访问到接口中的共有方法，这样是不对的
        methodCommon();
    }
}

静态方法定义(从 java 8 开始，接口中允许定义静态方法)

hint：就是将 abstract 或 default 换成 static 即可，和默认方法一样，有方法体

Notice：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
```
public interface MyInterfaceStatic{
    // 定义静态方法
    public static void methodStatic(){
        System.out.println("this is the static method");
    }
}
```
方法私有化(从 java 9 开始，接口中允许定义私有方法)

上述的共有默认方法或共有静态方法是可以被实现类调用

但是共有方法不应该让实现类使用，应该是私有化的，只有接口自己才能调用

私有方法定义

有两种：普通私有方法和静态私有方法
1. 普通私有方法，解决多个默认方法之间的重复代码问题
```
// 共有默认方法，用 private 关键字修饰
private void methodCommon(){
    System.out.println("this is common default method");
}
```
2. 静态私有方法，解决多个静态方法之间的重复代码问题
```
// 共有静态方法，用 private 关键字修饰
private static void methodCommon(){
    System.out.println("this is common static method");
}
```
定义为私有方法之后，就不能够被实现类进行调用

常量定义

定义格式：public static final 数据类型常量名称 = 数据值;

Notice：

必须进行赋值，一旦赋值不能改变
命名规则：使用完全的大写字母，用下划线进行分隔

// 定义
public interface MyInterfaceConst{
    public static final int NUM_CLASS = 12;
    
    // 省略写法
    // int NUM_CLASS = 12;
}

// 调用
public class DemoConst{
    public static void main(String[] args){
        // MyInterfaceConst.NUM_CLASS = 20  // 错误写法
        System.out.println(MyInterfaceConst.NUM_CLASS);  // 12
    }
}

final 关键字

final 表示最终的，不可改变的

常见的四种用法：

修饰一个类

// final 类不能被当做父类
public final class FinalClass{
    public void method(){
    }
}

修饰一个方法

abstract 和 final 关键字不能重复使用(抽象方法必须要覆盖重写，但 final 关键字不能被覆盖重写)

public class Father{
    // 这个方法是最终方法，也就是不能被覆盖 重写
    public final void method(){
    }
}

修饰一个局部变量

对于基本类型：不可变说的是变量中数据不可改变

对于引用类型：说的是变量中的地址值不可改变

public class Person {
    String name;
    public Person(String name){
        this.name = name;
    }
}

public class DemoFinal {
    public static void main(String[] args) {
        // 使用 final 用来修饰局部变量，那么这个变量就不能被改变
        final int a = 10;
        System.out.println(a);  // 10
        // a = 20;  // 不能修改
        // 可以先定义，后赋值
        final byte b;
        b = 20;

        final Person son = new Person("johny");
        System.out.println(son);  // demo_08_final_local_variable.Person@1b6d3586
        System.out.println(son.name);  // johny
        // son = new Person("johny");  错误写法

        son.name = "anson";
        System.out.println(son);  // demo_08_final_local_variable.Person@1b6d3586
        System.out.println(son.name);  // anson
    }
}

修饰一个成员变量

和局部变量的使用方式是类似的，需要注意的是：

Notice：
1. 成员变量有默认值，所以使用 final 之后必须手动赋值，或者通过构造方法赋值，二选一

接口的注意事项
1. 接口是没有静态代码块和构造方法的
2. 一个类的直接父类是唯一的(单继承)，但是一个类可以同时实现多个接口
  
  public class MyinterfaceImpl implements MyInterfaceA, MyInterfaceB { ... }
  
  如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次
  
  如果没有实现接口中所有的抽象方法，那么实现类就必须是一个抽象类
  
  如果存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
  
  如果一个类的直接父类的方法，和接口中的默认方法产生冲突，优先使用父类当中的方法(继承优先于接口实现)
接口之间的多继承
1. 类与类之间是单继承的，直接父类只有一个
2. 类与接口之间是多实现的，一个类可以实现多个接口
3. 接口与接口之间是多继承的
  
  多个父接口当中的抽象方法如果重复，没有关系
  
  多个父接口当中的默认方法重复，在子接口中需要覆盖重写

summary：在这里插入图片描述

kaichenkai

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA_面向对象_接口

接口定义接口就是多个类的公共规范接口是一种引用数据类型，最重要的内容就是其中的抽象方法定义格式：public interface MyInterfaceAbstract { // 这是一个抽象方法(public abstract 可省略) public abstract void methodAbs();}如果是java 7，那么接口中可以包含：常量、抽象方法如...
复制链接

扫一扫