typeScript類-クラス

1、多態
実はJsのコンストラクションみたいな感じです.

//      
class Person {
  //     
  name: string;
  age: number
  //       
  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
  //     
  say() {
    return '     ' + this.name + ',  ' + this.age + ' !'
  }
}

let p1 = new Person('   ', 23)
console.log(p1) => // Person { name: '   ', age: 23 }
let psay = p1.say()
console.log(psay) => //         ,  23 !

2、継承する
JQextensのように、拡張機能の役割を果たしています.新しいクラスはextensの後ろのクラスの方法と属性を継承して呼び出します.

// Student   ，Person                    
class Student extends Person {
  school: string;
  constructor(school: string) {
    // Person             super()      ，super     (  )，super()           
    super('   ', 18)
    this.school = school
  }
  //        ，     ，     Person say(),     Student say  sayHi
  sayHi() {
    return `     ${this.name},  ${this.age} ,    ${this.school}`
  }
}

let p2 = new Student('    ')
let nsay = p2.say()
//      say       ,    Student say()，     Person
console.log(nsay) =>  //         ,  18 ,        
//       say       ，    Person say()
console.log(nsay) => //         ,  18 !

3、クラス(構造関数)変数のスコープ

//               lei         (   )

// public =>                              ，    ，     
class Person {
    public name: string;
    constructor(name: string) {
       this.name = name
    }
}
let p3 = new Testname('   ')
console.log(p3.name) => //    

// private =>                         
class Person {
    private name: string;
    constructor(name: string) {
       this.name = name
    }
}
let p3 = new Testname('   ')
console.log(p3.name) => //   
// vsCode                 ：  “name”     ，    “Testname”   
//           ：Property 'name' is private and only accessible within class 'Testname'
//     ，private            ，      
    

// protected =>                            
class Person {
    pretected name: string;
    constructor(name: string) {
       this.name = name
    }
}
let p3 = new Testname('   ')
console.log(p3.name) => //   
// vsCode                 ：   “name”   ，    “Testname”       
//         ：Property 'name' is protected and only accessible within class 'Testname' and its subclasses
//     ，pretected            

サブクラスとベース(親タイプ)

class Son extends Father {}
//     
Son      Father   

4、readonly読み取り専用属性
読み取り専用の属性は宣言時または構造関数で初期化されなければなりません.値は修正されません.constと似ています.

class Person {
    pretected name: string;
    constructor(name: string) {
       this.name = name => //      
    }
}

5、アクセサ
クラスの中で一つの属性をprvateで修飾すると、クラスの外部でこの属性にアクセスできなくなります.この時はgetters/settersを通してパッケージ化して、クラスの外部でこの属性にアクセスすることができます.特に、getだけを持ってsetを持たないアクセサは、自動的にreadonlyと推定される.つまり、getだけ書いてsetがないと、私たちは値を変えることができません.

class Person {
    private _age: number; => //   ，  “_age”        ，            。
    constructor() {
        this._age = 0 => //     ，        
      }
    //       
    /*   java  getAge()*/
    get age () {
        return this._age
    }
    /*   java  setAge()*/
    set age (newAge: number) {
        if (newAge < 0 || newAge > 150) {
            console.log('   ，         !')
        } else {
            this._age = newAge
        }
    }
    say () {
        return `   ${this._age}  !`
    }
}
let p4 = new Person()
p4._age = 30 =>   “_age”     ，    “Person”   
p4.age = 30
console.log(p4.say()) => //   30  !

6、静的属性
javaと似ています.staticのキーワードを使って修飾します.staticで修飾した属性は、このクラスがロードされた時に初期化されます.静的属性は直接にクラス名を通してアクセスします.

class Person {
    //      constructor    ，  static     
    static school:String = "    ";
    /*                           */
    constructor(private name: String, protected age: number) {
        this.name = name;
        this.age = age;
    }
    private say() {
        console.log(`${this.name},${this.age}`);
    }
    protected tell() {
        console.log(`${this.name},${this.age}`);
    }
}
Person.school;//        ，     
console.log(Testschool.school) => //      ，              undefined,         new    ，   
console.log(Testschool.school) => //     ，           

7、抽象類(abstract)
abstractキーワードは抽象類を定義し、抽象類の内部で抽象的な方法を定義するために用いられ、サブクラスは親の抽象的な方法を実現しなければならず、それらは実用化されず、継承のみを提供する.

abstract class Father {
  name: string;
  age: number;
  constructor() {
    this.name = '   '
    this.age = 23
  }
  abstract say():string =>       ，    
  tell() {
    console.log('        !')
  }
}

class Son extends Father {
  school: string;
  constructor() {
    super()
    this.school = '  '
  }
  say() {
    return '      !'
  }
}
let p5 = new Son()
p5.tell() => //         !
console.log(p5.say()) => //       !
let p6 = new Father() => //   ：          

8、書き換える

class NewFather {
  say() {
    console.log('    ')
  }
}
class NewSon extends NewFather {
  say() {
    super.say()
    console.log('    ')
  }
}
let g: NewSon = new NewSon()
g.say() =>     
result: 
    
    

転載先:https://www.cnblogs.com/zjh-study/p/10650648.html