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

你可能感兴趣的