TS学习笔记--类

类

// 类可以理解为末班，通过模板实例化对象
// 面向对象的编程思想
(()=>{
    class Person{
        // 定义属性
        name:string
        age:number
        gender:string
        // 定义构造函数，为了将来实例化对象的时候，直接对属性的值进行初始化
        constructor(name:string='默认',age:number=0,gender:string='默认'){
            // 更新对象中的属性数据
            this.name = name
            this.age = age
            this.gender = gender
        }
        // 定义实例方法
        sayHi(str:string){
            console.log(`大家好我是${this.name}`,str);
        }
    }

    // ts中使用类,实例化对象，可以直接进行初始化操作
    const person = new Person('黄',11,'11') 
    person.sayHi('我也好')
})()

继承

// 继承类与类之间的关系
// 继承后类与类之间的叫法
// A继承B,A是B的子类，B类是基类
// 子类 ----> 派生类
// 基类 ----> 超类(父类)
// 一旦发生了继承的关系，就出现了父子类的叫法
(()=>{
    // 定义一个类
    class Person{
        // 定义属性
        name:string // 名字
        age:number
        gender:string
        // 定义构造函数
        constructor(name:string,age:number,gender:string){
            // 更新对象中的属性数据
            this.name = name
            this.age = age
            this.gender = gender
        }
        // 定义实例方法
        sayHi(str:string){
            console.log(`大家好我是${this.name}`,str);
        }
    }
    
    // 定义一个类继承Person
    class Student extends Person{
        constructor(name:string,age:number,gender:string){
            // 调用父类中的构造函数
            super(name,age,gender)
        }
 
        // 可以调用父类中的方法
        sayHi(){
            console.log('子类');
            super.sayHi('你在干嘛')
        }
    }
    const stu = new Student('黄',1,'1')
    stu.sayHi()
    
    // 类和类之间如果要有继承关系，需要使用extends 关键字
    // 子类中可以调用父类中的构造函数，使用的是super关键字(包括父类中的实例方法)
    // 子类可以重写父类的实例方法
})()

多态

// 多态：父类型的引用指向了子类型的对象，不同类型的对象针对相同方法，产生了不同的行为
(()=>{
    // 定义一个父类
    class Animal{
        // 定义一个属性
        name:string
        constructor(name:string){
            this.name = name
        }
        // 实例方法
        run(distance:number = 0){
            console.log(distance,this.name);
        }
    }

    // 定义一个子类
    class Dog extends Animal{
        constructor(name:string){
            super(name)
        }
        run(distance:number = 5){
            console.log(distance,this.name)
        }
    }

    // 定义一个字类
    class Pig extends Animal{
        constructor(name:string){
            super(name)
        }
        run(distance:number = 10){
            console.log(distance,this.name)
        }
    }

    const ani:Animal = new Animal('动物')
    ani.run()

    const ani1:Dog = new Dog('动物')
    ani1.run()

    const ani2:Pig = new Pig('猪')
    ani2.run()

    // 父类和子类的关系:父子关系，父类类型创建子类对象
 
    const dog1:Animal = new Dog('dog')
    dog1.run()

    const pig1:Animal = new Pig('pig')
    pig1.run()

    console.log('==============');
    
    // 该函数需要的参数是Animal类型的
    function showRun(ani:Animal){
        ani.run()
    }
    showRun(pig1)
    showRun(dog1)
})()

修饰符

// 修饰符(类中的成员的修饰符)：主要是描述类中的成员可访问性
// 类中的成员都有自己的默认的访问修饰符,public
// public 代表 类中成员默认的修饰符,代表的是公共的,任何位置都可以访问
// private 代表 类中成员 是私有的，子类也无法访问
// protected修饰符,外部无法访问，子类可以访问
(()=>{
    // 定义一个类
    class Person{
        // 属性
        // private name:string
        // public name:string
        protected name:string
        // 构造函数
        public constructor(name:string){
            this.name = name
        }
        // 方法
        public eat(){
            console.log('吃',this.name);
        }
    }

    class Students extends Person{
         constructor(name:string){
            super(name)
        }
        play(){
            console.log('111',this.name);
        }
    }

    // 实例化对象
    const per = new Person('黄') 
    // 类的外部可以访问类中的属性成员
    // console.log(per.name); 
    per.eat()
    const stu = new Students('红豆')
    stu.play()
    // console.log(stu.name); 


})() 

readonly

