Java 面向对象_接口

接口定义

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

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

定义格式:

public interface MyInterfaceAbstract {
　　// 这是一个抽象方法(public abstract 可省略)
　　public abstract void methodAbs();
}

如果是java 7，那么接口中可以包含：常量、抽象方法

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

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

使用接口

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

2. 实现类必须覆盖重写接口中所有的抽象方法(去掉 abstract 关键字，加上方法体大括号); 如果实现类没有覆盖重写接口中所有的抽象方法，那么这个实现类必须是抽象类

3. 创建实现类对象，进行调用操作

// 实现类
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:

1. 接口当中的默认方法，可以解决接口升级的问题

2. 可以通过实现类对象，直接调用

3. 也可以在实现类中进行覆盖重写

// 接口
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 开始，接口中允许定义静态方法)

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

应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法  (用处不大)

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：

1. 必须进行赋值，一旦赋值不能改变

2. 命名规则：使用完全的大写字母，用下划线进行分隔

   // 定义
   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);  //
       }
   }

final 关键字

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

常见的四种用法：

1. 修饰一个类

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

2. 修饰一个方法

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

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

3. 修饰一个局部变量

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

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

   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修改局部变量.Person@1b6d3586
           System.out.println(son.name);  // johny
           // son = new Person("johny");  错误写法
   ​
           son.name = "anson";
           System.out.println(son);  // demo_08_final修改局部变量.Person@1b6d3586
           System.out.println(son.name);  // anson
       }
   }

4. 修饰一个 成员变量

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

   Notice：

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

接口的注意事项

1. 接口是没有静态代码块 和 构造方法的

2. 一个类的直接父类是唯一的(单继承)，但是一个类可以同时实现多个接口

   public class MyinterfaceImpl implements MyInterfaceA, MyInterfaceB { ... }

3. 如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次

4. 如果没有实现接口中所有的抽象方法，那么实现类就必须是一个抽象类

5. 如果存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写

6. 如果一个类的直接父类的方法，和接口中的默认方法产生冲突，优先使用父类当中的方法(继承优先于接口实现)

接口之间的多继承

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

• • 多个父接口当中的抽象方法如果重复，没有关系
  • 多个父接口当中的默认方法重复，在子接口中需要覆盖重写

summary：

ending ~