• TypeScript的类和对象

    一、TypeScript 类

            TypeScript 是面向对象的 JavaScript。类描述了所创建的对象共同的属性和方法。TypeScript 支持面向对象的所有特性

          1.1、类的定义

    1. class class_name { 
    2.     // 类作用域
    3. }

    类可以包含以下几个模块（类的数据成员）：

    • 字段(属性) − 字段是类里面声明的变量。字段表示对象的有关数据。
    • 构造函数 − 类实例化时调用，可以为类的对象分配内存。
    • 方法 − 方法为对象要执行的操作。

         例如：

    1. class Car { 
    2.     // 字段 
    3.     engine:string; 
    4.     // 构造函数 
    5.     constructor(engine:string) {
    6.          this.engine = engine 
    7.     } 
    8.     // 方法 
    9.     disp():void { 
    10.         console.log("发动机为 : "+this.engine) 
    11.     }     
    12. }

    this 关键字表示当前类实例化的对象。注意构造函数的参数名与字段名相同，this.engine 表示类的字段。

          1.2、创建实例化对象：使用 new 关键字来实例化类的对象，语法格式如下：

                     var object_name = new class_name([ arguments ])

            类实例化时会调用构造函数，例如：

                    var obj = new Car("Engine 1")

            类中的字段属性和方法可以使用 . 号来访问：

                    // 访问属性

                            obj.field_name

                    // 访问方法

                            obj.function_name()

          示例：

    1. // 创建一个对象
    2.  var obj = new Car("XXSY1"); 
    3. // 访问字段 
    4. console.log("读取发动机型号 : " + obj.engine); 
    5. // 访问方法 
    6. obj.disp();

    二、类的继承

            TypeScript 支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。

            类继承使用关键字 extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。

            TypeScript 一次只能继承一个类，不支持继承多个类，但 TypeScript 支持多重继承（A 继承 B，B 继承 C）。

            实例：

    1. class Shape { 
    2.     Area:number 
    3.     constructor(a:number) { 
    4.         this.Area = a 
    5.     } 
    6. }
    7.  
    8. class Circle extends Shape { 
    9.     disp():void { 
    10.     console.log("圆的面积: "+this.Area) 
    11.     } 
    12. } 
    13.  
    14. var obj = new Circle(223); 
    15. obj.disp()

            2.1、继承类的方法重写(overwrite)：又称为方法覆盖。类继承后，子类可以对父类的方法重新定义，这个过程称之为方法的重写。使用 super 关键字可以引用父类的属性和方法。

             例如：

    1. class PrinterClass { 
    2.     doPrint():void { 
    3.         console.log("父类的 doPrint() 方法。") 
    4.     } 
    5. } 
    6.  
    7. class StringPrinter extends PrinterClass { 
    8.     doPrint():void { 
    9.         super.doPrint() // 调用父类的函数
    10.         console.log("子类的 doPrint()方法。") 
    11.     } 
    12. }

    三、static 关键字：用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。

          例如：

    1. class StaticMem { 
    2.     static num:number; 
    3.     static disp():void { 
    4.         console.log("num 值为 "+ StaticMem.num) 
    5.     } 
    6. } 
    7. StaticMem.num = 12 // 初始化静态变量 
    8. StaticMem.disp() // 调用静态方法

    四、instanceof 运算符：用于判断对象是否是指定的类型，如果是返回 true，否则返回 false。

    1. class Person{ }
    2.  
    3. var obj = new Person()
    4. var isPerson = obj instanceof Person; 
    5. console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);

    五、类属性权限修饰符：TypeScript 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。TypeScript 支持 3 种不同的访问权限。

    • public（默认） : 派生类、类的实例对象都可以访问。
    1. class Person{
    2.     public name:string;
    3.     public age:number;
    4.     constructor(name:strng,age:number){
    5.         this.name=name;
    6.         this.age=age;
    7.     }
    8.     cons(text:string){
    9.       console.log(`Hi! ${this.name},${text}`);
    10.     }
    11. }
    • protected (保护属性): 派生类可以访问、类的实例对象不可以访问。
    1. class Person{
    2.     protected name:string;
    3.     public age:number;
    4.     constructor(name:strng,age:number){
    5.         this.name=name;
    6.         this.age=age;
    7.     }
    8. }
    9. class Man extends Person{
    10.     sex:string;
    11.     constructor(name:strng,age:number,sex:string;){
    12.         super(name,age)
    13.         this.sex=sex
    14.     }
    15.     cons(text:string){
    16.          console.log(`Hi! ${this.name},${text}`);
    17.     }
    18. }
    19. new Man("Cat"，12).name; // 错误,name是保护属性
    • private (私有属性): 派生类、类的实例对象不可以访问。
    1. class Person{
    2.     private name:string;
    3.     public age:number;
    4.     constructor(name:strng,age:number){
    5.         this.name=name;
    6.         this.age=age;
    7.     }
    8.     cons(text:string){
    9.       console.log(`Hi! ${this.name},${text}`);
    10.     }
    11. }
    12. new Person("Cat"，12).name; // 错误: 'name' 是私有的.
    • readonly 修饰符：将属性设置为只读的。
    1. class Person{
    2.     readonly name:string;
    3.     public age:number;
    4.     constructor(name:strng,age:number){
    5.         this.name=name;
    6.         this.age=age;
    7.     }
    8. }
    9. let dad =new Person("Cat"，12);
    10. dad.name = "小明"; // 错误! name 是只读的.

    六、存取器：TypeScript支持通过getters/setters来截取对对象成员的访问。

    1. class Person{
    2.     private _name:string;
    3.     get name():string{
    4.         return this._name;
    5.     }
    6.     set name(name:string){
    7.         this._name=name;
    8.     }
    9. }
    10. let man = new Employee();
    11. man.name='小明';

    七、TypeScript对象：对象是包含一组键值对的实例。 值可以是标量、函数、数组、对象等，实例如下：

    1. var object_name = { 
    2.     key1: "value1", // 标量 
    3.     key2: "value", 
    4.     key3: function() { // 函数 }, 
    5.     key4:["content1", "content2"] //集合 
    6. }

             1、对象字面量表示法

    1. var person = {
    2.     firstname:"Tom",
    3.     lastname:"Hanks"
    4. };
    5. console.log(person.firstname)
    6. console.log(person.lastname)

              2、TypeScript 类型模板

    1. var sites = { 
    2.     site1: "Runoob", 
    3.     site2: "Google", 
    4.     sayHello: function () { } // 类型模板 
    5. }; 
    6. sites.sayHello = function () { 
    7.     console.log("hello " + sites.site1); 
    8. }; 
    9. sites.sayHello();

              3、对象作为函数参数

    1. var person = {
    2.     firstname:"Tom",
    3.     lastname:"Hanks"
    4. };
    5. var invokeperson = function(obj: { firstname:string, lastname :string }) {
    6.     console.log("first name :"+obj.firstname)
    7.     console.log("last name :"+obj.lastname)
    8. }
    9. invokeperson(person);

              4、匿名对象

    1. var invokeperson = function(obj:{ firstname:string, lastname :string}) {
    2.     console.log("first name :"+obj.firstname)
    3.     console.log("last name :"+obj.lastname)
    4. }
    5. invokeperson({firstname:"Sachin",lastname:"Tendulkar"});

    八、抽象类和抽象方法

    • 用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
    • abstract抽象方法只能放在抽象类里面。
    • 抽象类和抽象方法用来定义标准。 

        示例：Animal 类要求它的子类必须包含eat方法

    1. abstract class Animal{
    2.     public name:string;
    3.     constructor(name:string){
    4.         this.name=name;
    5.     }
    6.     abstract eat():any; //抽象方法不包含具体实现并且必须在派生类中实现。
    7.     run(){
    8.         console.log('其他方法可以不实现')
    9.     }
    10. }
    11. //var a=new Animal() /*错误，抽象类不能实例化*/
    1. class Dog extends Animal{
    2.     constructor(name:any){
    3.         super(name)
    4.     }
    5.     eat(){//抽象类的子类必须实现抽象类里面的抽象方法
    6.         console.log(this.name+'吃粮食')
    7.     }
    8. }
    9.  
    10. var d=new Dog('小花花');
    11. d.eat();
    12. --------------------------------------------------------------
    13. class Cat extends Animal{
    14.     constructor(name:any){
    15.         super(name)
    16.     }
    17.     run(){}
    18.     eat(){ //抽象类的子类必须实现抽象类里面的抽象方法
    19.         console.log(this.name+'吃老鼠')
    20.     }
    21. }
    22.  
    23. var c=new Cat('小花猫');
    24. c.eat();

    附：

    面向对象的七大原则：

    1. 单一原则：一个类只负责一个职责。
    2. 里氏替换原则：子类可以在任何地方替换它的父类。
    3. 依赖倒置原则：代码要依赖于抽象的类，而不要依赖于具体的类；要针对接口或抽象类编程，而不是针对具体类编程。
    4. 接口隔离原则：提供尽可能小的单独接口，而不要提供大的总接口。暴露行为让后面的实现类知道的越少越好。
    5. 迪米特法则：尽量降低类与类之间的耦合。
    6. 开闭原则：面向扩展开放，面向修改关闭
    7. 组合/聚合复用原则：尽量使用合成/聚合达到复用，尽量少用继承。原则： 一个类中有另一个类的对象。
  • 相关阅读:
    ABAP RFC
    echarts散点图demo
    Day06-Python文件和数据格式化
    【 C++ 】红黑树
    浅谈安科瑞可编程电测仪表在老挝某项目的应用
    【汇编语言-王爽】第七章：更灵活的定位内存地址的方法
    CocosCreator3.8研究笔记（十七）CocosCreator UI组件（一）
    Python的2042小游戏及其详解
    Redis技术
    Vue - 得到组件渲染的DOM
  • 原文地址：https://blog.csdn.net/m0_37911706/article/details/125605700