class 类名{
public readonly 属性名称:string
public 名称?:string ?可选属性
public static 声明静态属性
其中:
readonly修饰的属性,必须在声明时或构造函数里被初始化,即可以在构造函数中被修改。
private:只能在类中被调用,不能在实例和派生类中调用
给constructor添加private表示该类不能被显示new实例化和继承
protected:只能在类和派生类中调用,不能在该类的实例中调用
给constructor添加protected表示该类只能被继承,相当于声明一个基类
构造函数
方式一
constructor:(属性:类型)
{
this.属性=属性
}
方式二
将属性定义和构造器合并,则使用了修饰符的属性(包括readonly修饰的)会被绑定到this上
constructor(public 属性:类型,readonly 属性:类型){}
getter和setter
使得类外可以调用私有属性和方法
getter:
get x():返回类型 不能有参数
{
return this.xx
}
调用:实例对象.x
setter
set x(xx:类型) 只能具有一个参数,且类型必须和get的返回类型一致
{
this.xx=xx
}
调用:实例对象.x=xx
}
抽象类,继承类来实现,继承类重写必须满足抽象类中的类型约束的抽象属性和抽象方法
abstract class 类名{
abstract 属性:类型 抽象属性
abstract 方法名():返回类型; 抽象方法
可以有普通方法和变量
setter和getter抽象方法,子类需要实现对应的set/get方法或声明x属性
abstract set x(value:类型);
abstract get x():类型
}
其中:
抽象类不能被实例化,若用作约束类型,只能使用抽象类中的方法
通过this或实例对象来调用抽象类中的普通方法或属性
实现接口约束
接口检测的是类的实例属性,如果通过静态属性实现,并不能符合
interface x{
属性:类型,
函数名():返回约束
...
}
class X implements x{
必须实现接口中的除了非必要属性以外的属性,以及实现的属性不能用private和protected修饰,因为接口中的属性是公有的
}
class X implements x,x2{ 接口可以实现多个
必须实现接口中的除了非必要属性以外的属性,以及实现的属性不能用private和protected修饰,因为接口中的属性是公有的
}
let y:x=new X();
let y:X=new X();
继承
class X extends XX{
...
super(参数); 必须调用父类构造器
super.方法名()/属性; 调用父类属性,一般用于重写的父类方法中继续使用父类方法
this.父类方法名()/属性同样能访问(若未重写)
}
如果继承的类是泛型类,需要实现泛型或者扩展泛型
实现泛型:
class X extends XX<类型>{...}
扩展泛型:
class X<T> extends XX<T>{...}
类约束(当两个类的内部实现一样时,即便声明了类型可以进行赋值)
class Foo {
x!: number;
constructor() {
}
}
let a: Foo = {x:2} 当无typeof时,需要实现类的属性等
let b:typeof Foo=class{...} 当有typeof时,类返回的是构造函数
链式调用
通过方法返回this能实现链式调用
和接口声明合并,会添加到类的原型上
class F{} 也可以是同名方法、变量
interface F { 会为类添加一个name属性
name:string
}
const f = new F();
f.name;
代码示例;
//static
class An{
static is(a){
return 1
}
}
An.is(2);
class Dog{
static age=20;
}
let age:number=Dog.age;
class Cat{
a=1;
private b=1;
constructor(){
this.a=1;
this.b=2;
}
}
class Mer{
private name;
public constructor(name){
this.name=name;
}
}
let mer=new Mer('橘猫');
class Lanmao{
protected name;
public constructor(name){
this.name=name;
}
}
//继承
class Xiaomao extends Lanmao{
constructor(name){
super(name);
console.log(this.name);
}
}
//抽象类,只能用于继承
abstract class Pink{
public name;
constructor(name){
this.name=name;
}
//抽象类中的函数也是抽象函数
public abstract sayhi();
}
class Black extends Pink{
sayhi(){
console.log('hello');
}
}