typescript class修飾符public、private、protected、static、abstract

class修飾符的使用及區別

public、private、protected、static、abstract

public：可以繼承、實例化

// public可以繼承、實例化
class Person {
	public name: string;
	constructor(thename: string) {
		this.name = thename;
	}
}
class Jack extends Person {
	age: number;
	constructor(name: string, age: number) {
		super(name)
		this.age = age;
	}
	say() {
		console.log(`my name is ${this.name}, age ${this.age}`);
	}
}
let p1 = new Person('tom');
console.log(p1.name); // tom
let j1 = new Jack('jacker', 10);
j1.say(); // my name is jacker age 10

private 私有屬性只能在基類中訪問，不能在實例、派生類中訪問

class Person {
	private name: string;
	constructor(thename: string) {
		this.name = thename;
	}
	sayname() {
		console.log(`my name is ${this.name}`);
	}
}
class Jack extends Person {
	age: number;
	constructor(name: string, age: number) {
		super(name)
		this.age = age;
	}
	say() {
		// 只能在Person中訪問
		// console.log(`my name is ${this.name}, age ${this.age}`); // error
	}
}
let p1 = new Person('tom');
p1.sayname(); // tom
// console.log(p1.name); // tom // error 只能在Person中訪問
let j1 = new Jack('jacker', 10);
j1.sayname(); // jacker

  protected 受保護的，可以被繼承，在派生類中可以訪問，子類、父類都不能實例訪問

class Person {
	protected name: string;
	constructor(thename: string) {
		this.name = thename;
	}
	sayname() {
		console.log(`my name is ${this.name}`);
	}
}
class Jack extends Person {
	constructor(name: string) {
		super(name)
	}
	say() {
		// 只能在Person中訪問
		console.log(`my name is ${this.name}`);
	}
}
let p1 = new Person('tom');
p1.sayname(); // tom
console.log(p1.name); // tom // error 只能在Person、子類中訪問
let j1 = new Jack('jacker');
j1.say(); // jacker
console.log(j1.name); // error 只能在Person、子類中訪問

// static 只能通過基類、子類訪問，實例不能訪問

class Person {
	static myName: string;
	constructor(name: string) {
		Person.myName = name;
	}
	sayname() {
		return Person.myName;
	}
}
class Jack extends Person {
	constructor() {
		super('jacker');
	}
}
let p1 = new Person('tom');
p1.myName; // error Person上不存在myName屬性
console.log(p1.sayname());// tom
// 在類的外部訪問
console.log(Person.myName); // tom
let j1 = new Jack();
// 子類實例訪問基類方法
console.log(j1.sayname()); // jacker
j1.myName // error Jack 上不存在myName屬性
// 子類訪問靜態屬性
console.log(Jack.myName); // jacker

 // abstract 抽象類中的抽象方法不包含具體實現並且必須在派生類中實現

abstract class Person {
	sayname() {
		console.log('my name is sayname');
	}
	// 抽象方法不具體實現
	abstract say(): void;
}
class Jack extends Person {
	// 子類必須實現父類抽象方法
	say() {
		console.log('my name is jacker');
	}
}
// let p1 = new Person(); // 抽象類不可以被實例化
let j1 = new Jack();
j1.sayname();
j1.say();