一、对象和接口兼容

多的可以赋值给少的，少的不能赋值多的。
兼容时，会进行层层递归进行检查

interface Testinterface{
  name:string
}

let p = { name:'wds'} ;
let p1 = { age:23};
let p3 = { age:23,name:'www'};

let t:Testinterface;
t=p;
t=p1;//报错
t=p3;

//多层兼容
interface Testinterface{
    name:string,
    children:{
      age:number//层层递归进行检查
    }
  }
let p = { name:'wds' ,children:{ age:35}} ;
let p2 = { name:'wds' ,children:{ age:'eeee'}} ;
let t:Testinterface;
t=p;
t=p2;//报错

二、函数兼容性

1、参数兼容

参数少的可以兼容参数多的，参数多的不能兼容参数少的

let fn = (x:number,y:number)=>{}
let fn1 = (x:number)=>{}
fn = fn1;
fn1 = fn//报错

2、返回值类性兼容

不同类性不能兼容

• 返回值个数兼容的规则与参数类性兼容规则一致

let fn = (x:number):number=>123;
let fn1 = (x:number):number=>4567;
let fn2 = (x:number):string=>'234';
fn = fn1;
fn2 = fn1//报错

3、函数双向协变

（1）参数双向协变

确定类性和联合类性可以相互兼容。

let fn = (x:(number|string))=>{}
let fn1 = (x:(number))=>{}
fn = fn1
fn1 = fn

（2）返回值双向协变

确定类性的不能兼容联合类型的。

let fn = (x:(number)):(number|string)=>{ return x?123:'str'}
let fn1 = (x:(number)):number=>{return 123}
fn = fn1
fn1 = fn//报错

4、函数重载兼容

重载多的可以兼容重载少的，反之则不可以。

function add  (x:number,y:string):number
function add  (x:string,y:string):string
function add(x,y){
  return x+y
}

function sub  (x:string,y:string):string
function sub(x,y){
  return x+y
}

let fn = add;
let fn1 = sub

fn1 = fn
fn = fn1//报错

三、枚举兼容

• 数字枚举可以兼容数字
• 不同的枚举之间不能兼容
• 字符串枚举不能兼容字符串

enum Myenum{
  male,
  female, 
}
let q=Myenum.male;
q=2//不报错

enum Myenum2{
  male,
  female, 
}
enum Myenumone{
  dog,
  cat, 
}

let a = Myenum.male;
a = myenumone.dog//报错
enum Myenum3{
  male='str',
  female='female', 
}
let p = Myenum.male
p = '123234234'//报错

四、类的兼容性

• 参数多的可以兼容参数少的，判断依据仅判断实例的参数和方法，而静态方法和属性则不会影响类的兼容性，
• protected和private会影响类的兼容性

class Person{
  protected name:string
  // public age:number
}
class Son{
  protected name:string
}
let p : Person
let s : Son
p = s//报错
s = p//报错

五、泛型兼容

声明不影响兼容，只有使用才会影响兼容

interface setNubmer<T>{
    age:T
}
let t:setNubmer<number>;
let s:setNubmer<string>;
t = s;
s = t