class Square {
    constructor(public length: number) { }
}
 
class Circle {
    constructor(public radius: number) { }
}
 
class AreaCalculator {
    constructor(protected shapes: (Square|Circle)[]) { }
 
    public sum() {
        return this.shapes.reduce((sum,shape: Square|Circle,index: number) => {
            if(shape instanceof Square) {
                return sum+=Math.pow(shape.length,2);
            }
            if(shape instanceof Circle) {
                return sum+=Math.PI*Math.pow(shape.radius,2);
            }
            return sum;
        },0)
 
    }
 
    public output() {
        console.log('Sum of the areas of provided shapes: '+this.sum())
    }
}
 
// 使用：
 
const shapes=[
    new Circle(2),
    new Square(5),
    new Square(6),
];
 
const areas=new AreaCalculator(shapes);
 
areas.output();
 
// 上面的实现的 AreaCalculator 并未遵循 单一职责原则。 （即实现了计算面积的方法，也实现了输出方法）
// 假如我们希望 output 方法能打印出结构化数据，而不止打印出字符串。
// 我们可以做如下改造：
// 把 output 抽象成一个 SumCalculatorOutputter 类
 
class SumCalculatorOutputter {
    constructor(protected calculator: AreaCalculator) { }
 
    public toJSON() {
        const data={sum: this.calculator.sum()};
        console.log(JSON.stringify(data));
    }
 
    public toString() {
        console.log('Sum of the areas of provided shapes: '+this.calculator.sum())
    }
}
 
// 使用：
 
const shapes = [
  new Circle(2),
  new Square(5),
  new Square(6),
];
 
const areas = new AreaCalculator(shapes);
const output = new SumCalculatorOutputter(areas);
 
output.toJSON();
output.toString();

class AreaCalculator {
    public constructor(protected shapes: (Square|Circle)[]) { }
 
    public sum() {
        return this.shapes.reduce((sum,shape: Square|Circle,index: number) => {
            if(shape instanceof Square) {
                return sum+=Math.pow(shape.length,2);
            }
            if(shape instanceof Circle) {
                return sum+=Math.PI*Math.pow(shape.radius,2);
            }
            return sum;
        },0)
 
    }
}
 
// 我们可以考虑把 sum 方法中的 caculator area 方法分散到每一个 shape 类中。
interface IShape{
    area():number;
}
 
class Square implements IShape{
    constructor(public length: number) { }
 
    public area() {
        return Math.pow(this->length, 2);
    }
}
 
class Circle implements IShape {
    constructor(public radius: number) { }
 
    public area() {
        return Math.PI*Math.pow(this.radius,2);
    }
}
 
class AreaCalculator {
    public constructor(protected shapes: IShape[]) { }
 
    public sum() {
      return this.shapes.reduce((sum,shape: IShape,index: number) => (sum+shape.area()),0)
    }
}
 
// 我们还可以添加 Rectangle 类
 
class Rectangle implements IShape {
    constructor(public width: number,public height: number) { }
 
    public area() {
        return this.width*this.height;
    }
}

class AreaCalculator2 extends AreaCalculator {
    constructor(shapes: IShape[]) {
        super(shapes);
    }
 
    public sum():any {
        return {sum: this.shapes.reduce((sum:number,shape: IShape,index: number) => (sum+shape.area()),0)};
    }
}
 
// 使用 AreaCalculator2 和 AreaCalculator
 
const shapes = [
  new Circle(2),
  new Square(5),
  new Square(6),
];
 
const areas = new AreaCalculator(shapes);
const areas2 = new AreaCalculator2(shapes);
 
const output = new SumCalculatorOutputter(areas);
const output2 = new SumCalculatorOutputter(areas2);
 
output.toString();
// expected output: "Sum of the areas of provided shapes: 73.56"
output2.toString();
// expected output: "Sum of the areas of provided shapes: [object Object]"
 
// AreaCalculator2 类违背了里氏替换原则，它改写了 sum 方法，返回了 map 数据结构的数据。
// 这对原有功能造成了影响。
// 合适的改写可以另起一个方法来实现新的功能或者保证返回的数据能遵循父类的定义。
 
class AreaCalculator2 extends AreaCalculator {
    constructor(shapes: IShape[]) {
        super(shapes);
    }
 
    public sumToMap() {
        return {sum: this.shapes.reduce((sum:number,shape: IShape,index: number) => (sum+shape.area()),0)};
    }
}

interface IShape{
    area():number;
    volume():number;
}
 
// 如果这样设计，在实现 Square 类的时候我们就必须实现 volume 方法，这是不合理的
// 故我们要将 volume 拆分出来，满足接口隔离原则。
 
interface IThreeDimensionalShape{
    volume():number;
}
 
interface IShape{
    area():number;
}
 
class Cube implements IShape,IThreeDimensionalShape {
    constructor(public length: number) { }
    public area() {
        return Math.pow(this.length,2)*6;
    }
 
    public volume() {
        return Math.pow(this.length,3)
    }
}

