Typescript 面向对象

面向对象

类 (class)

• static关键字可以定义类属性| 类方法（静态属性｜静态方法）

   class Person {
   	static age: number = 18
   	static sayHe() {
   		console.log('hi')
   	}
   }
   Person.age  // 18
   Person.sayHe() // hi
  

• readonly只读属性

   class Person {
   	readonly name: string = 'Jin'
   }
   // 该属性不可修改， 可与static联合使用 static readonly
  

• 类的继承

	class Animal {
		name: string,
		age: number,
		constructor(name: string, age: number) {
			this.name = name;
			this.age = age;
		}
		sat() {
			console.log('这是一个公用类')
		}
	}
	/*
	 * -- Animal为父类， Dog为子类
 	* 
 	*  -- 使用继承后，子类将会拥有父类所有的方法和属性
 	* 
 	*  -- 通过继承可以将多个类中共有的代码，写在一个父类中

	*  -- 如果在子类中添加了父类相同的方法，则会覆盖（方法重写）
	*/
 	
 	// 使用Dog类继承Animal类
 	class Dog extends Animal {
	
 }

• super 在类的方法中，super就表示当前类的父类

  class A extends B {
  	constructor() {
  		// 如果在子类中写了构造函数，在子类的构造函数中必须对父类的构造函数调用
  		super()
  		//在类的方法中，super就表示当前类的父类
  	}	
  }
  

• 抽象类

以abstract开头的类是抽象类
抽象类和其他类区别不大，只是不能用来创建对象
抽象类就是专门用来被继承的类
抽象类中可以添加抽象方法，

abstract sayH():void;

• 接口

接口用来定义一个类结构，用来定义一个类中应该包含哪些属性和方法
同时接口也可以当成类型声明去使用
接口可以在定义类的时候去限制类的结构
接口中的所有属性都不能有实际的值，接口只定义对象的结构，而不考虑实际值
在接口中，所有的方法都是抽象方法

interface myInter {
   name: string,
   sayH(): void;
 }

 // 定义类时，可以使类去实现接口
class MyCalss implements myInter{ 
  name: string;
  constructor(name: string) {
    this.name = name
  }
  sayH() {
    console.log(99)
  }
}

• 属性封装

	 // 定义类时，可以使类去实现接口
	 /**
	 * 现在属性是在对象中设置的，属性可以任意修改的
	 * 
	 *  属性任意修改，将会导致对象中的数据变得非常不安全
	 */
class MyCalss implements myInter{ 
  name: string;
  constructor(name: string) {
    this.name = name
  }
  sayH() {
    console.log(99)
  }
}
let obj: myInterFace;
obj =  {
  name: '2',
  age: 2,
  number: 2
}

class Persons {
  //TS中可以在属性前添加属性的修饰符
  /**
 * public 修饰的属性可以在任意位置访问  默认值
 * protected 受保护的属性，只能在当前类和当前类的子类中访问
 * private 私有属性只能在类内部进行修改
 *  
 *    -通过在类中添加方法
   */
  private _name: string;
  private _age: number;
  constructor(name: string, age:number) {
    this._name = name; 
    this._age = age;
  }
  // // 定义一个方法 用来获取name
  // getName() {
  //   return this._name;
  // }

  // //定义方法，用来设置name属性
  // setName(value: string) {
  //   this._name = value
  // }

  // TS中设置getter方法的方式
  get name() {
    return this._name;
  }
  set name(value: string) {
    this._name = value
  }

  set age(value: number) {
    if (value > 0) {
      this._age = value
    }
  }
}

• 直接在属性定义在构造函数中

	class C {
		constructor (public name: string, public age: number){
	`
		}
	}

• 泛型

  在定义函数或是类时，如果遇到类型不明确就可以使用泛型
  可以同时指定多个

	function fn<k>(a:k):k {
		return a
	}
 	//可以直接调用具有泛型的函数
 	fn(10)  // TS可以自动对类型进行推断
 	
	fn<string>('hello') // 指定泛型

	function fn2<T,K>(a: T, b: K): T {
		return a
	}
	// 继承接口
	interface Inter {
		length: number
	}
	function fn3<K extends Inter>(a: T): number {
		return a.length
	}
	fn3('hello')

	class Myclass<T>{
		name: T,
		constructor(name: T) {
			this.name = name
		}
	}
	const mc = new Myclass<string>('Jin')