// Dog.java
public class Dog {
    String color;
    int age;
}

// Cat.java
public class Cat {
    String color;
    int age;
}
// Main.java
public class Main {
    Dog myCat = new Cat();// cannot convert from Cat to Dog
    Cat myDog = new Dog();// cannot convert from Dog to Cat
    Cat myCat2 = new Cat();// 允许
    Dog myDog2 = new Dog();// 允许
}

此时使用控制变量对其二者进行实例化，可以看到，虽然Dog和Cat的属性相同，都有color以及age属性，但是不能互相声明类型及赋

“鸭子类型”

鸭子类型（duck typing）是一种动态类型机制的编程概念，它指的是一个对象的类型由它能干什么决定，而不是它属于什么类决定，它在运行时就会对对象的类型进行判断。鸭子类型的思想是：如果它看起来像鸭子，游起来像鸭子，叫起来像鸭子，那么它就是鸭子。

TS中的类型检查就是鸭子类型系统，如果两个对象类型拥有相同的属性或方法，那么它们就被认定为是相同类型

我们在TS中实现上面的效果

class Dog {
    color: string
    age: number
}
class Cat {
    color: string
    age: number
}

const dog: Cat = new Dog()// 允许
const cat: Dog = new Cat()// 允许

可以看到，TypeScript和JAVA的模式不同，只要结构相同就可以重复使用类型，这与其他语言不太一样。

子类型化

在学习数学的集合时，一个集合A是另一个集合B的子集，那么A可以被视为B的一个子类型；正方形可以视作矩形的一种子类，因为它继承了矩形的性质，同时又在矩形的基础上增加了一些附加的约束条件

定义

在计算机科学中，我们常说的类的继承是对父类的拓展，而子类型化（Subtyping）是父类型的拓展，它是指一种类型（子类型）是另一种类型（超类型）的一种特殊形式。与继承相同，它可以添加或覆盖超类型的属性和方法。它是较为抽象的拓展方式，没有拓展具体的值，而是拓展类型。超类型经过子类型化操作后的类型产物称为子类型。

特点

赋值兼容性

如果IDog是IAnimal的子类型，那么IDog类型的变量可以赋值给IAnimal类型的变量，举个例子说说

interface IAnimal {
    name: string
}
interface IDog extends IAnimal {
    color: string
}
const animal: IAnimal = {
    name: "阿黄"
}
const dog: IDog = Object.assign(animal, {
    color: "black"
})
const _animal: IAnimal = dog // 可以执行

其中IDog继承自IAnimal，如果使用变量将这两种类型实现，则可以将子类型的变量赋予给父类型的变量。

反身性

任何类型都是它自己的子类型。

interface IAnimal {
    name: string
}
const animal: IAnimal = {
    name: "阿黄"
}
const _animal: IAnimal = animal

传递性

如果IDog是IAnimal的子类型，IWhiteDog是IDog的子类型，那么IWhiteDog也是IAnimal的子类型

interface IAnimal {
    name: string
}
interface IDog extends IAnimal {
    color: string
}
interface IWhiteDog extends IDog {
    isWhite: boolean
}
const animal: IAnimal = {
    name: "阿黄"
}
const dog: IDog = Object.assign(animal, {
    color: "black"
})
const whiteDog: IWhiteDog = Object.assign(dog, {
    isWhite: true
})
const _animal: IAnimal = whiteDog // 可以执行

除了上述几点外，子类型还有变量协变性及函数参数逆变性的特点，我们在下文中展开讲讲

协变

如果理解了上面的鸭子类型和子类型化的概念，协变（Covariance）就不难理解。它是一种类型的转换，就像子类型化中的例子，如果类型IDog是类型IAnimal的子类型，那么dog可以赋值给animal，这个过程就是协变，即协变多变少（子类型赋值给父类型）

为了更好理解上面的例子以及后续的案例，我们写一个工具类型IsExtends，用于判断两个类型之间是否是类型的继承关系

type IsExtends<Son, Parent> = Son extends Parent ? true : false;
type animalExtendsDog = IsExtends<IAnimal, IDog>// false
type dogExtendsAnimal = IsExtends<IDog, IAnimal>// true

