TypeScript，面向对象，类构造函数继承抽象类接口和封装

　　面向对象
　　面向对象，Object Oriented，软件开发方法，一种编程范式。
　　面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
　　面向对象的三大特性：封装、继承、多态。
　　TypeScript面向对象，类 (class)
　　1、static关键字，表示一个静态属性，通过类访问。
　　2、readonly关键字，表示一个只读属性，不能修改属性，构造函数可初始化。
　　构造函数和this关键字
　　1、constructor函数，称为构造函数，对象创建时调用。
　　2、在实例方法中，this就表示当前当前的实例。
　　继承（extends）和super关键字
　　1、子类写了constructor构造函数必须使用super继承父类constructor构造函数的属性
　　2、通过继承可以将多个类中共有的代码写在一个父类中，继承后子类将会拥有父类所有的方法和属性。
　　3、方法重写，子类中添加了和父类相同的方法，子类方法会覆盖掉父类的方法
　　抽象（abstract）
　　1、以abstract开头的类是抽象类，抽象类不能实例化，事专门用来被继承的类。
　　2、抽象类中可以添加抽象方法，非抽象类中不可以有抽象方法。
　　3、抽象方法使用abstract开头，没有方法体，只能定义在抽象类中，子类必须对抽象方法进行重写。
　　接口（interface）
　　1、接口的作用类似于抽象类，不同点在于接口中的所有函数和属性都是没有实值的，接口中的所有方法都是抽象方法。
　　2、接口主要负责定义一个类的结构，限制一个对象的接口，对象只有包含接口中定义的所有属性和方法时才能匹配接口。
　　3、一个类去实现接口，实现接口时类中要包括接口中的所有属性。
　　封装和属性的封装
　　1、private修饰符，私有的属性，私有属性只能在类内部进行访问修改。
　　2、protected修饰符，受保护的属性，只能在当前类和当前类的子类中访问。
　　3、public修饰符，共有的属性，修饰的属性可以再任意位置访问修改默认值。
　　4、getter方法用来读取属性。
　　5、setter方法迎来设置属性。
　　6、getter和setter被统一称为属性的存储器，定义时在方法之前添加get和set，调用的时候直接通过点语法调用。代码案例
　　案例1： class MyUser {     static desc: string = ＂用户类＂; // 使用static开头的属性是静态属性（类属性），可以直接通过类去访问     readonly id: number = 1000004; // readonly开头的属性表示一个只读的属性无法修改     name: string = ＂张三＂;     age: number = 28;     toString() {         return ＂id=＂ + this.id + ＂,name=＂ + this.name + ＂,age=＂ + this.age;     } } let myUser = new MyUser(); console.log(＂myUser=＂, myUser); // myUser= MyUser { id: 1000004, name: ＂张三＂, age: 28 } console.log(＂myUser.desc=＂, MyUser.desc); // myUser.desc= 用户类
　　案例2： class MyUser2 {      readonly id: number;     name: string;     age: number;      /**      * 构造函数和this      * @param id       * @param name       * @param age       */     constructor(id: number, name: string, age: number) {         this.id = id;         this.name = name;         this.age = age;     }      toString() {         return ＂id=＂ + this.id + ＂,name=＂ + this.name + ＂,age=＂ + this.age;     } }  let myUser2 = new MyUser2(1000001, ＂孔子＂, 2000); console.log(＂myUser2=＂, myUser2); // myUser2= MyUser2 { id: 1000001, name: ＂孔子＂, age: 2000 }
　　案例3： (     function () {         /**          * 以abstract开头的类是抽象类，抽象类和其他类区别不大，不能用来创建对象          * 抽象类就是专门用来被继承的类          * 抽象类中可以添加抽象方法          */         abstract class MyUser3 {              readonly id: number;             name: string;             age: number;              /**              * 构造函数和this              * @param id               * @param name               * @param age               */             constructor(id: number, name: string, age: number) {                 this.id = id;                 this.name = name;                 this.age = age;             }              toString() {                 return ＂id=＂ + this.id + ＂,name=＂ + this.name + ＂,age=＂ + this.age;             }              /**              * 抽象方法使用 abstract开头，没有方法体              * 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写              */             abstract work():void ;         }          class MyEmployee extends MyUser3 {              /**              * 构造函数              * @param id               * @param name               * @param age               */             constructor(id: number, name: string, age: number) {                 super(id, name, age);             }              work() {                 console.log(＂雇员，id=＂ + this.id + ＂,name=＂ + this.name + ＂在工作＂);             }         }          class MyManager extends MyUser3 {             work() {                 console.log(＂经理，id=＂ + this.id + ＂,name=＂ + this.name + ＂在工作＂);             }         }          let myEmployee = new MyEmployee(1, ＂沙僧＂, 501);         // myEmployee= MyEmployee { id: 1, name: ＂沙僧＂, age: 501 }         console.log(＂myEmployee=＂, myEmployee);         myEmployee.work();         // 雇员，id=1,name=沙僧在工作          let myManager = new MyManager(1, ＂唐僧＂, 500);         // myManager= MyManager { id: 1, name: ＂唐僧＂, age: 500 }         console.log(＂myManager=＂, myManager);         myManager.work();         // 经理，id=1,name=唐僧在工作      } )();
　　案例4： interface MyWorker{     work():void; }  class MyUser4 implements MyWorker {        readonly id: number = 1000004; // readonly开头的属性表示一个只读的属性无法修改     name: string = ＂张三＂;     age: number = 28;     toString() {         return ＂id=＂ + this.id + ＂,name=＂ + this.name + ＂,age=＂ + this.age;     }     work() {         console.log(＂用户，id=＂ + this.id + ＂,name=＂ + this.name + ＂在工作＂);     } } let myUser4 = new MyUser4(); // myUser4= MyUser4 { id: 1000004, name: ＂张三＂, age: 28 } console.log(＂myUser4=＂, myUser4);  myUser4.work(); //用户，id=1000004,name=张三在工作
　　案例5： (function () {     // 定义一个表示人的类     class Person {         // TS可以在属性前添加属性的修饰符         /*         *   public，修饰的属性可以在任意位置访问（修改） 默认值         *   private，私有属性，私有属性只能在类内部进行访问（修改）         *         - 通过在类中添加方法使得私有属性可以被外部访问         *   protected 受包含的属性，只能在当前类和当前类的子类中访问（修改）         *         * */         private _name: string;         private _age: number;          /**          * 构造函数          *           * @param name           * @param age           */         constructor(name: string, age: number) {             this._name = name;             this._age = age;         }          /*         *   getter方法用来读取属性         *   setter方法用来设置属性         *       - 它们被称为属性的存取器         * */         // TS中设置getter方法的方式         get name() {             // console.log(＂get name()执行了！！＂);             return this._name;         }         set name(value) {             this._name = value;         }         get age() {             return this._age;         }         set age(value) {             if (value >= 0) {                 this._age = value             }         }     }      const person = new Person(＂孙悟空＂, 18);     /*     * 现在属性是在对象中设置的，属性可以任意的被修改,     *   属性可以任意被修改将会导致对象中的数据变得非常不安全     * */     // person.setName(＂猪八戒＂);     // person.setAge(33);     person.name = ＂猪八戒＂;     person.age = 33;     console.log(person);      class A {         //protected是保护的属性，只能在当前类和子类中设置         //protected只能在当前类和当前类的子类中设置         protected num: number;         constructor(num: number) {             this.num = num;         }     }     class B extends A {         test() {             console.log(this.num);         }     }     const b = new B(123456789);     // b.num = 33; // 属性＂num＂受保护，只能在类＂A＂及其子类中访问。      class C1 {          name: string;         age: number          // 可以直接将属性定义在构造函数中         constructor(name: string, age: number) {             this.name = name;             this.age = age;         }     }     const c1 = new C1(＂沙僧＂, 111222333);     console.log(c1);     // C1 { name: ＂沙僧＂, age: 111222333 }      class C2 {         // 直接将属性定义在构造函数中         constructor(public name: string, public age: number) {         }     }     const c2 = new C2(＂沙僧＂, 111222333);     console.log(c2);     // C2 { name: ＂沙僧＂, age: 111222333 }  })();