ES6语法
class Person{
a(){
alert(123)
};
b(){
return 112233
};
constructor(aa=999){
this.x=aa;
this.bb=function(){
alert(222)
}
};
}
var p=new Person(1);
则x和bb是p的属性,而a和b在p的原型链上
ES7语法
允许直接在类里面定义属性，允许通过static定义静态属性
class Animal {
name = 'Jack';
static num = 42;
constructor() {
// ...
}
}
let a = new Animal();
console.log(a.name); // Jack
console.log(Animal.num); // 42
class Doit{
static hello:number=12321;
showHello(){
console.log(Doit.hello)
}
}
console.log(Doit.hello)
var doit=new Doit()
doit.showHello()
静态属性作为该类本身而非实例的属性被调用。在class内与class外都可以被调用
TS语法
class Person{
x:number;
bb;
a(){
alert(123)
};
b(){
return 112233
};
constructor(public aa:number=999){
this.x=aa;
this.bb=function(){
alert(222)
}
};
}
var p=new Person(1);
此时constructor中的x和bb必须事先被声明,且默认为public
形参aa默认为private
为private的无法在外部被使用,仅有为public的才能作为实例p的属性被调用
TS中类的继承
class Me extends Person{
p2p:any;
constructor(b){
super(b);
this.p2p='666'
};
mover(){
console.log('my mover','mover')
// super.mover()
}
}
var me:Person=new Me(66)
出现同名的属性和方法则以子类的为准,但是依然可以用 super.对应名的方式调用父类的内容
在子类的构造函数中用super()可以直接继承父类的构造函数
TS的修饰符
对于带有private的， 如果其中一个类型里包含一个private成员，那么只有当另外一个类型中也存在这样一个private成员， 并且它们是来自同一处声明时，我们才认为这两个类型是兼容的。 对于protected成员也使用这个规则。
例如:
class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}
class Rhino extends Animal {
constructor() { super("Rhino"); }
}
class Employee {
private name: string;
constructor(theName: string) { this.name = theName; }
}
let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");
animal = rhino;
animal = employee; // Error: Animal and Employee are not compatible
- private：属性和方法只能在该class内部使用，被继承后在子类的constructor中虽然能用super()获取，但无法输出，也无法在方法中使用。因此可以认为private的属性只是为了给该class自身（不包括子）的方法提供参数，与其他都无关系
- protected：属性和方法虽然也不能在class外调用，可以被子class继承
同理，加了protected的构造函数，本身无法被实例化。但是继承其class的子类可以实例化 - readonly：只读属性关键字
修饰符可以出现在构造函数参数中，等同于类中定义该属性同时给该属性赋值：
class Animal {
// public readonly name: string;
public constructor(public readonly name) {
// this.name = name;
}
}
abstract
用于定义抽象类和其中的抽象方法。
抽象类不能被实例化。
抽象方法不能有实际内容，且必须被子类实现。
abstract class Animal {
public name;
public constructor(name) {
this.name = name;
}
public abstract sayHi();
}
class Cat extends Animal {
public sayHi() {
console.log(`Meow, My name is ${this.name}`);
}
}
let cat = new Cat('Tom');
