Java 面向对象

接口定义

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

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

定义格式:

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

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

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

public interface MyInterfaceStatic{

    // 定义静态方法

    public static void methodStatic(){

        System.out.println("this is the static method");

    }

}

方法私有化 (从 java 9 开始，接口中允许定义私有方法)

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

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

私有方法定义:

有两种：普通私有方法和静态私有方法

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

// 共有默认方法，用 private 关键字修饰

private void methodCommon(){

    System.out.println("this is common default method");

}

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

// 共有静态方法，用 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);  //

    }

}

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修改局部变量.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

    }

}

修饰一个成员变量

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

Notice：

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

接口的注意事项

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

接口之间的多继承

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

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

summary：

ending ~