今天学习基础知识，抽象类和接口

今天学习基础知识，抽象类和接口，之前这块学的不太好没有太了解。

抽象类与接⼝

1. 抽象类

抽象类和抽象⽅法都使⽤ abstract 关键字进⾏声明。如果⼀个类中包含抽象⽅法，那么这个类必须声明

为抽象类。

抽象类和普通类最⼤的区别是，抽象类不能被实例化，只能被继承。

private InnerClass innerClass;

public AccessWithInnerClassExample() {

innerClass = new InnerClass();

}

public int getValue() {

return innerClass.x; // 直接访问

}

}

public abstract class AbstractClassExample {

protected int x;

private int y;

public abstract void func1();

public void func2() {

System.out.println("func2");

}

}

public class AbstractExtendClassExample extends AbstractClassExample {

@Override

public void func1() {

System.out.println("func1");

}

}

// AbstractClassExample ac1 = new AbstractClassExample(); //

'AbstractClassExample' is abstract; cannot be instantiated

AbstractClassExample ac2 = new AbstractExtendClassExample();

ac2.func1();

 

2. 接⼝

接⼝是抽象类的延伸，在 Java 8 之前，它可以看成是⼀个完全抽象的类，也就是说它不能有任何的⽅

法实现。

从 Java 8 开始，接⼝也可以拥有默认的⽅法实现，这是因为不⽀持默认⽅法的接⼝的维护成本太⾼

了。在 Java 8 之前，如果⼀个接⼝想要添加新的⽅法，那么要修改所有实现了该接⼝的类，让它们都

实现新增的⽅法。

接⼝的成员（字段 + ⽅法）默认都是 public 的，并且不允许定义为 private 或者 protected。从 Java 9

开始，允许将⽅法定义为 private，这样就能定义某些复⽤的代码⼜不会把⽅法暴露出去。

接⼝的字段默认都是 static 和 final 的。

 

public interface InterfaceExample {

void func1();

default void func2(){

System.out.println("func2");

}

int x = 123;

// int y; // Variable 'y' might not have been initialized

public int z = 0; // Modifier 'public' is redundant for interface

fields

// private int k = 0; // Modifier 'private' not allowed here

// protected int l = 0; // Modifier 'protected' not allowed here

// private void fun3(); // Modifier 'private' not allowed here

}

public class InterfaceImplementExample implements InterfaceExample {

@Override

public void func1() {

System.out.println("func1");

}

}

// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is

abstract; cannot be instantiated

InterfaceExample ie2 = new InterfaceImplementExample();

ie2.func1();

System.out.println(InterfaceExample.x);

3. ⽐较

从设计层⾯上看，抽象类提供了⼀种 IS-A 关系，需要满⾜⾥式替换原则，即⼦类对象必须能够替换

掉所有⽗类对象。⽽接⼝更像是⼀种 LIKE-A 关系，它只是提供⼀种⽅法实现契约，并不要求接⼝

和实现接⼝的类具有 IS-A 关系。

从使⽤上来看，⼀个类可以实现多个接⼝，但是不能继承多个抽象类。

接⼝的字段只能是 static 和 final 类型的，⽽抽象类的字段没有这种限制。

接⼝的成员只能是 public 的，⽽抽象类的成员可以有多种访问权限。

4. 使⽤选择

使⽤接⼝：

需要让不相关的类都实现⼀个⽅法，例如不相关的类都可以实现 Comparable 接⼝中的

compareTo() ⽅法；

需要使⽤多重继承。

使⽤抽象类：

需要在⼏个相关的类中共享代码。

需要能控制继承来的成员的访问权限，⽽不是都为 public。

需要继承⾮静态和⾮常量字段。

在很多情况下，接⼝优先于抽象类。因为接⼝没有抽象类严格的类层次结构要求，可以灵活地为⼀个类

添加⾏为。并且从 Java 8 开始，接⼝也可以有默认的⽅法实现，使得修改接⼝的成本也变的很低。

个人总结：看上十遍不如自己手写一遍，理解和记得清楚。