typescript interface 多继承

typeScript中的类

1.1 类的定义
1.2 继承
1.3 类里面的修饰符
1.4 静态属性 静态方法
1.5 抽象类 继承 多态

1. 类的定义

class Person{
    name:string;   //属性  前面省略了public关键词
    constructor(n:string){  //构造函数   实例化类的时候触发的方法
        this.name=n;
    }
    run():void{
        console.log(this.name);
    }
}
var p1=new Person('张三');
p1.run()

2. 继承 :extends 、super

class Person{
    name:string;   //属性  前面省略了public关键词
    constructor(n:string){  //构造函数   实例化类的时候触发的方法
        this.name=n;
    }
    run():void{
        console.log(this.name);
    }
}
class Man extends Person{
    constructor(name:string){
        super(name);  /*初始化父类的构造函数*/
    }
}

3. 类里面的修饰符

typescript里面定义属性的时候给我们提供了 三种修饰符
public :公有 在当前类里面、 子类 、类外面都可以访问
protected：保护类型 在当前类里面、子类里面可以访问 ，在类外部没法访问
private ：私有 在当前类里面可以访问，子类、类外部都没法访问

属性如果不加修饰符 默认就是 公有 （public）

//public :公有          在类里面、 子类  、类外面都可以访问
class Person{
    public name:string;  /*公有属性*/
    constructor(name:string){
        this.name=name;
    }
    run():string{
        return `${this.name}在运动`
    }
}
class Web extends Person{
    constructor(name:string){
        super(name);  /*初始化父类的构造函数*/
    }
    run():string{
        return `${this.name}在运动-子类`
    }
    work(){
        alert(`${this.name}在工作`)
    }
}

var p1=new Person('张三');
p1.run() // 正确：张三在运动
alert(p1.name) // 正确：张三
var p2=new Man('李四'); 
p2.run()  // 正确：李四在运动-子类
alert(p2.name) // 正确：李四

protected：保护类型

//protected：保护类型    在类里面、子类里面可以访问 ，在类外部没法访问
class Person{
    protected name:string;  /*公有属性*/
    constructor(name:string){
        this.name=name;
    }
    run():string{
        return `${this.name}在运动`
    }
}
class Man extends Person{
    constructor(name:string){
        super(name);  /*初始化父类的构造函数*/
    }
    run():string{
        return `${this.name}在运动-子类`
    }
    work(){
        alert(`${this.name}在工作`)
    }
}

var p1=new Person('张三');
p1.run() // 正确：张三在运动
alert(p1.name) // 错误，在类外部没法访问
var p2=new Man('李四'); 
p2.run()  // 正确：李四在运动-子类
alert(p2.name) // 错误，在类外部没法访问

private 私有属性

class Person{
    private name:string;  /*公有属性*/
    constructor(name:string){
        this.name=name;
    }
    run():string{
        return `${this.name}在运动`
    }
}
class Man extends Person{
    constructor(name:string){
        super(name);  /*初始化父类的构造函数*/
    }
    run():string{
        return `${this.name}在运动-子类`
    }
    work(){
        alert(`${this.name}在工作`)
    }
}

var p1=new Person('张三');
p1.run() // 正确：张三在运动
alert(p1.name) // 错误，私有属性外部无法访问
var p2=new Man('李四'); // 错误
p2.run()  // 错误，私有属性子类无法访问
alert(p2.name) // 错误，私有属性外部无法访问

4.静态属性 静态方法

class Man {
    public name:string;
    public age:number=18;
    static sex="男"; //静态属性
    constructor(name:string) {
            this.name=name;
    }
    run(){  /*实例方法*/
        console.log(`${this.name}在运动`)
    }
    work(){
        console.log(`${this.name}在工作`)
    }
    static print(){  /*静态方法  里面没法直接调用类里面的属性*/
        console.log('print方法'+ Man.sex);
    }
}

var p=new Man('张三');
p.run();  // 张三在运动
p.print(); // 错误，静态方法，外部无法调用
console.log(p.sex); // 错误，静态属性，外部无法调用

Man.print(); // 正确：print方法男
console.log(Man.sex); // 正确：男

5. 多态，抽象

//多态:父类定义一个方法不去实现，让继承它的子类去实现  每一个子类有不同的表现 
class Animal {

    name:string;
    constructor(name:string) {
        this.name=name;
    }
    eat(){   //具体吃什么  不知道   ，  具体吃什么?继承它的子类去实现 ，每一个子类的表现不一样
        console.log('吃的方法')
    }
}

class Dog extends Animal{
    constructor(name:string){
        super(name)
    }
    eat(){
        return this.name+'吃粮食'
    }
}

class Cat extends Animal{
    constructor(name:string){
        super(name)
    }
    eat(){
        return this.name+'吃老鼠'
    }
}

//typescript中的抽象类：它是提供其他类继承的基类，不能直接被实例化。
//用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
// abstract抽象方法只能放在抽象类里面
// 抽象类和抽象方法用来定义标准 。   标准：Animal 这个类要求它的子类必须包含eat方法


abstract class Animal{
    public name:string;
    constructor(name:string){
        this.name=name;
    }
    abstract eat():any;  //抽象方法不包含具体实现并且必须在派生类中实现。
    run(){
        console.log('其他方法可以不实现')
    }
}
var a = new Animal() /*错误的写法*/
 
class Dog extends Animal{
    //抽象类的子类必须实现抽象类里面的抽象方法
    constructor(name:any){
        super(name)
    }
    eat(){
        console.log(this.name+'吃粮食')
    }
}
var d = new Dog('小白狗');
d.eat();

总结

一、多态的概念：面向对象语言有三大主要特征：封装、继承、多态、封装是为了把我们需要隐藏的东西私有化，不让别人知道，把该暴露的暴露出去；继承提高了代码的复用性，我们可以直接拿父类中的属性，而且子父类的产生使类与类之间产生了关系，就有了多态的出现。顾名思义，多态就是事物的多种体现形态，学生军人农民都是人，我们既可以说他们是农民、军人又可以说他们是人，这就是多态。

二、多态的体现：多态必须是父类的引用指向子类的对象：Person p=new Student（）；当然这个前提是Student 这个类extends Person 这个类。多态的必要性：存在继承关系，子父类或者是实现关系（接口中）。然后就是发生重写，就是有重写存在。

三、多态的好处：大大提到了代码的可扩展性。