结构型设计模式（下）

// 抽象构件 Component
interface IPerson {
    getName(): string;
}
// 具体构件 ConcreteComponent，继承抽象构件
class Tim implements IPerson {
    private name: string;
    getName(): string {
        this.name = "Tim";
        return this.name;
    }
}
// 抽象装饰类 Decorator，继承抽象构件，并聚合抽象构件
class Cloths implements IPerson {
    protected person: IPerson;
    constructor(person: IPerson) {
        this.person = person;
    }
    getName(): string {
        return this.person.getName();
    }
}
class Trousers implements IPerson {
    protected person: IPerson;
    constructor(person: IPerson) {
        this.person = person;
    }
    getName(): string {
        return this.person.getName();
    }
}
// 具体装饰类 ConcreteDecorator，继承抽象装饰类
class Suit extends Cloths {
    private info: string;
    constructor(person: IPerson) {
        super(person);
    }
    getCloths(): string {
        this.info = this.person.getName() + "上衣: " + "suit...";
        return this.info;
    }
}
class Jack extends Cloths {
    private info: string;
    constructor(person: IPerson) {
        super(person);
    }
    getCloths(): string {
        this.info = this.person.getName() + "上衣: " + "jacket...";
        return this.info;
    }
}
class Pants extends Trousers {
    private info: string;
    constructor(person: IPerson) {
        super(person);
    }
    getTrousers(): string {
        this.info = this.person.getName() + "裤子: " + "pants...";
        return this.info;
    }
}
class Jean extends Trousers {
    private info: string;
    constructor(person: IPerson) {
        super(person);
    }
    getTrousers(): string {
        this.info = this.person.getName() + "裤子: " + "jean...";
        return this.info;
    }
}

let tim: IPerson = new Tim();
console.log("Get suit");
let suit: Suit = new Suit(tim);
console.log(suit.getCloths());  // Tim上衣: suit...
console.log("Get jean");
let jean: Jean = new Jean(tim);
console.log(jean.getTrousers());    // Tim裤子: jean...

// 子系统类
class Light {
    private name: string;
    constructor(name) {
        this.name = name;
    }
    open(): void {
        console.log(this.name + " opened!");
    }
}
class Heater {
    open(): void {
        console.log("Heater opened!");
    }
}

// 外观类，统一操作多个子系统
class Facade{
    private light1: Light;
    private light2: Light;
    private light3: Light;
    private heater: Heater;
    constructor() {
        this.light1 = new Light("light1");
        this.light2 = new Light("light2");
        this.light3 = new Light("light3");
        this.heater = new Heater();
    }
    open(): void {
        this.light1.open();
        this.light2.open();
        this.light3.open();
        this.heater.open();
    }
}

let facade: Facade = new Facade();
facade.open();  // light1 opened!
                // light2 opened!
                // light3 opened!
                // Heater opened!

// 抽象享元类 Flyweight，书本
interface Book {
    cell(): void;
}
// 具体享元类 ConcreteFlyweight，书名
class BookOrder implements Book {
    private name: string;
    constructor(name: string) {
        this.name = name;
    }
    cell(): void {
        console.log("Cell a book, named " + this.name);
    }
}
// 享元工厂类 FlyweightFactory
class BookFactory {
    // 享元池
    private bookPools: Map<string, Book> = new Map<string, Book>();
    // 和单例模式结合
    private constructor() {}
    private static factory: BookFactory = new BookFactory();
    static getInstance(): BookFactory {
        return this.factory;
    }
    getOrder(bookName: string): Book {
        let order: Book = null;
        // 如果存在该书，则从享元池中取出，否则新建一个书对象
        if (this.bookPools.has(bookName)) {
            order = this.bookPools.get(bookName);
        } else {
            order = new BookOrder(bookName);
            this.bookPools.set(bookName, order);
        }
        return order;
    }
    // 返回创建对象的数目
    getTotalObjs(): number {
        return this.bookPools.size;
    }
}



let orders: Book[] = new Array<Book>();
// 确保只有一个工厂对象
let factory: BookFactory = BookFactory.getInstance();

function takeOrders(bookName: string): void {
    orders.push(factory.getOrder(bookName));
}

takeOrders("三国演义");
takeOrders("水浒传");
takeOrders("封神榜");
takeOrders("三体");
takeOrders("红楼梦");
takeOrders("三国演义");
takeOrders("封神榜");
takeOrders("水浒传");

for (let i in orders) {
    orders[i].cell();
}

console.log("\n客户一共买了 " + orders.length + " 本书! "); // 客户一共买了 8 本书! 
console.log("共生成了 " + factory.getTotalObjs() + " 个 Book 对象! ");  // 共生成了 5 个 Book 对象! 

// 保护代理
//  抽象主题角色 Subject
interface Doc {
    read(): string;
}
// 真实主题角色 RealSubject
class SecretDoc implements Doc {
    private secret: string = "Secret doc!!!";
    private password: string = "123";
    read(): string {
        return this.secret;
    }
    getPsw(): string {
        return this.password;
    }
}
// 代理主题角色 Proxy
class ProtectionSecretDocProxy implements Doc{
    private doc: SecretDoc;
    private inputPsw: string;
    constructor(password: string) {
        this.inputPsw = password;
        this.doc = new SecretDoc();
    }
    // 判断密码是否正确
    checkPassword(): boolean {
        return this.doc.getPsw() === this.inputPsw;
    }
    read(): string {
        if (this.checkPassword()) {
            return this.doc.read();
        }
        return "Password is wrong!";
    }
}

let userProxy1: ProtectionSecretDocProxy = new ProtectionSecretDocProxy("123");
console.log("User1 get: " + userProxy1.read()); // User1 get: Secret doc!!!
let userProxy2: ProtectionSecretDocProxy = new ProtectionSecretDocProxy("234");
console.log("User2 get: " + userProxy2.read()); // User2 get: Password is wrong!