９．Javaのオブジェクト指向プログラミングの基本

オブジェクト指向プログラミング（OOP）は、Javaのコアコンセプトの一つであり、プログラムを現実世界のオブジェクトをモデルにして設計することを可能にします。OOPを理解することは、Javaプログラミングで効率的かつ再利用可能なコードを書くために非常に重要です。この記事では、OOPの基本概念、Javaにおけるその実装方法、および実際の例を使って詳細に説明します。

オブジェクト指向プログラミングの4つの基本原則

OOPは、次の4つの基本原則に基づいています：

• カプセル化（Encapsulation）
• 継承（Inheritance）
• ポリモーフィズム（Polymorphism）
• 抽象化（Abstraction）

これらの概念を理解することで、Javaでのオブジェクト指向設計がより効果的になります。それでは、一つ一つの概念を掘り下げていきます。

1. カプセル化（Encapsulation）

カプセル化は、データ（フィールド）とそのデータに対する操作（メソッド）を一つの単位であるクラスにまとめることを指します。また、フィールドを直接公開せず、メソッドを通じてアクセスすることで、データを保護し外部からの不正な変更を防ぎます。カプセル化により、オブジェクトの内部状態を制御し、プログラムの保守性を向上させることができます。

class Account {
    private String owner;
    private double balance;

    public Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println(owner + "のアカウントに" + amount + "円入金されました。現在の残高: " + balance + "円");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println(owner + "のアカウントから" + amount + "円引き出されました。現在の残高: " + balance + "円");
        } else {
            System.out.println("引き出しできません。残高不足です。");
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account account = new Account("Taro", 5000);
        account.deposit(2000);  // 出力: Taroのアカウントに2000円入金されました。現在の残高: 7000円
        account.withdraw(3000); // 出力: Taroのアカウントから3000円引き出されました。現在の残高: 4000円
        account.withdraw(5000); // 出力: 引き出しできません。残高不足です。
    }
}

上記の例では、`Account`クラスのフィールド`owner`と`balance`は`private`に設定されており、直接アクセスすることはできません。代わりに、`deposit`や`withdraw`メソッドを通じて、これらのフィールドを操作します。これにより、外部からの不正なアクセスを防ぎつつ、フィールドの値を安全に変更することができます。

2. 継承（Inheritance）

継承は、既存のクラス（親クラス）を基にして、新しいクラス（子クラス）を作成する仕組みです。子クラスは、親クラスのフィールドやメソッドを引き継ぎ、さらに独自の機能を追加することができます。これにより、コードの再利用性が高まり、プログラムの開発効率が向上します。

class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void sound() {
        System.out.println(name + " is making a sound.");
    }
}

class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    public void sound() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal("Animal");
        animal.sound();  // 出力: Animal is making a sound.

        Dog dog = new Dog("Pochi");
        dog.sound();  // 出力: Pochi is barking.
    }
}

ここでは、`Animal`クラスを親クラスとして`Dog`クラスを定義しています。`Dog`クラスは`Animal`クラスを継承し、`sound`メソッドをオーバーライドして独自の動作を定義しています。このように、継承を使うことでコードの再利用が容易になり、子クラスが親クラスの機能を引き継ぎつつも、独自の振る舞いを持つことが可能です。

3. ポリモーフィズム（Polymorphism）

ポリモーフィズム（多態性）は、同じメソッド呼び出しが異なるクラスで異なる振る舞いをすることを指します。Javaでは、親クラスの型の変数で子クラスのオブジェクトを参照することができ、オーバーライドされたメソッドを実行することができます。これにより、動的なメソッドの呼び出しが可能となり、柔軟なプログラム設計が実現します。

class Bird {
    public void fly() {
        System.out.println("Bird is flying.");
    }
}

class Sparrow extends Bird {
    public void fly() {
        System.out.println("Sparrow is flying swiftly.");
    }
}

class Eagle extends Bird {
    public void fly() {
        System.out.println("Eagle is soaring high.");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird myBird = new Sparrow();
        myBird.fly();  // 出力: Sparrow is flying swiftly.

        myBird = new Eagle();
        myBird.fly();  // 出力: Eagle is soaring high.
    }
}

この例では、`Bird`クラスを親クラスとして`Sparrow`と`Eagle`がそれぞれ異なる動作をオーバーライドしています。`myBird`変数は親クラスの`Bird`型ですが、実行時にはそれが`Sparrow`や`Eagle`のインスタンスであることが動的に決定され、対応するメソッドが呼び出されます。これがポリモーフィズムの基本的な使い方です。

4. 抽象化（Abstraction）

抽象化は、オブジェクトの複雑さを隠し、必要な機能だけを公開する手法です。Javaでは、抽象クラスやインターフェースを使用して、具体的な実装を隠し、クライアントコードに必要な操作のみを提供します。これにより、クラスの設計がより柔軟でモジュール化されたものになります。

abstract class Vehicle {
    abstract void start();

    public void stop() {
        System.out.println("Vehicle stopped.");
    }
}

class Car extends Vehicle {
    public void start() {
        System.out.println("Car started.");
    }
}

class Bike extends Vehicle {
    public void start() {
        System.out.println("Bike started.");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        car.start();  // 出力: Car started.
        car.stop();   // 出力: Vehicle stopped.

        Vehicle bike = new Bike();
        bike.start(); // 出力: Bike started.
        bike.stop();  // 出力: Vehicle stopped.
    }
}

この例では、`Vehicle`は抽象クラスであり、`start`メソッドを抽象メソッドとして定義しています。`Car`や`Bike`クラスはそれぞれ`Vehicle`を継承し、`start`メソッドを具体的に実装しています。抽象化を使うことで、複数のクラスで共通のインターフェースを定義しながら、具体的な実装を各クラスで提供することができます。

まとめ

オブジェクト指向プログラミング（OOP）は、Javaプログラミングの基礎であり、効率的なコードの設計と管理を可能にします。カプセル化、継承、ポリモーフィズム、抽象化といったOOPの原則を理解し、適切に活用することで、再利用可能で保守しやすいコードを作成できます。この記事では、これらの概念を実際のコード例とともに解説しましたが、実際に手を動かしてこれらの原則を適用することで、より深く理解することができます。