TypeScript面向对象编程---类和对象

面向对象的七大原则：

(1) 单一原则：一个类只负责一个职责。

(2) 里氏替换原则：子类可以在任何地方替换它的父类。

(3) 依赖倒置原则：代码要依赖于抽象的类，而不要依赖于具体的类；要针对接口或抽象类编程，而不是针对具体类编程。

(4) 接口隔离原则：提供尽可能小的单独接口，而不要提供大的总接口。暴露行为让后面的实现类知道的越少越好。

(5) 迪米特法则：尽量降低类与类之间的耦合。

(6) 开闭原则：面向扩展开放，面向修改关闭

(7) 组合/聚合复用原则：尽量使用合成/聚合达到复用，尽量少用继承。原则： 一个类中有另一个类的对象。

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

1.1、类的定义

class class_name {

    // 类作用域

}

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

(1) 字段(属性) − 字段是类里面声明的变量。字段表示对象的有关数据。

(2) 构造函数 − 类实例化时调用，可以为类的对象分配内存。

(3) 方法 − 方法为对象要执行的操作。

     例如：

class Car { 

// 字段

engine:string;

// 构造函数

constructor(engine:string) {

 this.engine = engine 

} 

// 方法

disp():void { 

console.log("发动机为 : "+this.engine) 

} 

}

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

      示例：

// 创建一个对象

 var obj = new Car("XXSY1");

// 访问字段 

console.log("读取发动机型号 : " + obj.engine);

// 访问方法

obj.disp();

   二、类的继承

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

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

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

实例：

class Shape { 

Area:number 

constructor(a:number) { 

this.Area = a 

} 

}

 class Circle extends Shape { 

disp():void { 

console.log("圆的面积: "+this.Area) 

} 

} 

var obj = new Circle(223);

obj.disp()

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

例如：

    class PrinterClass { 

doPrint():void { 

console.log("父类的 doPrint() 方法。") 

} 

} 

class StringPrinter extends PrinterClass { 

doPrint():void { 

super.doPrint() // 调用父类的函数

console.log("子类的 doPrint()方法。") 

} 

}

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

例如：

   class StaticMem { 

static num:number;

static disp():void { 

console.log("num 值为 "+ StaticMem.num) 

} 

} 

StaticMem.num = 12 // 初始化静态变量 

StaticMem.disp() // 调用静态方法

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

class Person{ }

  var obj = new Person()

  var isPerson = obj instanceof Person;

console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);

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

• public（默认） : 派生类、类的实例对象都可以访问。

class Person{

    public name:string;

    public age:number;

    constructor(name:strng,age:number){

        this.name=name;

        this.age=age;

    }

    cons(text:string){

      console.log(`Hi! ${this.name},${text}`);

    }

}

• protected (保护属性): 派生类可以访问、类的实例对象不可以访问。

class Person{

    protected name:string;

    public age:number;

    constructor(name:strng,age:number){

        this.name=name;

        this.age=age;

    }

}

class Man extends Person{

    sex:string;

    constructor(name:strng,age:number,sex:string;){

        super(name,age)

        this.sex=sex

    }

    cons(text:string){

         console.log(`Hi! ${this.name},${text}`);

    }

}

new Man("Cat"，12).name; // 错误,name是保护属性

• private (私有属性): 派生类、类的实例对象不可以访问。

class Person{

    private name:string;

    public age:number;

    constructor(name:strng,age:number){

        this.name=name;

        this.age=age;

    }

    cons(text:string){

      console.log(`Hi! ${this.name},${text}`);

    }

}

new Person("Cat"，12).name; // 错误: 'name' 是私有的.

• readonly 修饰符：将属性设置为只读的。

  class Person{

    readonly name:string;

    public age:number;

    constructor(name:strng,age:number){

        this.name=name;

        this.age=age;

    }

}

let dad =new Person("Cat"，12);

dad.name = "小明"; // 错误! name 是只读的.

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

class Person{

    private _name:string;

    get name():string{

        return this._name;

    }

    set name(name:string){

        this._name=name;

    }

}

let man = new Employee();

man.name='小明';

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

var object_name = { 

key1: "value1", // 标量 

key2: "value",

key3: function() { // 函数 },

key4:["content1", "content2"] //集合 

}

  1、对象字面量表示法

var person = {

firstname:"Tom",

lastname:"Hanks"

};

console.log(person.firstname)

console.log(person.lastname)

  2、TypeScript 类型模板

var sites = { 

site1: "Runoob",

site2: "Google",

sayHello: function () { } // 类型模板 

};

sites.sayHello = function () { 

console.log("hello " + sites.site1);

};

sites.sayHello();

     3、对象作为函数参数

var person = {

firstname:"Tom",

lastname:"Hanks"

};

var invokeperson = function(obj: { firstname:string, lastname :string }) {

console.log("first name :"+obj.firstname)

console.log("last name :"+obj.lastname)

}

invokeperson(person);

4、匿名对象

var invokeperson = function(obj:{ firstname:string, lastname :string}) {

console.log("first name :"+obj.firstname)

console.log("last name :"+obj.lastname)

}

invokeperson({firstname:"Sachin",lastname:"Tendulkar"});

八、抽象类和抽象方法

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

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

abstract class Animal{

public name:string;

constructor(name:string){

this.name=name;

}

abstract eat():any; //抽象方法不包含具体实现并且必须在派生类中实现。

run(){

console.log('其他方法可以不实现')

}

}

//var a=new Animal() /*错误，抽象类不能实例化*/

--------------------------------------------------------------

class Dog extends Animal{

constructor(name:any){

super(name)

}

eat(){//抽象类的子类必须实现抽象类里面的抽象方法

console.log(this.name+'吃粮食')

}

}

var d=new Dog('小花花');

d.eat();

--------------------------------------------------------------

class Cat extends Animal{

constructor(name:any){

super(name)

}

run(){}

eat(){ //抽象类的子类必须实现抽象类里面的抽象方法

console.log(this.name+'吃老鼠')

}

}

var c=new Cat('小花猫');

c.eat();