// readonly修饰符：首先是一个关键字，对类中的属性成员进行修饰，修饰符后，该属性成员不能在外部随意修改
// 构造函数可以对只读的属性成员的数据进行修改
// 如果构造函数中没有任何的参数，类中的属性成员此时已经使用readonly进行修饰，外部也不能对属性值进行修改
// 构造函数中的参数可以使用public private protected 修饰
(()=>{
    // 1、readonly 修饰类中的成员属性操作
    // 定义一个类型
    // class Person{
    //     // name: any;
    //     // 属性
    //     readonly name:string
    //     constructor(name:string){
    //         this.name = name
    //     }
    //     sayHi(){
    //         console.log('hi',this.name);
    //         // 类中的普通方法，也不能修改readonly
    //         // person.name = '梁'  
    //     }
    // }
    // // 实例化对象
    // const person:Person = new Person('黄')
    // // 此时无法修改 name属性为readonly
    // // person.name = '梁'  
    // console.log(person);
    // console.log(person.name);
    
    // 1、readonly 修饰类中的构造函数的的参数
    class Person{
        // 构造函数中的name参数,一旦使用readonly进行修饰该参数可以叫做参数属性
        // 构造函数中的name参数，一旦使用readonly进行修饰之后，Person中就有了一个name属性成员
        // 这种方式修饰，person.name = '梁' 外部无法修改
        // constructor(readonly name:string){
        //     this.name = name
        // }

        // 构造函数中的name参数，一旦使用public进行修饰,那么Person类中就有了一个name公共属性
        // constructor(public name:string){
        //     this.name = name
        // }

        // 构造函数中的name参数，一旦使用private进行修饰,那么Person类中就有了一个name私有属性
        // constructor(private name:string){
        //     this.name = name
        // }

        // 构造函数中的name参数，一旦使用protected进行修饰,那么Person类中就有了一个name受保护属性成员,只能读
        constructor(protected name:string){
        this.name = name
    }
       
    }
    // 实例化对象
    const person:Person = new Person('黄')
    // 此时无法修改 name属性为readonly
    // person.name = '梁'  
    console.log(person);
    // console.log(person.name);
    
})()

存取器

// 存取器：让我们有效的控制对 对象 中的成员进行访问,通过getter和setter来进行操作
(()=>{
    // 在外部可以传入姓氏和名字的数据，同时使用set和get控制姓名的数据，外部也可以修改
    class Person{
        firstname:string // 姓氏
        lastName:string // 名字
        
        constructor(firstName:string,lastName:string){
            this.firstname = firstName
            this.lastName = lastName
        }

        // 读取器
        get fullName(){
            return this.firstname+'_'+ this.lastName
        }

        // 设置器
        set fullName(val){
            let names = val.split('_')
            this.firstname = names[0]
            this.lastName = names[1]
        }
    }
    const person:Person = new Person('黄','梁')
    console.log(person);
    console.log(person.fullName);
    person.fullName = '在_这'
    console.log(person.fullName);

})()

静态成员

// 静态成员：在类中通过static修饰的属性或者方法，那么就是静态的属性及静态的方法，称之为静态成员
// 静态成员在使用的时候是通过类名.的这种语法来调用
(()=>{
    class Person{
        static name1:string = '梁'
        // 构造函数
        
        // static constructor(){
        //     // 此时this是实例dioxide，name1是静态属性,不能通过实例对象直接调用静态属性来使用
        //     // this.name1 = name
        // }
        
        constructor(){
            // 此时this是实例dioxide，name1是静态属性,不能通过实例对象直接调用静态属性来使用
            // this.name1 = name
        }
        // 静态方法
        static eat(){
            console.log('吃');
        }
    }

    // const person:Person = new Person() 
    // 通过实例对象调用属性
    // console.log(person.name1);
    // 通过实例对象调用方法
    // person.eat()
    // 通过类名.的这种语法来调用静态属性
    console.log(Person.name1);
    // 通过类名.的这种语法来设置静态属性
    Person.name1 = "赋值成功"
    console.log(Person.name1);
    // 通过类名.的这种语法来调用静态方法
    Person.eat()

})()

抽象类

// 抽象类:包含抽象方法(抽象方法一般没有任何的具体内容的实现),也包含实例方法,抽象类是不能被实例化,为了让子类进行实例化及实现内部的方法
// 抽象类的目的或者作用都是为子类服务
(()=>{
    // 定义一个类
    abstract class Animal {
        // abstract name:string = '小图'
        // 抽象方法
        abstract eat()
        // 抽象方法不能有具体实现
        // abstract eat(){
        //     console.log('趴着吃,挑着吃');
        // }

        // 实例方法
        run(){
            console.log('都跑了');
        } 
    }  
    
    // 定义一个子类(派生类)Dog
    class Dog extends Animal{
        name:string='小黄'
        // 重新的实现抽象
        eat(){
            console.log('子类挑着吃');
        }
    }
    // 不能实例化抽象类的对象
    // const ani:Animal = new Animal()

    const dog:Dog = new Dog()
    dog.eat()
    dog.run()
    console.log(dog.name);
    
})()