Java面向对象编程（Object Oriented Programming，OOP）之抽象类（Abstract Class）与抽象方法（Abstract Method）

抽象类（Abstract Class）

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类的特点：

• 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
• 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
• 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

AbstractClass.java

abstract class Employee {
    private String name;
    private String address;
    private int number;

    public Employee(String name, String address, int number) {
        System.out.println("构建一个员工对象");
        this.name = name;
        this.address = address;
        this.number = number;
    }

    public double computePay() {
        System.out.println("员工中的方法");
        return 0.0;
    }

    public void mailCheck() {
        System.out.println("邮件发给" + name + "，地址是" +
                address + "，工号为" + number);
    }

    public String toString() {
        return name + " " + address + " " + number;
    }

    public void setName(String newName) {
        this.name = newName;
    }

    public void setAddress(String newAddress) {
        this.address = newAddress;
    }

    public void setNumber(int newNumber) {
        this.number = newNumber;
    }


    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }

    public int getNumber() {
        return number;
    }
}


class Salary extends Employee {
    private double salary;

    public Salary(String name, String address, int number, double salary) {
        super(name, address, number);
        setSalary(salary);
    }

    @Override
    public void mailCheck() {
        System.out.println("重写超类的邮件方法方法：");
        System.out.println("邮件发给" + getName() + "，地址是" +
                getAddress() + "，工号为" + getNumber() + "，工资为" + salary);
    }

    public void setSalary(double newSalary) {
        if (newSalary >= 0.0) {
            salary = newSalary;
        }
    }

    @Override
    public double computePay() {
        System.out.println("工资发给：" + getName());
        return salary / 52;
    }
}

public class AbstractDemo {
    public static void main(String[] agrs) {
        //错误，抽象类不行被实例化
        //Employee employee = new Employee("张三","北京",123456);

        Salary salary = new Salary("张三", "北京",
                123456, 10000);
        System.out.println("salary调用邮件方法：");
        salary.mailCheck();
        System.out.println("------------------------LINE-------------------");
        Employee employee = new Salary("李四", "上海",
                654321, 20000);
        System.out.println("employee调用邮件方法：");
        employee.mailCheck();
    }
}

结果：

构建一个员工对象
salary调用邮件方法：
重写超类的邮件方法方法：
邮件发给张三，地址是北京，工号为123456，工资为10000.0
------------------------LINE-------------------
构建一个员工对象
employee调用邮件方法：
重写超类的邮件方法方法：
邮件发给李四，地址是上海，工号为654321，工资为20000.0

Process finished with exit code 0

分析：抽象方与普通方法相似，但是抽象方法不能被实例化，实例化会报错。抽象方法可以被继承，通过派生类的来实例化，可间接实现。

抽象方法（Abstract Method）

如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

abstract关键字同样可以用来实现抽象方法，抽象方法包含一个方法名，没有具体的方法体。

抽象方法没有关键字，方法后面直接接上分号。

声明抽象方法会造成以下结果：

• 如果一个类包含抽象方法，那么这个类必须是抽象类。
• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

AbstractMethodDemo.java

abstract class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void abstractMethod();

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class AbstractMethodDemo extends Person {

    public AbstractMethodDemo(String name, int age) {
        super(name, age);
    }

    @Override
    public void abstractMethod() {
        System.out.println("子类必须实现抽象类中的抽象方法：");
        System.out.println("姓名是" + getName() + ",年龄为" + getAge());
    }

    public static void main(String[] args) {
        AbstractMethodDemo abstractMethodDemo = new AbstractMethodDemo("张三", 18);
        abstractMethodDemo.abstractMethod();
        System.out.println("------------------------LINE-------------------");
        Person person = new AbstractMethodDemo("李四", 25);
        person.abstractMethod();
    }
}

结果：

子类必须实现抽象类中的抽象方法：
姓名是张三,年龄为18
------------------------LINE-------------------
子类必须实现抽象类中的抽象方法：
姓名是李四,年龄为25

Process finished with exit code 0

抽象类拓展：

1. 抽象类中可以存在构造函数；

2. 抽象类也可以实现接口，由于其抽象性，不能被时间接口中的方法，可以被继承；

3. 抽象类不能是final，因为抽象类的实现需要被继承；

4. 抽象类可以具有能static方法，需严格遵守static规则，此种用法较少。

5. 抽象类只能被继承，不能实例化。

6. 抽象类中不一定要有抽象方法。

面试题

Java中抽象类与接口有何区别？什么时候选择抽象类而不是接口？

参考答案：第一问，

抽象类与接口对比

参数	抽象类	接口
默认方法实现	可以有默认方法实现	完全抽象，不存在方法实现
实现	由子类使用关键字extends继承，如果子类不继承，那么子类不是抽象类的话，它需要由提供抽象类中所有声明的方法实现	子类使用关键字implement实现接口，子类需要提供接口中所有声明方法实现
构造器	抽象类可以有构造器	借口没有构造器
与正常类的区别	除了不能实例化之外，没任何区别	与类不是同一类型
访问修饰符	public、protected、default	只能public
main()方法	可以有main()方法且可以执行	没有
多继承	抽象方法可以继承一个类和实现多个接口	只能实现一个或者实现多个接口
速度	较快	较慢，需要时间寻找类中的方法
添加新方法	抽象类中添加新方法，可以为之提供默认的实现，因此不需要修改你现在的代码	往接口中添加方法，那么你必须修改实现该接口的类

问题二，

• 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类。
• 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

值得注意的是：Oracle已经开始尝试向接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。

---