TypeScriptで抽象クラスを完全理解！実用例10選でプロへの道を切り開く

// 抽象クラスの定義
abstract class 動物 {
    // 抽象メソッド
    abstract 鳴く(): void;
}

// 犬クラスの定義
class 犬 extends 動物 {
    鳴く() {
        console.log("ワンワン");
    }
}

const ポチ = new 犬();
ポチ.鳴く();  // 出力結果: ワンワン

abstract class Animal {
    name: string;

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

    // 抽象メソッドの定義
    abstract speak(): string;
}

class Dog extends Animal {
    speak(): string {
        return "ワンワン";
    }
}

class Cat extends Animal {
    speak(): string {
        return "ニャーニャー";
    }
}

const dog = new Dog("ポチ");
console.log(`${dog.name}の鳴き声: ${dog.speak()}`);

const cat = new Cat("たま");
console.log(`${cat.name}の鳴き声: ${cat.speak()}`);

abstract class Car {
    abstract startEngine(): void;
    abstract stopEngine(): void;
}

class Toyota extends Car {
    startEngine() {
        console.log("トヨタのエンジンが始動します");
    }
    stopEngine() {
        console.log("トヨタのエンジンが停止します");
    }
}

const myCar = new Toyota();
myCar.startEngine(); // トヨタのエンジンが始動します
myCar.stopEngine();  // トヨタのエンジンが停止します

abstract class Animal {
    // 抽象メソッド：speak
    abstract speak(): string;
}

// Dogクラス：Animalクラスを継承
class Dog extends Animal {
    speak(): string {
        return 'ワンワン';
    }
}

// Catクラス：Animalクラスを継承
class Cat extends Animal {
    speak(): string {
        return 'ニャー';
    }
}

const dog = new Dog();
const cat = new Cat();
console.log(dog.speak()); // ワンワン
console.log(cat.speak()); // ニャー

// 抽象クラス「Animal」を定義
abstract class Animal {
    // 抽象クラス内でプロパティを定義
    name: string;

    // コンストラクターで名前を初期化
    constructor(name: string) {
        this.name = name;
    }

    // 抽象メソッドの定義
    abstract makeSound(): void;
}

// 「Dog」クラスを定義し、抽象クラス「Animal」を継承
class Dog extends Animal {
    // 「makeSound」メソッドを実装
    makeSound(): void {
        console.log(`${this.name}はワンワンと鳴く`);
    }
}

// 「Dog」クラスのインスタンスを作成
const myDog = new Dog("ポチ");
myDog.makeSound(); // 出力結果として、"ポチはワンワンと鳴く"が表示される。

abstract class Bird {
    // 「protected」キーワードを使用してプロパティを定義
    protected featherColor: string;

    constructor(featherColor: string) {
        this.featherColor = featherColor;
    }

    abstract fly(): void;
}

class Sparrow extends Bird {
    fly(): void {
        console.log(`このすずめは${this.featherColor}色の羽で飛ぶ`);
    }
}

const mySparrow = new Sparrow("茶");
mySparrow.fly(); // 出力結果として、「このすずめは茶色の羽で飛ぶ」と表示される。

// 動物の振る舞いを定義するインターフェース
interface IAnimalBehavior {
    eat(): void;
    sleep(): void;
}

// 抽象クラスAnimalを作成し、IAnimalBehaviorインターフェースを実装
abstract class Animal implements IAnimalBehavior {
    // 具体的な振る舞いの実装はサブクラスに委ねる
    abstract eat(): void;
    sleep(): void {
        console.log('眠る');
    }
}

// 犬クラス
class Dog extends Animal {
    eat(): void {
        console.log('ドッグフードを食べる');
    }
}

// 犬クラスのインスタンスを作成
const myDog = new Dog();
myDog.eat();  // ドッグフードを食べる
myDog.sleep(); // 眠る

// 抽象クラス1: 飛ぶ能力を持つ生物
abstract class Flyable {
    abstract fly(): void;
}

// 抽象クラス2: 歩く能力を持つ生物
abstract class Walkable {
    abstract walk(): void;
}

// ミックスイン関数
function mix<T, U>(C1: T, C2: U): T & U {
    return {...C1.prototype, ...C2.prototype} as T & U;
}

// 具体的なクラス：ペンギン
class Penguin {
    swim() {
        console.log("ペンギンは泳ぐ");
    }
}

// ペンギンに飛ぶ能力と歩く能力をミックスイン
interface Penguin extends Flyable, Walkable {}

mix(Penguin.prototype, Flyable.prototype);
mix(Penguin.prototype, Walkable.prototype);

Penguin.prototype.fly = function() {
    console.log("ペンギンは飛べない");
}

Penguin.prototype.walk = function() {
    console.log("ペンギンは歩く");
}

const penguin = new Penguin();
penguin.swim();
penguin.fly();
penguin.walk();

// 抽象クラスとジェネリックを組み合わせる例
abstract class AbstractData<T> {
    // データを格納するための配列
    protected data: T[] = [];

    // データを追加するための抽象メソッド
    abstract add(item: T): void;

    // データを取得するメソッド
    getData(): T[] {
        return this.data;
    }
}

// 抽象クラスを継承し、ジェネリックを具体的な型で特化
class StringData extends AbstractData<string> {
    // 抽象メソッドの実装
    add(item: string): void {
        this.data.push(item.toUpperCase());
    }
}

