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

面向对象的七大原则：

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

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

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

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

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

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

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

一、TypeScript 类

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 支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。

类继承使用关键字

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("父类的") 
} 
} 
class StringPrinter extends PrinterClass { 
doPrint():void { 
super.doPrint() // 调用父类的函数
console.log("子类的") 
} 
}

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

例如：

  

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


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

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