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

太过爱你忘了你带给我的痛 2022-05-18 02:08 121阅读 0赞

## 抽象类（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中抽象类与接口有何区别？什么时候选择抽象类而不是接口？

参考答案：第一问，

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

问题二，

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

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

--------------------