1.クラスを定義します

クラスのプロパティ：

インスタンス属性：オブジェクトのインスタンスを介してアクセスされる、直接定義された属性
静的属性（クラス属性）：static最初は、インスタンスを作成する必要はなく、クラスを介してアクセスします
読み取り専用属性：readonly先頭、変更できません

クラスのメソッド：

インスタンスメソッド：直接定義されたメソッド
クラスメソッド：static最初に、クラスを通して訪問する

class Person {
    
    
    // 直接定义的属性
    age = 18;
    // 静态属性（类属性）
    static gender = 'man';
    // 只读属性
    readonly name = 'Jack';

    // 实例方法
    sayHello() {
    
    
        console.log('Hello!');
    }

    // 类方法
    static sayHi() {
    
    
        console.log('Hi!');
    }
}

const Jack = new Person();

console.log(Jack.name);
console.log(Jack.age);
console.log(Person.gender);

Jack.sayHello();
Person.sayHi();

2.コンストラクター

constructor()知られているコンストラクタ、コンストラクタは、ときに自動的に呼び出され、インスタンスオブジェクトがされて作成されました。

instanceメソッドでthisは、現在のオブジェクトインスタンスを表します
コンストラクターでは、現在のオブジェクトは新しく作成されたオブジェクトです
あなたはできるthis新しく作成されたオブジェクトにプロパティを追加します

class Dog {
    
    
    name: string;
    age: number;

    constructor(name: string, age: number) {
    
    
        this.name = name;
        this.age = age;
    }

    bark() {
    
    
        console.log(this.name);
    }
}

const dog = new Dog('小黑', 2);
const dog2 = new Dog('小白', 3);

dog.bark(); // 小黑
dog2.bark(); // 小白

3.継承

キーワードを使用してextends継承を実装する
子クラスには、親クラスのすべてのメソッドとプロパティが含まれます
親クラスにないサブクラスに属性とメソッドを追加できます
オーバーライド：親クラスと同じメソッドがサブクラスに追加され、サブクラスメソッドが親クラスメソッドをオーバーライドします
クラスのメソッドでは、super現在のクラスの親クラスを表します
サブクラスがコンストラクターをサブクラスに書き込む場合、コンストラクターはマニュアルで親クラスコンストラクターが呼び出される必要があります（super親を示します）

// 父类
class Animal {
    
    
    name: string;
    age: number;

    constructor(name: string, age: number) {
    
    
        this.name = name;
        this.age = age;
    }

    sayHello() {
    
    
        console.log('动物叫~');
    }
}

// 子类：狗
class Dog extends Animal {
    
    
    sayHello() {
    
    
        console.log('wang wang~');
        // super就表示当前类的父类
        super.sayHello();
    }
}

// 子类：猫
class Cat extends Animal {
    
    
    gender: string;

    constructor(name: string, age: number, gender: string) {
    
    
        // 手动调用父类的构造函数，参数为name, age
        super(name, age);
        this.gender = gender;
    }

    run() {
    
    
        console.log(`${
      
      this.name}在跑！`);
    }
    sayHello() {
    
    
        console.log('miao miao~');
    }
}

const dog = new Dog('柯基', 2);
const cat = new Cat('布偶', 4, '雌');

dog.sayHello();
// wang wang~
// 动物叫~

console.log(cat); // Cat { name: '布偶', age: 4, gender: '雌' }
cat.run(); // 布偶在跑！

4.抽象クラス、抽象メソッド

抽象クラスのabstract始まりを分類するには
抽象クラスはオブジェクトの作成には使用できません。継承されたクラスとして設計されています。
抽象メソッドは抽象クラスに追加できます。abstract最初は、メソッド本体はありません。
抽象メソッドは抽象クラスまたはインターフェイスでのみ定義でき、サブクラスは抽象メソッドをオーバーライドする必要があります

abstract class Animal {
    
    
    name: string;

    constructor(name: string) {
    
    
        this.name = name;
    }
    abstract sayHello(): void;
}

class Dog extends Animal {
    
    
    age: number;

