【设计模式】05-面向对象四大特性能解决什么问题

　　前文提到，理解面向对象编程和面向对象编程语言，关键是要理解四大特性（封装、抽象、继承、多态）。仅仅知道定义是不够的，我们要深刻理解它们的意义和目的，以及能解决什么问题。

　　本文结合代码来解析四大特性。有一点要注意，不同编程语言对于四大特性的语法机制不尽相同，但我们的分析不与特定编程语言挂钩，不要局限在语法的细节中。

一、封装（Encapsulation）

1. 什么是封装

　　封装也叫信息隐藏或数据访问保护。类隐藏具体的数据和实现细节，只暴露有限的访问接口。由此，可以限制外部，只能通过类提供的这些访问接口来访问类内部的数据和信息。

　　接下来，我们用一段 demo 为例来分析。在金融系统中，会给每个用户创建一个虚拟钱包，记录用户在系统中的虚拟货币量。对于虚拟钱包的业务背景，只需要简单了解即可。后续我们会利用 OOP 的设计思想来详细介绍虚拟钱包的设计实现。

public class Wallet {

    private String id;                      // 钱包编号
    private long createTime;                // 钱包创建时间
    private BigDecimal balance;             // 钱包余额
    private long balanceLastModifiedTime;   // 上次余额变更时间

    public Wallet() {
        this.id = IdGenerator.getInstance().generate();
        this.createTime = System.currentTimeMillis();
        this.balance = BigDecimal.ZERO;
        this.balanceLastModifiedTime = System.currentTimeMillis();
    }

    public String getId() {
        return this.id
    }

    public long getCreateTime() {
        return this.createTime;
    }

    public BigDecimal getBalance() {
        return this.balance;
    }

    public long getBalanceLastModifiedTime()
    {
        return this.balanceLastModifiedTime;
    }

    public void increaseBalance(BigDecimal increasedAmount) {
        if (increasedAmount.compareTo(BigDecimal.ZERO) < 0) {
            throw new InvalidAmountException("...");
        }
        
        this.balance.add(increaseBalance);
        this.balanceLastModifiedTime = System.currentTimeMillis();
    }
    
    public void decreaseBalance(BigDecimal decreasedAmount) {
        if (decreasedAmount.compareTo(ZERO) < 0) {
            throw new InvalidAmountException("...");
        }
        
        if (decreasedAmount.compareTo(this.balance) > 0) {
            throw new InsufficientAmountException("...");
        }
        
        this.balance.subtract(decreasedAmount);
        this.balanceLastModifiedTime = System.currentTimeMillis();
    }
}

　　从以上代码可以看到，Wallet 类有四个成员变量，我们使用封装特性，对这四个成员变量的访问进行限制。调用者只能通过以下六个方法来访问或修改钱包中的数据：

• • String getId()
  • long getCreateTime()
  • BigDecimal getBalance()
  • long getBalanceLastModifiedTime()
  • void increaseBalance(BigDecimal increasedAmount)
  • void decreaseBalance(BigDecimal decreasedAmount)

　　之所以这样设计，是因为 id、createTime 在对象创建时确定，不应再被改动，所以 Wallet 类不对外暴露它们的修改方法。此外，这两个属性的初始化设置，对于 Wallet 类的调用者来说应该是透明的。因此，在 Wallet 类的构造函数中将其初始化，而非通过构造函数的参数来外部赋值。

　　对于钱包余额 balance 属性，只能增减，不能重新设置。所以在 Wallet 类中只暴露 increaseBalance() 和 decreaseBalance() 方法，并没有暴露 set 方法。

　　对于 balanceLastModifiedTime 这个属性，应该和 balance 的修改操作绑定在一起。所以将这个属性的修改操作完全封装在 increaseBalance() 和 decreaseBalance() 方法中，不对外暴露。这样也可以保证 balance 和 balanceLastModifiedTime 两个数据的一致性。

　　对于封装特性，需要编程语言本身提供访问权限控制来支持。如果没有访问权限控制的功能，那么外部代码可以随意读写属性，无法达到隐藏信息、保护数据的目的，封装自然也就无从谈起了。

2. 封装的意义是什么？能解决什么问题？

　　如果对类中属性的访问不做限制，那么任意代码都可以访问、修改类中的属性。这样看起来虽然比较灵活，但过度灵活意味着不可控——属性可能被随意修改，而且修改逻辑散落在各处，势必影响代码可读性和可维护性。

　　此外，如果类仅仅通过有限的方法暴露必要操作，可以提高易用性。如果把所有细节暴露出来，调用者需要对类有详尽了解才能确保正确调用。这实际是一种负担。如果我们把细节封装起来，暴露几个方法给调用者使用，那就会比较容易使用，而且大大降低了出错的概率。

二、抽象（Abstraction）

1. 什么是抽象

　　抽象讲的是如何隐藏方法的具体实现，让调用者只需关注方法提供了哪些功能即可，不用关注实现细节。

　　在面向对象编程中，通常借助编程语言提供的接口类、抽象类这两种语法机制来实现抽象特性。PS：接口的概念比较宽泛，譬如还有 API 的含义。我们后续都用“接口类”来特指编程语言提供的接口语法。