- 木头桌子
- 木头椅子
- 塑料桌子
- 塑料椅子

- 燃点
- 密度
- 价格
- 重量

interface Material{
	private density:number;
	private burning:number;
  public getDensity():number;
	public getBurningPoint():number;
}
 
class Wood implements Meterial{
	constructor(private density = 10,private burning = 10){}
  public getDensity(){
		return this.density;
	}
	public getBurningPoint(){
		return this.burning;
	}
}
 
class Plastic implements Meterial{
	constructor(private density = 20,private burning = 20){}
  public get Density(){
		return this.density;
	}
	public get BurningPoint(){
		return this.burning;
	}
}
 
interface Furniture{
	private volume:number;
	private price:number;
	private material: Material;
	public getWeight():number;
	public getBurningPoint():number;
}
 
class Desk implements Furniture{
	constructor(private material:Material, private volume = 10, private price: 20 ){}
	public getWeight(){
		return this.volume * this.material.Density;
	}
	public getBurningPoint(){
		return this.material.BurningPoint;
	}
}
 
class Chair implements Furniture{
	constructor(private material:Material, private volume = 10, private price: 20 ){}
	public getWeight(){
		return this.volume * this.material.Density;
	}
	public getBurningPoint(){
		return this.material.BurningPoint;
	}
}
 
// 我们通过注入 Material 抽象来达到设置不同家具拥有不同的材质。这儿就是一种依赖注入——构造函数注入（Constructor injection），在本文中，我们主要讨论构造函数依赖注入。
// 依赖注入还有 设定器注入(Setter injection) 和 接口注入(Interface injection)、参数注入 (Parameter injection) 等等。
 
 
// 上面的例子，其实也体现了 依赖倒置（Dependency inversion) 的思想，通过抽象出 Material Interface，注入到 Furniture 中，Furniture 无需关注 Material 的实现，只需要关注接口调用即可，
// Wood 和 Plastic 也无需关注如何被调用，只需要关注自身如何实现 Material 定义的接口即可。
// Furniture 和 Wood、Plastic 都依赖于 Material。这即实现了控制反转 （Inversion of control）或者说 依赖倒置（Dependency inversion）
// 在 Furniture 和 依赖类（Wood 和 Plastic）之间抽象出一层 Material Interface，使双方都依赖接口编程，这很好的剥离了各自的关注点。
 
// 可以再举个例子：
 
class Katana {
    hit() {
        return "cut!";
    }
}
 
class Shuriken {
    throw() {
        return "hit!";
    }
}
 
class Ninja {
    constructor(private weapon: Katana | shuriken ) { }
    fight() {
			if (this.weapon instanceof Katana){
				 return this.weapon.hit();
			}
			if(this.weapon instanceof Shuriken){
				return this.weapon.throw();
			}
		};
}
 
// 换个写法，先声明 Weapon interface
 
interface Weapon{
	attack():string;
}
 
 
class Katana implements Weapon {
    hit() {
        return "cut!";
    }
		attack(){
			return this.hit();
		}
}
 
class Shuriken implements Weapon {
    throw() {
        return "hit!";
    }
		attack(){
			return this.throw();
		}
}
 
class Ninja {
    constructor(private weapon: Weapon) { }
    fight() {
			return this.weapon.attack();
		};
}
 
// 现在，忍者需要一个新武器 Wand, 他无需念咒语，直接使用 attack 就可以 '除你武器'
 
class Wand implements Weapon{
		expelliarmus(){
			return 'Expelliarmus';
		}
 
		attack(){
			return this.expelliarmus();
		}
}

// Foo.ts
export class Foo {}

// Bar.ts
import {Foo} from "./Foo";
import {injectable} from "tsyringe";
 
@injectable()
export class Bar {
  constructor(public myFoo: Foo) {}
}

// main.ts
import "reflect-metadata";
import {container} from "tsyringe";
import {Bar} from "./Bar";
 
const myBar = container.resolve(Bar);
// myBar.myFoo => An instance of Foo

// SuperService.ts
export interface SuperService {
  // ...
}

// TestService.ts
import {SuperService} from "./SuperService";
export class TestService implements SuperService {
  //...
}

// Client.ts
import {injectable, inject} from "tsyringe";
 
@injectable()
export class Client {
  constructor(@inject("SuperService") private service: SuperService) {}
}

// main.ts
import "reflect-metadata";
import {Client} from "./Client";
import {TestService} from "./TestService";
import {container} from "tsyringe";
 
container.register("SuperService", {
  useClass: TestService
});
const client = container.resolve(Client);
// client's dependencies will have been resolved

import {singleton, inject} from "tsyringe";
 
@singleton()
class Foo {
  private str: string;
  constructor(@inject("SpecialString") value: string) {
    this.str = value;
  }
}
 
// some other file
import "reflect-metadata";
import {container} from "tsyringe";
import {Foo} from "./foo";
 
const str = "test";
container.register("SpecialString", {useValue: str});
 
const instance = container.resolve(Foo);