typescript关于 类

typescript创建一个类

class Person {
    // 类的属性，不能使用const/let/var实例
    name: string
    // 该类的构造方法
    constructor(name: string){
        this.name = name;
    }
    // 不带参数的方法
    run(): void{
        // 这里的name是对象本身构造函数的naem使用的时候需要this.name
        console.log(`${this.name} is running...`)
    }
    // 带参数的方法
    work(name: string): void{
        console.log(`${name} is working...`)
    }
}
// 实例化一个类
var p = new Person("Jack");
p.run();
p.work("wollens")

typescript中的构造方法：
构造方法中的属性和类中的属性的区别:

1. 构造函数中的属性可以是变化的，动态接收参数，且在实例化类的时候需要将构造函数的参数传入类中,
   且在类实例化时构造方法里的代码就会执行
2. 而类中的属性是一个变量，在实例化是不需要传参(当属性前面加类readonly：表示该属性只读不能被改变)
3. 补充：
   使用readonly关键字会将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。且值不能不能被修改，和const类似。
   最简单判断该用readonly还是const的方法是看要把它做为变量使用还是做为一个属性。 做为变量使用的话用 const，若做为属性则使用readonly

class test {
    // 类属性
    name: string = "jack"
    age: number = 16
    gender: string
    // readonly属性不能被修改
    readonly num: number = 12
    // 构造方法
    constructor(gender: string) {
        this.gender = gender
        console.log(`I'm a ${this.gender}`)
    }
    run(){
        console.log(`${this.name} is running...`)
    }
}
var t = new test("male")
console.log(t.name)
t.run()
t.name = "tom"
t.gender = "female"

关于typescript中类的继承

// 创建一个类
class Person {
    // 类的属性，不能使用const/let/var实例
    name: string
    // 该类的构造方法
    constructor(name: string){
        this.name = name;
    }
    // 不带参数的方法
    run(): void{
        // 这里的name是对象本身构造函数的naem使用的时候需要this.name
        console.log(`${this.name} is running...`)
    }
    // 带参数的方法
    work(name: string): void{
        console.log(`${name} is working...`)
    }
}

// 创建一个类继承Person类(typescript中的继承是用extends和super实现)
class goodPerson extends Person {
    // 当一个类去继承父类时需要重写父类的构造方法，且super继承父类的属性
    gender: string
    constructor(name: string, gender: string){
        super(name)
        this.gender = gender
        console.log(`hello I'm ${this.name} ${this.gender}`)
    }
    eat(food: string){
        console.log(`${this.name} is eatting ${food}`)
    }
    // 子类还可以重构父类的方法
    run(){
        console.log(`${this.name} is a ${this.gender}`)
    }
}

// 实例化这个类
var g = new goodPerson("Tom", "male");
g.eat("drunk");
g.run()

typescript中定义一个抽象方法

// ts中的抽象类方法：子类必须实现父类定义的抽象方法否则会报错
abstract class Animal {
    name: string = "pig";
    age: number = 12;
    abstract eat(): void;
    hello() {
        console.log("hello everyone")
    }
}

// 子类必须实现父类定义的抽象方法否则会报错
class Dog extends Animal {
    eat() {
        console.log("I'm hungrey")
    }
}
var d = new Dog()
d.eat()

typescript中属性的修饰符
TypeScript的访问修饰符有三个，分别是public、private、protected 。
TypeScript的默认访问修饰符是public。

• public声明的属性和方法在类的内部和外部均能访问到。
• protected声明的方法和属性只能在类的内部和其子类能访问。
• private声明的方法和属性只能在其类的内部访问。

class Persons {
    public name: string;
    protected gender: string;
    private age: number;
    constructor(name: string, gender: string, age: number){
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    run(): void{
        console.log(`${this.name} is running...`)
    }
    work(name: string): void{
        console.log(`${name} is working...`)
    }
}

var p = new Persons("Jack", "male", 16);
p.run();
console.log(p.name)
console.log(p.gender)  //外部不能访问(报错)
console.log(p.age)  // 外部不能访问(报错)
p.work("wollens")

关于typescript中的参数属性

• ts中的参数属性
• 在TypeScript中，参数属性可以方便地让我们在一个地方定义并初始化一个成员。
• 参数属性通过给构造函数参数添加一个访问限定符来声明。

class Man {
    constructor(public name: string, protected age: number, private gender: string) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    run() {
        console.log(`${this.name} is running...`);
    }
    eat() {
        console.log(`${this.name} is eatting...`);
    }
}

var m = new Man("alex", 16, "male")
console.log(m.name)
console.log(m.age)  // 私有属性不能被访问
console.log(m.gender)  // 私有属性不能被访问
m.run()
m.eat