　　我们还是用一个 demo 来理解抽象特性：

public interface IPictureStorage {
    void savePicture(Picture picture);
    Image getPicture(String pictureId);
    void deletePicture(String pictureId);
    void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo);
}

public class PictureStorage implements IPictureStorage {

    // ...省略其他属性...

    @Override
    public void savePicture(Picture picture) { ... }

    @Override
    public Image getPicture(String pictureId) { ... }

    @Override
    public void deletePicture(String pictureId) { ... }

    @Override
    public void modifyMetaInfo(String pictureId, PictureMetaInfo metaInfo) { ... }
}

　　以上代码利用 Java 的 interface 接口语法来实现抽象特性。调用者在使用图片存储功能时，只要知道 IPictureStorage 接口类暴露了哪些方法即可，不用去 PictureStorage 类里查看具体实现逻辑。

　　抽象特性其实是很容易实现的。即使不依赖接口类和抽象类这种特殊语法机制，单纯的 PictureStorage 类本身就满足抽象特性。因为类的方法包裹了具体的实现逻辑，这本身就是一种抽象。调用者在使用函数时，并不需要去研究函数内部的实现逻辑，只要通过函数的命名、注释和文档，了解其功能即可使用。

　　前文提到面向对象三大特性和四大特性的问题，为什么有时会把抽象排除在外？这是因为抽象是一个通用的设计思想，并非仅用在面向对象编程中，架构设计等方面也经常使用抽象。此外，抽象特性本身不需要编程语言提供特殊语法机制，支持函数即可实现。综上所述，抽象没有很强的特异性，所以有时不被看作面向对象编程的特性之一。

2. 抽象的意义是什么？它能解决什么问题？

　　抽象作为一种只关注功能，不关注实现的设计思路，帮我们过滤掉了很多不必要信息。

　　此外，抽象作为一种非常宽泛的设计思想，在代码设计中起到重要指导作用，很多设计原则都体现了抽象的思想。譬如基于接口而非实现编程、开闭原则（对扩展开放，对修改关闭）、代码解耦等。

　　我们在给类的方法命名时，也要有抽象思维，不要在方法定义中暴露太多细节，从而保证后续需要修改方法实现逻辑时，不用修改其定义。譬如将方法命名为 getAliyunPictureUrl()，那么后续不再使用阿里云时，这个命名也要随之修改。如果定义成 getPictureUrl() 这种比较抽象的函数，就避免了这个问题。

三、继承（Inheritance）

1. 什么是继承

　　继承用于表示类之间的 is-a 关系。譬如我们说人是一种哺乳动物。

　　从继承关系来区分，继承可以分为两种模式——单继承和多继承。单继承就是说，一个子类只继承一个父类。多继承则是说，一个子类可以继承多个父类。

　　为了实现继承特性，编程语言需要提供特殊的语法机制来支持。譬如，Java 使用 extends，C++ 使用 : 。区别在于，有些编程语言只支持单继承，譬如 Java、PHP。有些语言支持多继承，譬如 C++、Python。

2. 继承的意义是什么？它能解决哪些问题？

　　继承最大的好处是代码复用。如果两个类有相同的属性和方法，我们就可以将这些相同部分抽取到父类中，让两个子类继承父类。这样，两个子类就可以重用父类中的代码，避免代码重复写多遍。但这并非继承独有的，我们也可以用其他方式来解决代码复用问题，譬如组合。

　　过度使用继承，继承的层次过深过复杂，就会使得代码可读性、可维护性变差。为了了解一个类的功能，可能需要按照继承关系向上逐层查看直接父类和间接父类。此外，子类和父类高度耦合，修改父类的代码，也会影响到子类。

　　综上，继承特性比较有争议。有些观点认为，继承是一种反模式，我们应该少用甚至不用。后续会写篇关于“多用组合少用继承”设计思想的博客，再详细分析。

四、多态（Polymorphism）

1. 什么是多态

　　多态是指，定义时使用父类，实际运行时可以传入子类，从而可以调用子类的方法实现。譬如，定义时写的参数是汽车（父类），实际调用的时候传入的是 F1 赛车（子类），那就可以使用 F1 赛车的特性，譬如速度超快。

　　多态的特性用文字描述不易理解，还是老规矩，写个 demo：

public class DynamicArray {
    private static final int DEFAULT_CAPACITY = 10;
    protected int size = 0;
    protected int capacity = DEFAULT_CAPACITY;
    protected Integer[] elements = new Integer[DEFAULT_CAPACITY];

    public int size() {
        return this.size;
    }

    public Integer get(int index) {
        return elements[index];
    }

    //...省略n多方法...
  
    public void add(Integer e) {
        ensureCapacity();
        elements[size++] = e;
    }

    protected void ensureCapacity() {
        //...如果数组满了就扩容...代码省略...
    }
}

public class SortedDynamicArray extends DynamicArray {
    @Override
    public void add(Integer e) {
        ensureCapacity();
        
        int i;
        
        for (i = size-1; i>=0; --i) { //保证数组中的数据有序
            if (elements[i] > e) {
                elements[i+1] = elements[i];
            } else {
                break;
            }
        }
        
        elements[i+1] = e;
        ++size;
    }
}