逆变

逆变（Contravariance）与协变相反，如果将父类赋值给子类成立，则称为逆变。我们将上述的例子修改一下变成以下代码，就是逆变的过程，即逆变少变多（父类型赋值给子类型）

const _dog: IDog = animal // 无法执行，类型 "IAnimal" 中缺少属性 "color"，但类型 "IDog" 中需要该属性。

然而，一般情况下上面这段代码是会抛错的，提示缺少属性，此时我们可以借助类型断言进行转换

const _dog: IDog = animal as IDog // 可以执行

但是这么写不太安全，如果animal中缺少IDog的属性可能会抛错

除此之外，函数的参数具有逆变性（不进行类型检查就具有双变特征），我们可以借助TS的函数进行转变，首先我们写个工具类型ToFun，将类型作为参数传入函数中

type ToFun<P> = (params: P) => void

然后我们将之前两个类型IAnimal和IDog传入函数中就会发现结果与前文截然相反

type IsExtends<Son, Parent> = Son extends Parent ? true : false;
type ToFun<P> = (params: P) => void

type animalExtendsDogFn = IsExtends<ToFun<IAnimal>, ToFun<IDog>>// true
type dogExtendsAnimalFn = IsExtends<ToFun<IDog>, ToFun<IAnimal>>// false

tips：如果两个都是true，可以将tsconfig中的strictFunctionTypes或strict打开，此时会检测函数参数的变体

此时，我们可以将变量转换为函数的形式，达到逆变的效果

const animalFn: (animal: IAnimal) => void = (animal) => { }
const _dog: ToFun<IDog> = animalFn // 可以执行

双变

双变（Bivariance）在许多地方被称为是双向协变，个人认为不太准确，双变是指类型同时具有协变和逆变的性质，称为协变与逆变可能比较合适。我们将tsconfig中的strictFunctionTypes与strict关闭，上面的例子就会显示两个true

type IsExtends<Son, Parent> = Son extends Parent ? true : false;
type ToFun<P> = (params: P) => void
type animalExtendsDogFn = IsExtends<ToFun<IAnimal>, ToFun<IDog>>// true
type dogExtendsAnimalFn = IsExtends<ToFun<IDog>, ToFun<IAnimal>>// true

我们使用变量试试

const animalFn: (animal: IAnimal) => void = (animal) => { }
const dogFn: (dog: IDog) => void = (dog) => { }
const _dog: ToFun<IDog> = animalFn // 可以执行
const _animal: ToFun<IAnimal> = dogFn // 可以执行

不变

不变（Invariance）的概念就比较简单了，两种类型既不会发生协变，也不会逆变，完全没有关系的两种类型

interface IAnimal {
    name: string
}
interface IDog {
    color: string
}

let animal: IAnimal = {
    name: "阿黄"
}
let dog: IDog = {
    color: "black"
}

dog = animal// 不能执行，缺少对应属性
animal = dog// 不能执行，缺少对应属性

思考

看个例子

思考这个的例子，如果使用上面讲到的协变与逆变的概念应该不难理解。变量（返回值）协变，参数逆变

我们把原文的例子使用TS实现一下

首先新建三个类型，分别是IAnimal，IDog，IWhiteDog，从动物到白狗层层继承

interface IAnimal {
    name: string
}
interface IDog extends IAnimal {
    type: string
}
interface IWhiteDog extends IDog {
    isWhite: boolean
}

接着我们使用工具类型实现一个函数创建，以及之前判断继承的工具

type Fun<P, R> = (params: P) => R// 创建以P为参数，R为返回值的函数
type IsExtends<Son, Parent> = Son extends Parent ? true : false;// 是否是继承关系

最后使用上述两种工具对类型进行检测：除了自身外，当函数的参数是IAnimal，返回值是IWhiteDog类型时，此函数是IDogFn的子类型

type IDogFn = Fun<IDog, IDog> // IDog, IDog

