TS

TypeScript 类（一）

TypeScript 是面向对象的 JavaScript

类描述了所创建的对象共同的属性和方法。

TypeScript 支持面向对象的所有特性，比如 类、接口等

定义类的关键字为 class，后面紧跟类名，类可以包含以下几个模块（类的数据成员）：

1） 字段 − 类里面声明的变量。字段表示对象的有关数据。

2）构造函数 − 实例化时调用，可以为类的对象分配内存。

3）方法 − 对象要执行的操作。

4）创建实例化对象

class Person {
    //属性
    name: string;
    age: number;
    //?代表可选
    role?:string;

    //只读属性，不允许被修改
    readonly height: number;

    //构造函数（初始化属性）
    constructor(name: string, age: number, height: number,role?: string){
        this.name = name;
        this.age = age;
        this.role = role;
        this.height = height;
    }

    sayHello(){
        console.log(`${this.name}:hello`);  
    }
}

const p = new Person('admin',18,172);

p.height = 186; // 报错:因为 readonly(只读) height不能修改
console.log(p);

TypeScript 类（二）

1.static 关键字：

​ static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用

{
    class Person{
        static nickName: string;

        static sayHi(){
            console.log(Person.nickName,'hi');
            
        }
    }

    //静态属性的静态方法通过类名访问
    Person.nickName = 'John';
    Person.sayHi()
}

2.instanceof 运算符：

​ instanceof 运算符用于判断对象是否是指定的类型，如果是返回 true，否则返回 false

3. 访问控制修饰符

4. TypeScript 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。TypeScript 支持 3 种不同的访问权限 ：

​ 1）public（默认） : 公有，可以在任何地方被访问。（写或不写都是public）

​ 2）protected : 受保护，可以被其自身以及其子类和父类访问。

​ 3） private : 私有，只能被其定义所在的类访问

{
    class Person{
        //在本类和子类中访问
        protected name: string;
        //在本类中访问
        private age: number;

    constructor(name: string, age: number){
        this.name = name;
        this.age = age;
        }

        sayHello(){
            console.log("this.name,this.age");
        }
    }
    const p = new Person('admin',18);

}

TypeScript 类的继承

一. 1）TypeScript 支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。

2） 类继承使用关键字 extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。

3）TypeScript 一次只能继承一个类，不支持继承多个类，但 TypeScript 支持多重继承（A 继承 B，B 继承 C）。

二.继承类的方法重写

​ 类继承后，子类可以对父类的方法重新定义，这个过程称之为方法的重写。

​ 其中 super 关键字是对父类的直接引用，该关键字可以引用父类的属性和方法。

{
   //Animal
   class Animal{
       name: string;
       age: number;

       constructor(name: string, age: number){
           this.name = name;
           this.age = age;
       }
   }

   class Dog extends Animal{
       back(){
           console.log(`${this.name}:汪汪汪汪`);
           
       }
   }

   const dog = new Dog('哈士奇',4);
   dog.back();
}

TypeScript抽象类

1)什么时抽象类？

被abstract修饰的类，就是抽象类，抽象类又叫基类

2)为什么要有抽象类？

为了规定类中的一些属性和方法，在被继承的时候必须重写，所以被abstract修饰的方法和属性，在继承时必须重 写，分别叫做抽象类和抽象方法

3)抽象类的特点：

​ 抽象类自身无法实例化，必须由子类（派生类）进行实例化

​ 抽象类也可以拥有自己的抽象方法和属性

​ 抽象类中的抽象方法和抽象属性必须被重写

{
    //被abstract修饰的类叫做抽象类
    //抽象类不能实例化（创建对象）,只能作为基类（父类），派生类(子类)
    //只能被继承，继承的时候需要重写父类中的抽象属性和抽象方法
    //被abstract修饰的属性叫做抽象属性，不能直接赋值
    //被abstract修饰的方法叫做抽象方法，不能有方法体
    //抽象属性和属性方法不能有具体的实现

    //抽象类用来定义类的结果（属性，方法）
    abstract class Person {
        abstract name: string;
        abstract sayHi();
       
    }

    //继承抽象类
    class Student extends Person {
        name: string;

        constructor(name: string){
            super();
            this.name = name;
        }

        sayHi() {
            console.log('${this.name}:hi');
            
        }
    }
    const stu = new Student('chen');
}

TypeScript接口

一.1)接口定义使用interface关键字

2)接口的作用类似于抽象类，不同点在于接口中的所有方法和属性都是没有实值的，换句话说接口中的所有方法都是抽象方法。接口主要负 责定义一个类的结构，接口可以去限制一个对象的接口，对象只有包含接口中定义的所有属性和方法时才能匹配接口。同时，可以让一个 类去实现接口，实现接口时类中要保护接口中的所有属性

3)需要注意接口不能转换为 JavaScript。 它只是 TypeScript 的一部分。

{
    interface IPerson{
        // name: string = "", //报错：接口函数不能具有初始化表达式
        name: string;


        sayHi();
    }

    interface IA{
        age: number;
    }

    //实现接口
    class Student implements IPerson,IA{
        name: string;
        age: number;

        constructor(name: string,age: number) {
            this.name = name;
            this.age = age;
        }
        
        sayHi(){
            console.log(`${this.name}:hi`);
            
        }
    }

const stu = new Student('chen',24);

stu.sayHi();
}

二.实现接口

1)接口的实现使用implements关键字

2)同一个类可以实现多个接口

3)抽象类也可以实现接口

4)接口不能实现接口，但可以使用extends扩展

{
    interface IA{
        name: string;
    }

    //扩展
    interface IB extends IA{
        age: number;
    }

    class C implements IB{
        //重写
        name: string;
        age: number;

    }
}

泛型

1)在定义函数和类时，遇到类型不明确的时候就可以使用泛型

2)泛型可以指定多个

import { LanguageServiceMode } from "typescript";

{
    function test<T>(arg:T):T{
        return arg;
    }

    //外部指定类型
    test<string>('chen');

    test<number>(10);

    //多个泛型使用用逗号，隔开
    function test2<T,K>(a:T, b:K):K{
        return b;
    }

   //类的泛型
    class MyClass<T>{
        data:T;

        constructor(data:T){
            this.data = data;
        }
    }

interface MyInter{
    length: number;
}

const obj:MyInter ={length:10};

//T extends MyInter  可以是MyInter，也可以是实现了MyInter接口的子类
function foo<T extends MyInter>(a:T):T{
return a;
}
foo<MyInter>(obj);

const mc = new MyClass<number>(10);

}