面向对象
类 (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')