TS基础2（类）-学习笔记

TS基础2（类）-学习笔记

class类

    //类  class
    //首字母大写
    //类(Class)：定义了一件事物的抽象特点，包含它的属性和方法
    class A {   //定义类，名称为A

    }
    //ES5 
    function Person(name,age){
        this.name = name;
        this.age = age;
    };
    Person.prototype.toString = function(){
        return this.name
    };
    var p = new Person('abc',20);
    p.name;
    p.toString()

    //ES6
    //一个类必须有constructor 
    //class A{}  === class A{constructor(){}}
    class Person2{
        name:string;   //提前定义值类型
        age:number;
        constructor(name,age){
            this.name = name;
            this.age = age;
        }
        toString(){
            return this.name
        }
    };
    var p2 = new Person2('abc',20);

类的继承

    //类的继承
    //动物类
    class Animal {
        name:string;
        constructor(name){
            this.name = name;
        }
        eat(){
            return '吃肉'
        }
    }
    //继承
    class Dog extends Animal {
        constructor(name){
            super(name);
            
        }
        say(){
            return this.name+' '+ this.eat()  //调用父类的属性和方法
        }
    }
    var d = new Dog('abc');  //实例化
    d.say();

    //static   静态方法   修饰符 不需要实例化 可以直接通过类来调用
    class Animal2 {
        static url: string = 'abc';
        static eat(){  //添加修饰符
            return '吃肉'
        }
        eat2(){  //添加修饰符
            return '吃肉'
        }
    };
    // var e1 = new Animal2();
    // e1.eat()   //error
    //Animal2.eat();  //不需要实例化
    Animal2.url
    //Animal2.eat2();

修饰符

    // 修饰符
    // public 修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是 public 的
    // private 修饰的属性或方法是私有的，不能在声明它的类的外部访问
    // protected 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的
    class A2 {
        name:string;
        public constructor(name){
            this.name = name;
        }
        //public static url: string = 'abc';
        public eat(){  //添加修饰符
            return '吃肉'
        }
        public eat2(){  //添加修饰符
            return '吃肉'
        }
    }
    //private 修饰的属性或方法是私有的，不能在声明它的类的外部访问
    class A3 {
        private eat(){  //无法访问
            return '吃肉'
        }
        public eat2(){  //添加修饰符
            return '吃肉123'
        }
    }
    var a3 = new A3();
    a3.eat()  //访问报错 但不影响正常编译
    a3.eat2()  //正常访问

    //protected 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的
    class A4 {
        protected eat(){  //无法访问 子类中也是允许被访问的
            return '吃肉'
        }
        private eat3(){  //无法访问 子类也不能访问
            return '吃肉'
        }
        public eat2(){  //添加修饰符
            return '吃肉'
        }
    }
    class D4 extends A4 {
        constructor(){
            super();
        }
        fun() {
            return this.eat()   //子类的内部是可以访问的
        }
        fun3() {
            return this.eat3()   //子类也不能访问
        }
    }
    var a4 = new A4();
    var d4 = new D4();

类的类型、实现接口

    //类的类型   
    class A6 {
        name:string;
        constructor(name:string){
            this.name = name;
        }
        eat():string {  //添加修饰符
            return '吃肉'
        }
        eat2(n:string):number{  //添加修饰符
            return 111
        }
    }

    //类实现接口
    //接口
    interface Obj {
        name:string;
        action():string;
    }
    //类实现接口 implements实现
    class A8 implements Obj {
        name:string;
        constructor(name){
            this.name = name;
        }
        action(){
            return '1111'
        }
        action2(){
            return 111
        }
    }

    //demo
    //定义门 公共类
    class Door{

    }
    //定义防火门  门的子类
    class sDoor extends Door implements Alarm{
        sing(){

        }
    }
    //报警功能  接口
    interface Alarm {
        sing();
    }
    interface Light{  //灯的接口
        lightOn();
        lightOff();
    }
    //车  类
    class Car implements Alarm,Light{
        sing(){}
        lightOn(){}
        lightOff(){}
    }