    constructor(name: string, age: number) {
    
    
        super(name);
        this.age = age;
    }
    sayHello() {
    
    
        console.log(`我是${
      
      this.name}`);
    }
}


const dog = new Dog('旺财', 2);
dog.sayHello(); // 我是旺财

5.インターフェース

インターフェイスはinterface、クラス構造を定義するために使用され、含める必要のある属性とメソッドを指定します
型宣言としても使用できます
インターフェイスのすべての属性に実際の値を設定することはできません。オブジェクトの構造のみが定義されます。
インターフェイスのすべてのメソッドは抽象メソッドです
クラスを定義するときに、クラスにインターフェイスを実装させることができます

class 类名 implements 接口名{}

// 定义接口
interface myInterface {
    
    
    name: string;
}

// 补充这个接口
interface myInterface {
    
    
    age: number;
    sayHello(): void;
}

class Person implements myInterface {
    
    
    name: string;
    age: number;
    constructor(name: string, age: number) {
    
    
        this.name = name;
        this.age = age;
    }
    sayHello() {
    
    
        console.log('Hello~');
    }
}

6.属性のカプセル化

属性修飾子

オブジェクトは本質的にプロパティとメソッドのコンテナであり、その主な機能はプロパティとメソッドを格納することです。これはいわゆるカプセル化です。クラスを定義するときに、属性の前に属性修飾子を追加できます。

public：パブリック属性、任意の場所でアクセス（変更）可能、デフォルト値
private：プライベート属性。クラス内でのみアクセス（変更）できますが、クラスメソッドの外部で使用できます。privateプロパティにアクセスします。
protected：現在のクラスおよび現在のクラスのサブクラスでのみアクセスできる保護された属性（変更）

あなたは直接定義することができます属性でコンストラクタを、両端で次のコードは同等。

class Person {
    
    
    name: string;
    age: number;
    constructor(name: string, age: number) {
    
    
        this.name = name;
        this.age = age;
    }
}

class Person {
    
    
    constructor(public name: string, public age: number) {
    
     }
}
// public不能忘记

属性アクセサー

任意に変更したくない一部の属性については、次のように設定できます。private
に直接設定するprivateと、オブジェクトを介してそのプロパティを変更できなくなります。
私たちは、セットを定義することができますのための方法を読み、設定プロパティをクラスに。読み取りまたはセットのプロパティプロパティはと呼ばれ、プロパティアクセサを。
属性を読み取る方法をメソッドと呼びsetter、属性を設定するgetter方法をメソッドと呼びます。

class Person {
    
    
    private age: number;
    constructor(_age: number) {
    
    
        this.age = _age;
    }
    get _age() {
    
    
        return this.age;
    }
    set _age(value) {
    
    
        if (value > 0) {
    
    
            this.age = value;
        }
    }
}

const Tom = new Person(12);
// “age”为私有属性，只能在类“Person”中访问
// 所以访问的是 _age
Tom._age = 18; // 可以更改
console.log(Tom._age); // 18
Tom._age = -18; // 不满足条件，无法更改
console.log(Tom._age); //  18

7.ジェネリック

関数またはクラスを定義するときに、型が明確でない場合はジェネリックを使用できます。

function fn<T>(a: T): T {
    
    
    return a;
}

// 可以直接调用具有泛型的函数
let result = fn(10); // 不指定泛型，TS可以自动对类型进行推断
let result2 = fn<string>('hello'); // 指定泛型

// 泛型可以同时指定多个
function fn<T, K>(a: T, b: K): T {
    
    
    console.log(b);
    return a;
}
fn<number, string>(123, 'hello');

// 定义类时可以使用泛型
class MyClass<T>{
    
    
    name: T;
    constructor(name: T) {
    
    
        this.name = name;
    }
}
const Person = new MyClass<string>('Jack');

interface Inter {
    
    
    length: number;
}

// T extends Inter 表示泛型T必须是Inter实现类（子类）
function fn<T extends Inter>(a: T): number {
    
    
    return a.length;
}

TypeScriptオブジェクト指向学習