Java 抽象类、抽象方法（abstract）

抽象方法：

• 在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。
• 而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字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抽象类 详解