类
类有两部分：静态部分和实例部分
基本
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
greet() {
return this.greeting;
}
}
-
类方法挂在prototype上
类属性是实例属性
类属性必须被初始化
1.在constructor里
2.声明时
class Greeter {
name:string='dog';
}
-
编译
ts
由上图可知编译时：
- 没有修饰符、protected、private成员挂在实例上；
- 方法挂在类的prototype上；
- static修饰符挂在类上；
继承与修饰符
public:
- ts里的类成员默认为public
-
参数属性：可以在constructor的入参加public，此时该入参为实例属性
public修饰入参
实例
private
- 不能在类外部访问，包括实例和派生类;
- 如果
private constructor则该类不可以被new和继承。
protected:
- 与private相比，可以在派生类中访问;
- 如果
protected constructor则该类不可以被new，�但可以被继承。
readonly
- 只读属性必须在声明时或构造函数里被初始化。
static
- 可以通过类和派生类来访问，不能通过实例访问
抽象类
abstract class Talk {
protected name: string = 'geo';
protected constructor(str?: string) {
// this.name = str;
}
abstract speaking(): void;
}
- 关键字abstract
- 抽象类作为其他派生类的基类不会被实例化
多态
- 实现：使用同一个抽象类，由不同的派生类进行不同的实现
abstract class Animal {
abstract makeSound(): void;
move(): void {
console.log('move')
}
}
class Dog extends Animal {
makeSound() {
console.log('dog makeSound');
}
}
let dog = new Dog();
class Cat extends Animal {
makeSound() {
console.log('cat makeSound');
}
}
let cat = new Cat();
let animal: Array<Animal> = [dog, cat];
animal.forEach(element => {
console.log(element.makeSound());
});
链式调用在多态中应用
- 链式调用
class Task{
step1() {
return this;
}
step2() {
return this;
}
}
new Task().step1().step2()
- 多态
用以保证父类与子类调用的连贯性
使用场景：父类接口与子类接口相继调用
class Task{
step1() {
return this;
}
step2() {
return this;
}
}
class Story extends Task{
next() {
return this;
}
}
new Story().next().step1().next().step2()
接口
interface Human {
walk(): void;
}
interface Man extends Human {
speak(): string;
}
interface Child extends Human {
cry(): string;
}
class Boy implements Man, Child {
cry(): string {
return "";
}
walk() {
return;
}
speak() {
return "";
}
}
- 类实现接口的时候必须实现接口的所有定义，类可以实现接口没有声明的定义
- 接口只能约束类的公有成员
- 接口不能约束类的构造函数
- 接口继承类
class Control {
state = 1;
}
interface Port extends Control {
}
class Task implements Port {
state: number;
}
new Task();
泛型
泛型类型
function identify<T>(arg: T): T {
return arg;
}
identify<string[]>(['a', 'b']); // 设定T类型，调用
identify(['a', 'b']);// 自动推导出T类型，调用
// 定义类型
type Log = <T>(value: T) => T;
// interface 1
interface Log {
<T>(value: T): T
}
// interface 2
interface Log<T = string> {
(value: T): T
}
// 调用
let log: Log<number> = identify;
console.log(identify(2));
泛型类
class Log<T>{
run(value: T) {
return value;
}
}
let log1 = new Log<number>();
log1.run(1);
-
类有两部分：静态部分和实例部分。泛型指的是实例部分的类型。
泛型不能用在静态部分
泛型约束
interface Length {
length: number;
}
function logLength<T extends Length>(params: T) {
return params.length;
}
logLength([1]);
// 类型参数
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