type IAnimalWhiteDogFn = Fun<IAnimal, IWhiteDog>// IAnimal, IWhiteDog
type IAnimalFn = Fun<IAnimal, IAnimal>// IAnimal, IAnimal
type IWhiteDogFn = Fun<IWhiteDog, IWhiteDog>// IWhiteDog, IWhiteDog
type IWhiteDogAnimalFn = Fun<IWhiteDog, IAnimal>// IWhiteDog, IAnimal

type IsExtendsAnimalWhiteDog = IsExtends<IAnimalWhiteDogFn, IDogFn>// true
type IsExtendsAnimal = IsExtends<IAnimalFn, IDogFn>// false
type IsExtendsWhiteDog = IsExtends<IWhiteDogFn, IDogFn>// false
type IsExtendsWhiteDogAnimal = IsExtends<IWhiteDogAnimalFn, IDogFn>// false

函数返回值和变量一样是协变的，所以子类遵循常规的继承取IWhiteDog；参数是逆变的，因此与正常的继承行为相反，取IAnimal

原因是什么？

返回值

返回值是协变的这点不难理解，函数执行时结果是RHS（Right Hand Side）右操作数，即函数返回值同样是赋值给变量的，我们还是使用上文赋值兼容性的例子做一点修改，在外层加个函数

interface IAnimal {
    name: string
}
interface IDog extends IAnimal {
    color: string
}
const animal = () => ({
    name: "阿黄"
})
const dog = () => Object.assign(animal, {
    color: "black"
})
const _animal: typeof animal = dog // 可以执行

参数

传入的参数访问子类型中的属性是不安全的。我们针对参数的子类型举个例子，首先我们增加一个IBlackDog类型，并将IDogFn以及其他的变量实现

interface IAnimal {
    name: string
}
interface IDog extends IAnimal {
    type: string
}
interface IWhiteDog extends IDog {
    isWhite: boolean
}
interface IBlackDog extends IDog {
    isBlack: boolean
}

type Fun<P, R> = (params: P) => R// 函数
type IDogFn = Fun<IDog, IDog> // dog函数
const animal: IAnimal = {
    name: "阿黄"
}
const dog: IDog = Object.assign(animal, {
    type: "dog"
})
const whiteDog: IWhiteDog = Object.assign(dog, {
    isWhite: true
})
const blackDog: IBlackDog = Object.assign(dog, {
    isBlack: true
})

接着创建一个函数参数接收一个函数，这个函数结构是Fun<IDog, IDog>。此时由下面的代码可以推导出，为何协变的参数是不安全的，可能有点绕

const example = (_fn: IDogFn): void => {
    _fn(blackDog)// _fn参数限制了IDog类型，所以实参可以传递blackDog，whiteDog，dog。这里我们传入blackDog
}
example(whiteDogFn)// 抛错，参数“_whiteDog”和“params” 的类型不兼容。

const whiteDogFn = (_whiteDog: IWhiteDog) => {
    _whiteDog.isWhite = false// 形参取IWhiteDog，但是实参传了blackDog，此时就会抛错，找不到isWhite，因为blackDog只有isBlack。所以使用形参使用IWhiteDog是不安全的，必须传递IDog类型，或者IAnimal，因为IAnimal有的属性，IDog都有
    return dog
}
const animalFn = (_animal: IAnimal) => {
    return dog
}
example(animalFn)// 允许执行

针对上面的代码做个解释：

我们定义了一个函数whiteDogFn，接收一个参数IWhiteDog，此时我们可以直接调用IWhiteDog中的属性isWhite，到这里都还算正常。但是接下来我们将这个函数代入到example函数中，为什么会抛错？因为IDogFn类型限制我们传入blackDog，whiteDog，dog这三种类型，如果此时我们传入blackDog则会有问题，因为blackDog没有isWhite这个属性。怎么做才能解决这个问题呢？从源头上控制函数的参数类型，即使用逆变的方式限制whiteDogFn函数的参数，限制为IAnimal，此时IAnimal只提供name这个属性，我们只能调用这个属性，并且这个属性是IAnimal，IDog，IWhiteDog，IBlackDog这四个类型都有的，此时使用该函数程序就是安全的