1 抽象类

抽象方法：使用 abstract 修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。
抽象类：包含抽象方法的类就是抽象类。通过 abstract 方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

//抽象类
abstract class Animal {
	abstract public void shout();//抽象方法
}
class Dog extends Animal {
	//子类必须实现父类的抽象方法，否则编译错误
	public void shout() {
		System.out.println("汪汪汪！");
	}
	public void seeDoor(){
		System.out.println("看门中....");
	}
}
//测试抽象类
public class TestAbstractClass {
	public static void main(String[ ] args) {
		Dog a = new Dog();
		a.shout();
		a.seeDoor();
	}
}

要点

  • 抽象类必须在类前用abstract修饰。
  • 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例，只能用来被子类调用。
  • 抽象类中可以包含抽象方法，也可以不包含抽象方法。有抽象方法的类只能定义成抽象类。
  • 如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类。
  • 抽象类默认的权限修饰符为public，可以定义为public和protected，如果定义为private，则子类无法继承。
  • 抽象类只能用来被继承。

2 接口

接口：一系列方法的声明而没有方法的实现，接口中所有方法都是抽象方法。规范和具体实现的分离。
区别

  • 普通类：具体实现
  • 抽象类：具体实现，规范(抽象方法)
  • 接口：规范！

声明格式：
[访问修饰符] interface 接口名 [extends父接口 1，父接口 2…]{
常量定义；
方法定义；
}
定义接口的详细说明：

  • 访问修饰符：只能是 public 或默认。
  • 接口名：和类名采用相同命名机制。
  • extends：接口可以多继承。
  • 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
  • 方法：接口中的方法只能是：public abstract。 省略的话，也是 public abstract。
public class TestInterface {
	public static void main(String[ ] args) {
		Volant volant = new Angel();
		volant.fly();
		System.out.println(Volant.FLY_HIGHT);
		Honest honest = new GoodMan();
		honest.helpOther();
	}
}
/**飞行接口*/
interface Volant {
	int FLY_HIGHT = 100;// 总是：public static final 类型的；
	void fly();//总是：public abstract void fly();
}
/**善良接口*/
interface Honest {
	void helpOther();
}
/**Angel 类实现飞行接口和善良接口*/
class Angel implements Volant, Honest{
	public void fly() {
		System.out.println("我是天使，飞起来啦！");
	}
	public void helpOther() {
		System.out.println("扶老奶奶过马路！");
	}
}
class GoodMan implements Honest {
	public void helpOther() {
		System.out.println("扶老奶奶过马路！");
	}
}
class BirdMan implements Volant {
	public void fly() {
		System.out.println("我是鸟人，正在飞！");
	}
}

要点

  • 子类通过 implements 来实现接口中的规范。
  • 接口不能创建实例，但是可用于声明引用变量类型。
  • 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public 的。
  • JDK1.8（不含 8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
  • JDK1.8（含 8）后，接口中包含普通的静态方法、默认方法。
  • 使用interface修饰。
  • 一个类只能继承一个类，能实现多个接口。

接口中定义静态方法和默认方法(JDK8 以后)
默认方法
Java 8 及以上新版本，允许给接口添加一个非抽象的方法实现，只需要使用 default 关键字即可，这个特征又叫做默认方法（也称为扩展方法）。默认方法和抽象方法的区别是抽象方法必须要被实现，默认方法不是。作为替代方式，接口可以提供默认方法的实现，所有这个接口的实现类都会通过继承得到这个方法。

public class Test {
	public static void main(String[] args) {
		A a = new Test_A();
		a.moren();
	}
}
interface A {
	default void moren(){
		System.out.println("我是接口 A 中的默认方法！");
	}
}
class Test_A implements A {
	@Override
	public void moren() {
		System.out.println("Test_A.moren");
	}
}

结果为：Test_A.moren
静态方法
JAVA8 以后，我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口（接口也是类，一种特殊的类），可以通过接口名调用。**如果子类中定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于子类。**可以通过子类名直接调用。

public class Test {
	public static void main(String[] args) {
		A.staticMethod();
		Test_A.staticMethod();
	}
}
interface A {
	public static void staticMethod(){
		System.out.println("A.staticMethod");
	}
}
class Test_A implements A {
	public static void staticMethod(){
		System.out.println("Test_A.staticMethod");
	}
}

本接口的默认方法中可以调用静态方法。

public class Test {
	public static void main(String[] args) {
		A a = new Test_A();
		a.moren();
	}
}
interface A {
	public static void staticMethod(){
		System.out.println("A.staticMethod");
	}
	public default void moren(){
		staticMethod();
		System.out.println("A.moren");
	}
}
class Test_A implements A {
	public static void staticMethod(){
		System.out.println("Test_A.staticMethod");
	}
}

结果为：
A.staticMethod
A.moren