TypeScript学习笔记-06 类、构造器、继承、super

// 使用类来定义一个类
class Person {

    // readonly 开头的表示只读的属性，无法进行修改
    // 定义实例属性
    readonly name: string = '索隆';

    // 静态属性加上static关键字，使用类.静态属性，跟java有点类型
    static readonly age: number = 18;

    constructor() {

    }

    sayHello() {
        console.log('Hello 大家好');

    }

}

const person = new Person();

console.log(person.name, Person.age);

// 只读属性之后就没法修改了
// person.name = '路飞'

console.log(person.name);

person.sayHello();

/* 
    感觉就跟java的类有点类似，关键字static readonly,但是好像没有java里面的作用域
*/

类的构造器的学习

class Dog {
    name: string;
    age: number;

    bar() {
        // this当前对象
        alert(this.name + '哐哐哐')
    }

    // 构造函数
    // 构造函数 this当前对象就当前新建的对象
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

}

const dog1 = new Dog('旺财', 3);
const dog2 = new Dog('小黑', 2);
const dog3 = new Dog('小黄', 1);
const dog4 = new Dog('Rocket', 2);
console.log(dog1);
console.log(dog2);
console.log(dog3);
console.log(dog4);

dog1.bar();

dog2.bar();

继承，以及方法重写

(function () {

    // 定义一个Animal类

    class Animal {
        name: string;
        age: number;

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

        sayHello() {
            console.log('动物在叫');
        }
    }

    class Dog extends Animal {

        sayHello() {
            console.log('汪汪汪');
        }

        run() {
            console.log(this.name + '在跑');

        }
    }

    class Cat extends Animal {
        // 重写父类方法
        sayHello() {
            console.log('喵喵喵');
        }
    }

    const dog = new Dog('旺财', 3);
    console.log(dog);

    const cat = new Cat('喵喵', 1);
    console.log(cat);

    dog.sayHello();
    dog.run();
    cat.sayHello();


})();

有关super的代码，子类构造引入父类

(function () {
    class Animal {

        name: string

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

        sayHello() {
            console.log('动物在叫');

        }
    }

    class Dog extends Animal {

        age: number

        constructor(name: string, age: number) {
            // 子类中写了构造函数，那么父类的就不会进行执行，但是这样的会丢失属性
            // 我们必须对父类的构造函数进行调用,并且子类的参数也要写上与父类同样的属性
            super(name);
            this.age = age;
        }

        sayHello(): void {
            // super表示当前类的父类，所以这时候就是在调用父类的sayHello，和java中的类似
            // super.sayHello();
            console.log('汪汪汪');

        }
    }

    const dog = new Dog('旺财', 3);
    dog.sayHello();


})()

抽象类、抽象方法

(function () {
    // abstract抽象类，抽象类不能创建对象
    // 抽象类就是专门给别人继承的
    // 抽象类中可以添加抽象方法
    abstract class Animal {

        name: string

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

        // 父类抽象方法
        abstract sayHello(): void;
    }

    class Dog extends Animal {



        constructor(name: string) {
            // 子类中写了构造函数，那么父类的就不会进行执行，但是这样的会丢失属性
            // 我们必须对父类的构造函数进行调用,并且子类的参数也要写上与父类同样的属性
            super(name);

        }

        sayHello(): void {
            // super表示当前类的父类，所以这时候就是在调用父类的sayHello，和java中的类似
            // super.sayHello();
            console.log('汪汪汪');

        }
    }

    // 继承抽象类必须实现抽象方法
    class Cat extends Animal {


        sayHello(): void {
            console.log('喵喵喵');
        }

    }

    const dog = new Dog('旺财');
    dog.sayHello();

    const an = new Animal('蛇')

})()