#1 面向对象编程

本节内容来自 大话设计模式 - 程杰 的笔记，将C#语言改用 TypeScript进行实现。

1.1 面向过程的实现

如果要实现一个简单的计算器的加减乘除功能，我们可能这样进行实现：

function calculate(operandA: number, operandB: number, operator: number) {
    let result = 0;
    switch (operator) {
        case '+':
            result = operandA + operandB;
            break;
        case '-':
            result = operandA - operandB;
            break;
        case '*':
            result = operandA * operandB;
            break;
        case '/':
            if (operandB === 0)
                throw new Error('right operand can not be 0');
            result = operandA - operandB;
            break;
    }
    return result;
}

1.2 面向对象编程

上面的写法虽然没什么问题，但是不够灵活，并且暴露给外界的信息太多，命令式的写法扩展性也不强。

就好比将这个东西都写在一个地方，如果需要修改，这整个地方都需要进行修改，如果将每一个部分进行拆分，这样，某个地方变动了，则只需要对相应的地方进行修改即可。并且各个小模块是可以 复用的。

如果我们需要加一个 sqrt 开平方根的方法，则上面的 加减乘除都会暴露在外面，这样可能会引入其它不可控的因素，比如不小心将上面加减乘除中的某些内容修改了。这样是对 扩展 是不太友好的。

将上面的代码使用面向对象的方式进行 封装：

// 定义一个抽象类
abstract class Operation {
    // 抽象类的属性
    private _operandA: number = 0;
    private _operandB: number = 0;
    
    get operandA(): number {
        return this._operandA;
    }
    set operandA(value) {
        this._operandA = value;
    }
    
    get operandB(): number {
        return this._operandB;
    }
    set operandB(value) {
        this._operandB = value;
    }
    
    // 抽象方法
    abstract getResult(): number;
}

加减乘除类：

class OperationAdd extends Operation {
    // 实现抽象类中的抽象方法
    getResult(): number {
        return this.operandA + this.operandB;
    }
}

class OperationSub extends Operation {
    // 实现抽象类中的抽象方法
    getResult(): number {
        return this.operandA - this.operandB;
    }
}

class OperationMul: Operation {
    // 实现抽象类中的抽象方法
    getResult(): number {
        return this.operandA * this.operandB;
    }
}

class OperationDiv: Operation {
    // 实现抽象类中的抽象方法
    getResult(): number {
        if (this.operandB === 0) {
            throw new Error('operandB can not be 0');
        }
        return this.operandA / this.operandB;
    }
}

这样就将每个功能进行了拆分，加减乘除类互不影响，修改某一个类不会影响到其他类的功能，这种就叫 封装和继承

1.3 简单工厂模式

上面的分离之后，我们需要知道 如何实例化对象的问题。到底要实例化谁，将来会不会增加实例化的对象，比如增加开根运算，这是很 容易变化 的地方，应该考虑用一个单独的类来做创造实例的工程， 这就是简单工程模式

class OperationFactory {
    static createOperate(operation: string): Operation {
        let oper: Operation = null;
        switch (operation) {
            case '+':
                oper = new OperationAdd();
                break;
            case '-':
                oper = new OperationSub();
                break;
            case '*':
                oper = new OperationMul();
                break;
            case '/':
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

使用工厂创建实例：

let oper: Operation = OperationFactory.createOperate('*');
oper.operandA = 10;
oper.operandB = 2;
oper.getResult(); // 20

通过这个示例介绍了面向对象编程的几大特性：

• 封装，继承

• 紧耦合和松耦合

• 简单工厂模式 创建实例

  • 面向对象编程 - stackblitz

2019年01月10日01:19:18