Java：抽象类和接口小记

对 Java 中的 抽象类和接口，做一个微不足道的小小小小记

抽象类：使用 abstract 修饰，子类用 extends 继承；

接口：使用 interface 修饰，采用 implements 实现；

构造函数：

抽象类中可以定义构造函数（但是抽象类不能被实例化）；
接口不能定义构造函数；

演示一下：

// 抽象类
public abstract class AbstractTest {
    // 正常
    public AbstractTest() {
        System.out.println("abstract class");
    }
}

/******************分割线*********************/

// 接口
public interface InterfaceTest {
    // error：Interface abstract method cannot have body
    public InterfaceTest(){}
}

成员变量：

抽象类中的成员权限可以是 public、默认、protected、private

注：抽象类中抽象方法就是为了重写，所以不能被 private 修饰；
而接口中的成员只可以是 public（方法默认：public abstract 、成员变量默认：public static final）；

演示一下

// 抽象类：
public abstract class AbstractTest {
    public AbstractTest() {
        System.out.println("abstract class");
    }

    public int a = 0;
    int b = 0;
    protected int c = 0;
    private int d = 0;
    // 成员变量是可以用private修饰的
    private String e = "hello";

    public void out(){
        System.out.println(d);
        System.out.println(e);
    }
}

public class Demo extends AbstractTest {

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.out();
    }
}

// 输出：
// abstract class
// 0
// hello

/******************分割线*********************/

// 接口：
public interface InterfaceTest {

    int a = 10;
    // error:Modifier 'protected' not allowed here
    protected int b = 10;
    // error:Modifier 'default' not allowed here
    default int c = 20;
    // info:Modifier 'public' is redundant for interface field
    public int d = 30;
    // public static final可以不加，是默认的
    public static final int e = 40;
}

成员方法：

抽象类中可以有抽象方法和具体方法，
而接口中只能有抽象方法（public abstract），但在 JDK1.8中，允许在接口中包含带有具体实现的方法，使用 default 修饰，这类方法就是默认方法。
抽象类中可以包含静态方法；
接口中不可以包含静态方法，同样在JDK1.8 以后可以包含，之前不能包含是因为，接口不可以实现方法，只可以定义方法，所以不能使用静态方法（因为静态方法必须实现）。现在可以包含了，只能直接用接口调用静态方法。
JDK1.8中，接口仍然不可以包含静态代码块。

演示一下：

// 抽象类
public abstract class AbstractTest {
    public AbstractTest() {
        System.out.println("abstract class");
    }

    public int a = 0;
    int b = 0;
    protected int c = 0;
    private int d = 0;
    // 成员变量是可以用private修饰的
    private String e = "hello";

    // 具体方法，在继承AbstractTest的类中可以直接调用
    public void method1(){
        System.out.println(d);
        System.out.println(e);
    }

    // 静态方法，可以通过 AbstractTest.method2()进行调用
    public static String f = "world";
    public static void method2(){
        System.out.println(f);
    }

    // 抽象方法，后续抽象方法必须是继承类中实现，否则继承类也是个抽象类
    public abstract void method3();
    abstract void method4();
    protected abstract void method5();
    // error: illegal combination of midifiers: 'abstract' and 'private'
    // private abstract void method6();
}

/******************分割线*********************/

// 接口
public interface InterfaceTest {

    int a = 10;
    // public static final可以不加，可以不加
    public static final int b = 20;

    // 抽象方法：public abstract可以不加，是默认，且只能用这个修饰
    public abstract void method1();

    // 默认方法：必须只能用default修饰
    default void method2(){
        System.out.println("默认方法");
    }

    // 静态方法: 通过InterfaceTest.method3()调用
    // 只能用public去修饰，可加可不加，其他的 protected/private/default都是不允许的
    public static void method3(){
        System.out.println("静态方法");
    }
}

public class Demo implements InterfaceTest {

    public static void main(String[] args) {
        Demo demo = new Demo();
        // 实现了抽象方法调用
        demo.method1();
        // 调用默认方法
        demo.method2();
        // 调用静态方法
        // demo.method3();        // 和抽象类不同，不能这样调用
        InterfaceTest.method3();  // 只能这样调用
    }

    @Override
    public void method1() {
        System.out.println();
    }
}

总结：

抽象类

接口

类修饰符

public/不加

构造方法

可以有

无

普通成员变量

可以有，类的普通成员变量相同

不能有，即使定义了也是被默认修饰了
public static final

普通成员方法