public class Example {
    public static void test(DynamicArray dynamicArray) {
        dynamicArray.add(5);
        dynamicArray.add(1);
        dynamicArray.add(3);
        
        for (int i = 0; i < dynamicArray.size(); ++i) {
            System.out.println(dynamicArray.get(i));
        }
    }

    public static void main(String args[]) {
        DynamicArray dynamicArray = new SortedDynamicArray();
        test(dynamicArray); // 打印结果：1、3、5
    }
}

　　多态这种特性也需要编程语言提供一些语法支持。在上面的 demo 中，用到了三个语法机制来实现多态：

• • 编程语言要支持引用父类对象的变量可以引用子类对象。
  • 编程语言要支持继承。
  • 编程语言要支持子类可以重写父类方法。

　　对于多态特性的实现方式，除了“继承+重写”之外，还有两种实现方式比较常见。一是利用接口类语法，另一个是利用 duck-typing 语法。但是要注意，不是所有编程语言都支持接口类或 duck-typing。譬如 C++ 不支持接口类，而 duck-typing 只有一些动态语言才支持，譬如 Python。

　　接下来，我们再通过一个 demo 看看，如何利用接口类来实现多态特性。

public interface Iterator {
    boolean hasNext();
    String next();
    String remove();
}

public class Array implements Iterator {
    private String[] data;

    public boolean hasNext() {
        ...
    }

    public String next() {
        ...
    }

    public String remove() {
        ...
    }

    //...省略其他方法...
}

public class LinkedList implements Iterator {
    private LinkedListNode head;

    public boolean hasNext() {
        ...
    }

    public String next() {
        ...
    }

    public String remove() {
        ...
    }

    //...省略其他方法... 
}

public class Demo {
    private static void print(Iterator iterator) {
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
  
    public static void main(String[] args) {
        Iterator arrayIterator = new Array();
        print(arrayIterator);

        Iterator linkedListIterator = new LinkedList();
        print(linkedListIterator);
    }
}

　　在以上 demo 中，Iterator 是一个接口类，定义了一个可以遍历集合数据的迭代器。Array 和 LinkedList 都实现了接口类 Iterator。传递不同类型的实现类（Array、LinkedList）到 print(Iterator iterator) 函数中，即可动态地调用不同的 next()、hasNext() 实现。当我们往 print(Iterator iterator) 函数传递 Array 类型的对象的时候，print(Iterator iterator) 函数就会调用 Array 的 next()、hasNext() 的实现逻辑；当我们往 print(Iterator iterator) 函数传递 LinkedList 类型的对象的时候，print(Iterator iterator) 函数就会调用 LinkedList 的 next()、hasNext() 的实现逻辑。

　　接下来用 Python 写了一个 demo，用于说明如何用 duck-typing 来实现多态特性。

class Logger:
    def record(self):
        print(“I write a log into file.”)
        
class DB:
    def record(self):
        print(“I insert data into db. ”)
        
def test(recorder):
    recorder.record()

def demo():
    logger = Logger()
    db = DB()
    test(logger)
    test(db)

　　duck-typing 实现多态的方式非常灵活。Logger 和 DB 两个类没有任何关系，既不是继承关系，也不是接口和实现的关系。但只要它们都定义了 record() 方法，就可以被传递到 test() 方法中，在实际运行的时候，执行对应的 record() 方法。

　　所谓 duck-typing，即只要两个类具有相同方法，就可以实现多态，并不要求两个类之间有任何关系。这是一些动态语言所特有的语法机制。而像 Java 这样的静态语言，通过继承实现多态特性，必须要求两个类之间有继承关系，通过接口实现多态特性，类必须实现对应的接口。

2. 多态的意义是什么？它能解决什么问题？

　　多态特性能提高代码的可扩展性和复用性。咱们以上文的第二个 demo（Iterator）为例来分析。

　　在此例中，利用多态特性，仅用一个 print() 函数即可遍历打印不同类型（Array、LinkedList）集合的数据。当要添加一种需要遍历打印的类型，比如 HashMap 时，只要让 HashMap 实现 Iterator 接口，重新实现自己的 hasNext()、next() 等方法即可，完全不需要改动 print() 函数。所以说，多态能提高代码的可扩展性。

　　如果不使用多态特性，就不能将不同的集合类型（Array、LinkedList）传递给同一个函数（print(Iterator iterator) 函数）。这样就需要针对每种要遍历打印的集合，分别实现不同的 print() 函数。譬如 Array 要实现 print(Array array) 函数，LinkedList 要实现 print(LinkedList linkedList) 函数。而利用多态特性，我们只需要实现一个 print() 函数的打印逻辑，就能应对各种集合数据的打印操作，这显然提高了代码的复用性。

　　除此之外，多态也是很多设计模式、设计原则、编程技巧的代码实现基础。比如策略模式、基于接口而非实现编程、依赖倒置原则、里式替换原则、利用多态去掉冗长的 if-else 语句等。