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

男娘i 2022-10-19 11:29 128阅读 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(){ }
        }