TS基础2（类）-学习笔记-蒲公英云

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

男娘i 2022-10-19 11:29 233阅读 0赞

文章目录

- TS基础2（类）-学习笔记
- - class类
  - 类的继承
  - 修饰符
  - 类的类型、实现接口

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(){ }
    }