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