// 抽象クラスの定義
abstract class Animal {
    // 公開されたプロパティ（どこからでもアクセス可能）
    public name: string;

    // 保護されたプロパティ（このクラスとサブクラスからアクセス可能）
    protected age: number;

    // 非公開プロパティ（このクラスからのみアクセス可能）
    private isHungry: boolean;

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

    // 抽象メソッド
    abstract makeSound(): void;

    // このクラスの中でのみアクセスできるメソッド
    private checkHunger(): boolean {
        return this.isHungry;
    }

    // 公開されたメソッド
    public feed(): void {
        if (this.checkHunger()) {
            console.log(`${this.name}は食事をしました。`);
            this.isHungry = false;
        } else {
            console.log(`${this.name}は食事を必要としていません。`);
        }
    }
}

class Dog extends Animal {
    makeSound(): void {
        console.log("ワンワン！");
    }
}

const myDog = new Dog("ポチ", 3);
myDog.makeSound();
myDog.feed();

ワンワン！
ポチは食事をしました。

// 抽象クラスの定義
abstract class AbstractClass {
    // 抽象プロパティの定義
    abstract prop: string;

    // 静的メソッドの定義
    static showClassName() {
        return "AbstractClass";
    }
}

// 派生クラスの定義
class DerivedClass extends AbstractClass {
    prop = "DerivedClassProperty";

    // 派生クラス独自の静的メソッド
    static showDerivedClassName() {
        return "DerivedClass";
    }
}

// 静的メソッドの呼び出し例
console.log(AbstractClass.showClassName()); // AbstractClassを表示
console.log(DerivedClass.showClassName());  // AbstractClassを表示
console.log(DerivedClass.showDerivedClassName()); // DerivedClassを表示

abstract class AbstractConfig {
    abstract defaultSetting: string;

    static getDefaultConfig() {
        return "Default Config of Abstract";
    }
}

class DerivedConfigA extends AbstractConfig {
    defaultSetting = "ConfigA";

    static getDefaultConfig() {
        return "Default Config of DerivedA";
    }
}

class DerivedConfigB extends AbstractConfig {
    defaultSetting = "ConfigB";
}

console.log(DerivedConfigA.getDefaultConfig()); // Default Config of DerivedAを表示
console.log(DerivedConfigB.getDefaultConfig()); // Default Config of Abstractを表示

// 抽象クラス: 商品
abstract class Product {
    constructor(protected name: string, protected price: number) {}

    // 抽象メソッド: 商品の詳細を取得
    abstract getDetails(): string;

    // 価格を取得するメソッド
    getPrice(): number {
        return this.price;
    }
}

// 本のクラス
class Book extends Product {
    constructor(name: string, price: number, private author: string) {
        super(name, price);
    }

    // 商品の詳細を取得
    getDetails(): string {
        return `${this.name} は、${this.author} 著で、価格は ${this.price} 円です。`;
    }
}

// 家電のクラス
class Appliance extends Product {
    constructor(name: string, price: number, private brand: string) {
        super(name, price);
    }

    // 商品の詳細を取得
    getDetails(): string {
        return `${this.name} は、${this.brand} のブランドで、価格は ${this.price} 円です。`;
    }
}

const book = new Book("TypeScript入門", 3000, "田中太郎");
console.log(book.getDetails());  // 実行すると「TypeScript入門 は、田中太郎 著で、価格は 3000 円です。」と表示されます。

const appliance = new Appliance("エアコン", 25000, "ダイキン");
console.log(appliance.getDetails());  // 実行すると「エアコン は、ダイキン のブランドで、価格は 25000 円です。」と表示されます。

abstract class AbstractClass {
    abstract abstractMethod(): void;

    // このメソッドは具体的な実装を持つことができません
    abstract implementedMethod() {
        console.log("Implemented in abstract class");
    }
}

abstract class AbstractClass {
    abstract sayHello(): void;
}

// 以下のコードはエラーとなります
const instance = new AbstractClass();

abstract class AbstractClass {
    abstract sayHello(): void;
}

class ConcreteClass extends AbstractClass {
    sayHello() {
        console.log("Hello from ConcreteClass!");
    }
}

const instance = new ConcreteClass();
instance.sayHello(); // "Hello from ConcreteClass!" と出力されます

abstract class AbstractBase {
    abstract sayHello(): string;

    printMessage() {
        console.log(this.sayHello() + "、これはカスタマイズされたメッセージです！");
    }
}

class ConcreteClass extends AbstractBase {
    sayHello(): string {
        return "こんにちは";
    }
}

const example = new ConcreteClass();
example.printMessage();

abstract class ExpandableAbstractBase {
    abstract basicMethod(): void;

    // 拡張用のメソッド
    extensionPoint() {
        // デフォルトの処理
    }
}

class ExtendedClass extends ExpandableAbstractBase {
    basicMethod(): void {
        console.log("基本的な処理");
    }

    extensionPoint() {
        console.log("独自の拡張処理");
    }
}

const example2 = new ExtendedClass();
example2.basicMethod();
example2.extensionPoint();

abstract class AbstractCalculator {
    abstract calculate(a: number, b: number): number;
}

class AdvancedCalculator extends AbstractCalculator {
    calculate(a: number, b: number): number {
        return a * b;
    }

    // 新しい計算機能の追加
    power(a: number, exponent: number): number {
        return Math.pow(a, exponent);
    }
}

const calculator = new AdvancedCalculator();
console.log(calculator.calculate(3, 4));
console.log(calculator.power(2, 3));