抽象方法：
- 在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。
- 而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
- 抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
抽象方法示例：
//没有方法体，有abstract关键字做修饰
public abstract void xxx();
抽象类的基本概念：
- 众所周知，父类是将子类所共同拥有的属性和方法进行抽取，这些属性和方法中，有的是已经明确实现了的，有的还无法确定，那么我们就可以将其定义成抽象，在后日子类进行重用，进行具体化。
- 所以，抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象方法。
- 简单说，拥有抽象方法的类就是抽象类（但抽象类中也可以不包含抽象方法），抽象类要使用abstract关键字声明。
抽象类示例：
//定义一个抽象类
abstract class A{
//普通方法
public void fun(){
System.out.println("存在方法体的方法");
}
//抽象方法，没有方法体，有abstract关键字做修饰
public abstract void print();
}
抽象类的特性和使用：
- 抽象类不能被实例化。因为抽象类中方法未具体化，这是一种不完整的类，所以直接实例化也就没有意义了。
- 抽象类的使用必须有子类，使用extends继承，一个子类只能继承一个抽象类。
- 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）。
- 抽象类可以不包含抽象方法，但如果类中包含抽象方法，就必须将该类声明为抽象类。
抽象类的基本使用示例：
//定义一个抽象类
abstract class A{
//普通方法
public void fun(){
System.out.println("存在方法体的方法");
}
//抽象方法，没有方法体，有abstract关键字做修饰
public abstract void print();
}
//单继承
//B类是抽象类的子类，是一个普通类
class B extends A{
//强制要求覆写
@Override
public void print() {
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String[] args) {
//向上转型
A a = new B();
//被子类所覆写的过的方法
a.print();
}
}
运行结果：
Hello World !
抽象类的使用限制：
- 抽象类可以有构造方法。
由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。
示例如下：
abstract class A{
public A(){
System.out.println("*****A类构造方法*****");
}
public abstract void print();
}
class B extends A{
public B(){
System.out.println("*****B类构造方法*****");
}
@Override
public void print() {
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String[] args) {
A a = new B();
}
}
执行结果：
*****A类构造方法*****
*****B类构造方法*****
抽象类不能使用final声明，因为抽象类必须有子类，而final定义的类不能有子类。
抽象类能否使用static声明吗？
外部抽象类不允许使用static声明，而内部的抽象类可以使用static声明。
使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。
内部抽象类使用示例：
abstract class A{
//static定义的内部类属于外部类
static abstract class B{
public abstract void print();
}
}
class C extends A.B{
public void print(){
System.out.println("**********");
}
}
public class TestDemo {
public static void main(String[] args) {
//向上转型
A.B ab = new C();
ab.print();
}
}
执行结果：
**********
- 抽象类中的static方法可以直接调用。
示例代码：
abstract class A{
public static void print(){
System.out.println("Hello World !");
}
}
public class TestDemo {
public static void main(String[] args) {
A.print();
}
}
执行结果：
Hello World !
- 有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。
示例如下：
abstract class A{
public abstract void print();
//内部抽象类子类
private static class B extends A{
//覆写抽象类的方法
public void print(){
System.out.println("Hello World !");
}
}
//这个方法不受实例化对象的控制
public static A getInstance(){
return new B();
}
}
public class TestDemo {
public static void main(String[] args) {
//此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
A a = A.getInstance();
a.print();
}
}
执行结果：
Hello World !
本文参考链接：Java抽象类 详解
