class修饰符public、private、protected、static、abstract

class修饰符的使用及区别

public、private、protected、static、abstract

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()

　　

class修饰符的使用及区别

public、private、protected、static、abstract

public：可以继承、实例化

1.  
   // public可以继承、实例化
2.  
   class Person {
3.  
   public name: string;
4.  
   constructor(thename: string) {
5.  
   this.name = thename;
6.  
   }
7.  
   }
8.  
   class Jack extends Person {
9.  
   age: number;
10.  
    constructor(name: string, age: number) {
11.  
    super(name)
12.  
    this.age = age;
13.  
    }
14.  
    say() {
15.  
    console.log(`my name is ${this.name}, age ${this.age}`);
16.  
    }
17.  
    }
18.  
    let p1 = new Person('tom');
19.  
    console.log(p1.name); // tom
20.  
    let j1 = new Jack('jacker', 10);
21.  
    j1.say(); // my name is jacker age 10

private 私有属性只能在基类中访问，不能在实例、派生类中访问

1.  
   class Person {
2.  
   private name: string;
3.  
   constructor(thename: string) {
4.  
   this.name = thename;
5.  
   }
6.  
   sayname() {
7.  
   console.log(`my name is ${this.name}`);
8.  
   }
9.  
   }
10.  
    class Jack extends Person {
11.  
    age: number;
12.  
    constructor(name: string, age: number) {
13.  
    super(name)
14.  
    this.age = age;
15.  
    }
16.  
    say() {
17.  
    // 只能在Person中访问
18.  
    // console.log(`my name is ${this.name}, age ${this.age}`); // error
19.  
    }
20.  
    }
21.  
    let p1 = new Person('tom');
22.  
    p1.sayname(); // tom
23.  
    // console.log(p1.name); // tom // error 只能在Person中访问
24.  
    let j1 = new Jack('jacker', 10);
25.  
    j1.sayname(); // jacker

  protected 受保护的，可以被继承，在派生类中可以访问，子类、父类都不能实例访问

1.  
   class Person {
2.  
   protected name: string;
3.  
   constructor(thename: string) {
4.  
   this.name = thename;
5.  
   }
6.  
   sayname() {
7.  
   console.log(`my name is ${this.name}`);
8.  
   }
9.  
   }
10.  
    class Jack extends Person {
11.  
    constructor(name: string) {
12.  
    super(name)
13.  
    }
14.  
    say() {
15.  
    // 只能在Person中访问
16.  
    console.log(`my name is ${this.name}`);
17.  
    }
18.  
    }
19.  
    let p1 = new Person('tom');
20.  
    p1.sayname(); // tom
21.  
    console.log(p1.name); // tom // error 只能在Person、子类中访问
22.  
    let j1 = new Jack('jacker');
23.  
    j1.say(); // jacker
24.  
    console.log(j1.name); // error 只能在Person、子类中访问

// static 只能通过基类、子类访问，实例不能访问

1.  
   class Person {
2.  
   static myName: string;
3.  
   constructor(name: string) {
4.  
   Person.myName = name;
5.  
   }
6.  
   sayname() {
7.  
   return Person.myName;
8.  
   }
9.  
   }
10.  
    class Jack extends Person {
11.  
    constructor() {
12.  
    super('jacker');
13.  
    }
14.  
    }
15.  
    let p1 = new Person('tom');
16.  
    p1.myName; // error Person上不存在myName属性
17.  
    console.log(p1.sayname());// tom
18.  
    // 在类的外部访问
19.  
    console.log(Person.myName); // tom
20.  
    let j1 = new Jack();
21.  
    // 子类实例访问基类方法
22.  
    console.log(j1.sayname()); // jacker
23.  
    j1.myName // error Jack 上不存在myName属性
24.  
    // 子类访问静态属性
25.  
    console.log(Jack.myName); // jacker

 // abstract 抽象类中的抽象方法不包含具体实现并且必须在派生类中实现

1.  
   abstract class Person {
2.  
   sayname() {
3.  
   console.log('my name is sayname');
4.  
   }
5.  
   // 抽象方法不具体实现
6.  
   abstract say(): void;
7.  
   }
8.  
   class Jack extends Person {
9.  
   // 子类必须实现父类抽象方法
10.  
    say() {
11.  
    console.log('my name is jacker');
12.  
    }
13.  
    }
14.  
    // let p1 = new Person(); // 抽象类不可以被实例化
15.  
    let j1 = new Jack();
16.  
    j1.sayname();
17.  
    j1.say();