class modifiers public, private, protected, static, abstract

The use and difference of class modifiers

public, private, protected, static, abstract

public: can be inherited and instantiated

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 private properties can only be accessed in the base class, not in instances or derived classes

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() {
// Can only be accessed in 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 can only be accessed in Person
let j1 = new Jack('jacker', 10);
j1.sayname(); // jacker

protected is protected, can be inherited, and can be accessed in derived classes. Neither subclasses nor parent classes can access instances

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() {
// Can only be accessed in Person
console.log(`my name is ${this.name}`);
}
}
let p1 = new Person('tom');
p1.sayname(); // tom
console.log(p1.name); // tom // error can only be accessed in Person and subclasses
let j1 = new Jack('jacker');
j1.say(); // jacker
console.log(j1.name); // error can only be accessed in Person and subclasses

// static can only be accessed through base classes and subclasses, not instances

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 myName attribute does not exist on Person
console.log(p1.sayname());// tom
//Access outside the class
console.log(Person.myName); // tom
let j1 = new Jack();
// Subclass instance accesses base class method
console.log(j1.sayname()); // jacker
j1.myName // error Jack attribute does not exist on myName
// Subclass access static properties
console.log(Jack.myName); // jacker

// abstract Abstract methods in abstract classes do not contain concrete implementations and must be implemented in derived classes

abstract class Person {
sayname() {
console.log('my name is sayname');
}
//Abstract methods are not implemented concretely
abstract say(): void;
}
class Jack extends Person {
// Subclasses must implement the abstract methods of the parent class
say() {
console.log('my name is jacker');
}
}
// let p1 = new Person(); // Abstract classes cannot be instantiated
let j1 = new Jack();
j1.sayname();
j1.say()

The use and difference of class modifiers

public, private, protected, static, abstract

public: can be inherited and instantiated

1. // public can be inherited and instantiated

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 private properties can only be accessed in base classes, not instances or derived classes.

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. // Can only be accessed in 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 can only be accessed in Person

24. let j1 =
    new Jack(
    ‘jacker’,
    10);

25. j1.sayname();
    // jacker

protected is protected, can be inherited, and can be accessed in derived classes. Neither subclasses nor parent classes can access instances.

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. // Can only be accessed in 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 can only be accessed in Person and subclasses

22. let j1 =
    new Jack(
    ‘jacker’);

23. j1.say();
    // jacker

24. console.log(j1.name);
    // error can only be accessed in Person and subclasses

// static can only be accessed through base classes and subclasses, instances cannot be accessed

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 myName attribute does not exist on Person

17. console.log(p1.sayname());
    // tom

18. //Access outside the class

19. console.log(Person.myName);
    // tom

20. let j1 =
    new Jack();

21. // Subclass instance accesses base class method

22. console.log(j1.sayname());
    // jacker

23. j1.myName
    // myName attribute does not exist on error Jack

24. // Subclass access static properties

25. console.log(Jack.myName);
    // jacker

// abstract Abstract methods in abstract classes do not contain concrete implementations and must be implemented in derived classes

1. abstract
   class Person {

2. sayname() {

3. console.log(
   ‘my name is sayname’);

4. }

5. //Abstract methods are not implemented concretely

6. abstract say():
   void;

7. }

8. class Jack extends Person {

9. // Subclasses must implement the abstract methods of the parent class

10. say() {

11. console.log(
    ‘my name is jacker’);

12. }

13. }

14. // let p1 = new Person(); // Abstract classes cannot be instantiated

15. let j1 =
    new Jack();

16. j1.sayname();

17. j1.say();