MENU
  1. ホーム
  2. PHP
  3. PHPでpublic, private, protectedを活用した柔軟なクラス設計方法

PHPでpublic, private, protectedを活用した柔軟なクラス設計方法

PHP

PHPにおけるクラス設計では、アクセス修飾子であるpublic、private、protectedをうまく使い分けることで、オブジェクト指向プログラミングのメリットを最大限に引き出すことができます。これらの修飾子は、クラス内部のプロパティやメソッドへのアクセス範囲を制御するものであり、コードの安全性や可読性を向上させ、保守性の高いプログラムを作成するために非常に重要です。本記事では、それぞれのアクセス修飾子の使い方や利点、さらにはそれらを効果的に組み合わせて柔軟なクラス設計を行う方法について詳しく解説します。

目次

PHPにおけるアクセス修飾子とは

アクセス修飾子は、クラス内のプロパティやメソッドに対するアクセス範囲を制限するために使用されるキーワードです。PHPでは主に「public」、「private」、「protected」の3種類のアクセス修飾子が用意されており、それぞれ異なるレベルでアクセス制御を行います。

public

publicは、クラスの外部からでも自由にアクセス可能なメンバーを定義するための修飾子です。これにより、他のクラスやスクリプトから直接プロパティやメソッドを呼び出すことができます。

private

privateは、同じクラス内でのみアクセス可能なメンバーを定義します。クラスの外部から、あるいは継承したクラスからもアクセスすることができません。これにより、特定のデータや処理を外部に公開せずにカプセル化することが可能です。

protected

protectedは、同じクラスおよびその継承クラス内でのみアクセス可能なメンバーを定義します。これにより、継承関係にあるクラス内で共有されるメンバーを安全に制御できます。

これらのアクセス修飾子を適切に使い分けることで、クラスのカプセル化や継承を効果的に実現することができ、コードの安全性や拡張性が向上します。

publicの使用シーン

publicは、クラスの外部から直接アクセスする必要があるプロパティやメソッドに使用されます。これは、クラス外部のコードや他のオブジェクトから頻繁に呼び出される機能を提供する場合に便利です。例えば、ユーザー入力を受け取って処理を行うメソッドや、オブジェクトの状態を読み書きするためのプロパティにpublicが適用されます。

外部からのアクセスが必要なメソッド

クラスの外部からメソッドを呼び出すケースでは、publicが必要です。例えば、次のようなクラスを考えてみましょう。

class User {
    public $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

この例では、ユーザーの名前を設定し、取得するためにsetNameとgetNameメソッドがpublicとして定義されています。外部から自由にこれらのメソッドを呼び出すことで、クラスのプロパティを安全に操作することができます。

オブジェクトの状態を操作するためのプロパティ

外部から直接アクセスが必要なプロパティにもpublicが使用されます。例えば、次のような例では、$nameプロパティがpublicとして宣言されているため、クラス外部から直接アクセスして値を設定できます。

$user = new User();
$user->name = "John";  // publicプロパティに直接アクセス
echo $user->getName();  // "John"が出力される

publicを利用することで、外部から自由にアクセスできる部分と、クラス内部で保護される部分を明確に区別することが可能です。

privateの使用シーン

privateは、クラスの外部から直接アクセスさせたくないプロパティやメソッドに使用されます。これは、外部からの変更を防ぎ、クラス内でデータや動作を安全に管理するための手法です。特定のデータやロジックをカプセル化して隠蔽し、クラスの使用者に必要最低限のインターフェースだけを公開することで、クラスの安全性や可読性が向上します。

データの隠蔽

privateは、オブジェクトの内部状態を保護するために使用されます。直接的な変更を防ぎ、代わりにpublicなメソッドを通じて値の操作を行うことで、データの一貫性を保ちます。次の例では、$passwordプロパティが外部から直接変更されるのを防ぐために、privateとして宣言されています。

class User {
    private $password;

    public function setPassword($password) {
        // パスワードの長さや形式を検証
        if(strlen($password) > 6) {
            $this->password = $password;
        }
    }

    public function getPassword() {
        // セキュリティ上の理由で、通常パスワードは公開しない
        return "パスワードは非公開です。";
    }
}

この場合、パスワードはクラス外部から直接操作できません。値を設定する際には、setPasswordメソッドを通じて、バリデーションやその他の処理を行った後にのみ$passwordを設定できるため、データの整合性が保たれます。

内部処理のカプセル化

privateは、クラスの内部処理をカプセル化するためにも使用されます。これにより、クラスの動作を外部から干渉されることなく管理することが可能になります。次の例では、内部処理を行うメソッドがprivateとして宣言されています。

class Calculator {
    private function calculate($a, $b) {
        return $a + $b;
    }

    public function getResult($a, $b) {
        return $this->calculate($a, $b);  // 外部からはcalculateメソッドに直接アクセスできない
    }
}

calculateメソッドはprivateであるため、外部から直接呼び出すことができません。publicなメソッドであるgetResultを介して、計算結果を取得することができる仕組みです。このように、内部ロジックを保護することで、クラスの一貫性と安全性を保ちます。

privateを適切に利用することで、外部からアクセスできる部分と、クラス内部に隠すべき部分を明確に分け、堅牢なコード設計を実現します。

protectedの使用シーン

protectedは、クラス内およびその継承クラスでのみアクセスできるプロパティやメソッドに使用されます。これにより、継承によって拡張されたクラスが、親クラスの内部状態や処理にアクセスできる一方で、外部からの直接アクセスは制限されるという、カプセル化と柔軟な拡張性の両立が可能になります。

継承クラスでの再利用

protectedは、親クラス内で定義されたメンバーが、継承された子クラス内で再利用される場合に役立ちます。次の例では、親クラスAnimalのprotectedプロパティとメソッドが、子クラスDogで利用されています。

class Animal {
    protected $species;

    protected function setSpecies($species) {
        $this->species = $species;
    }

    public function getSpecies() {
        return $this->species;
    }
}

class Dog extends Animal {
    public function __construct() {
        $this->setSpecies("Canine");  // 親クラスのprotectedメソッドにアクセス可能
    }
}

$dog = new Dog();
echo $dog->getSpecies();  // "Canine"が出力される

この例では、AnimalクラスのsetSpeciesメソッドと$speciesプロパティがprotectedとして定義されています。そのため、子クラスのDogからはこれらにアクセス可能ですが、クラスの外部から直接アクセスすることはできません。

親クラスの処理を強化する

protectedメンバーを持つ親クラスを継承することで、子クラスが親クラスの機能を拡張する際に、親クラスの内部機能を再利用できます。以下の例では、親クラスで定義されたprotectedメソッドを使って、子クラスが特定の処理を強化しています。

class Vehicle {
    protected function startEngine() {
        return "Engine started";
    }
}

class Car extends Vehicle {
    public function drive() {
        return $this->startEngine() . " and driving!";
    }
}

$car = new Car();
echo $car->drive();  // "Engine started and driving!"が出力される

このように、protectedメソッドstartEngineは、子クラスCarでアクセス可能ですが、外部から直接呼び出すことはできません。この設計により、親クラスのロジックを安全に保持しつつ、子クラスで柔軟に拡張できます。

カプセル化を保ちながらの拡張

protectedを使うことで、クラスの内部構造を継承クラス内で共有しながら、外部からのアクセスを制限できます。これは、クラスのカプセル化を維持しつつも、クラス階層全体でデータや処理を効率的に再利用できる設計を可能にします。

このように、protectedを適切に利用することで、クラスの拡張性を高めながらも、安全で整ったコード設計が実現できます。

アクセス修飾子の混在による設計の柔軟性

PHPのクラス設計では、public、private、protectedのアクセス修飾子を適切に組み合わせることで、非常に柔軟かつ安全なプログラムを構築できます。それぞれの修飾子には特定の役割があり、これらを併用することでクラスのカプセル化を維持しながら、必要な部分だけを外部に公開したり、継承クラスで再利用できる構造を実現します。この設計の柔軟性により、拡張性と安全性を両立したコードを書くことが可能になります。

公開部分と非公開部分の明確な分離

public、private、protectedを併用することで、クラスの外部に公開する必要のある部分と、内部で保護すべき部分を明確に分離できます。例えば、次のようなクラスを考えてみましょう。

class BankAccount {
    private $balance;
    protected $accountNumber;
    public $ownerName;

    public function __construct($ownerName, $accountNumber) {
        $this->ownerName = $ownerName;
        $this->accountNumber = $accountNumber;
        $this->balance = 0;
    }

    public function deposit($amount) {
        $this->balance += $amount;
    }

    public function getBalance() {
        return $this->balance;
    }

    protected function generateAccountStatement() {
        return "Account No: $this->accountNumber, Balance: $this->balance";
    }
}

この例では、balanceがprivateとして設定され、外部から直接操作できないように保護されています。一方で、ownerNameはpublicとして宣言されており、外部から自由にアクセス可能です。さらに、accountNumberはprotectedとして定義されており、継承クラス内でのみアクセス可能です。このように、公開するべき情報と保護する情報を柔軟に制御できます。

セキュリティとデータ保護の向上

privateを使用して、外部から操作されてはいけないデータや処理を厳密に隠蔽することで、セキュリティを向上させます。たとえば、銀行口座の残高やパスワードのような重要なデータをprivateとして設定し、外部から直接変更できないようにすることで、データの整合性や安全性を確保できます。

一方で、protectedを利用することで、親クラスと子クラス間で内部のデータやロジックを安全に共有できます。例えば、銀行口座のステートメントを生成する機能を子クラスに継承させつつ、外部には公開しないといったケースが考えられます。

柔軟なクラス拡張が可能

protectedメンバーは、クラスを継承する際に特に役立ちます。子クラスが親クラスの重要なデータやメソッドにアクセスできるため、親クラスの機能を拡張することが容易です。これにより、既存のクラスを拡張しながら、新たな機能を追加したり、動作をカスタマイズしたりすることができます。

例えば、次の例では、BankAccountクラスを継承したSavingsAccountクラスが、親クラスのprotectedメンバーを利用して独自の機能を追加しています。

class SavingsAccount extends BankAccount {
    public function getAccountStatement() {
        return $this->generateAccountStatement();
    }
}

このように、アクセス修飾子を混在させて利用することで、外部への公開範囲を制御しつつ、内部での再利用や拡張を柔軟に行うことができ、セキュリティと利便性のバランスを取った設計が可能になります。

クラスのカプセル化を実現する設計パターン

カプセル化は、オブジェクト指向プログラミングの重要な概念であり、クラスの内部データやメソッドを外部から隠し、必要な部分だけを公開することで、クラスの安全性と保守性を向上させます。PHPでは、アクセス修飾子であるprivateやprotectedを使用してカプセル化を実現し、publicメソッドを介して必要なインターフェースだけを外部に提供する設計パターンが広く用いられています。

アクセサメソッドによるデータの安全な操作

カプセル化を実現するための最も基本的な手法は、プロパティに直接アクセスさせずに、publicなアクセサメソッド（ゲッターとセッター）を通じてデータを操作することです。これにより、プロパティの値が不正に変更されることを防ぎ、データの整合性を保つことができます。

例えば、次のクラスでは、$balanceプロパティがprivateとしてカプセル化され、外部からの直接アクセスを禁止しています。一方、publicなメソッドgetBalanceとdepositを使って、安全にデータの操作が行えます。

class BankAccount {
    private $balance;

    public function __construct() {
        $this->balance = 0;
    }

    public function deposit($amount) {
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

    public function getBalance() {
        return $this->balance;
    }
}

このように、privateプロパティに直接アクセスさせず、適切なバリデーションを含むメソッドを介して操作することで、データの保護と適切な管理が行われます。

カプセル化による内部ロジックの保護

カプセル化は、単にデータを保護するだけでなく、内部の複雑なロジックを隠蔽する役割も果たします。これにより、クラスの利用者は、内部の詳細に依存せずに、公開されているメソッドだけを使って機能を利用できるため、クラスの変更があった場合でも外部に影響を与えずに改良を行うことができます。

例えば、次の例では、内部で行われる計算処理がprivateメソッドにカプセル化され、外部から直接呼び出すことはできませんが、publicメソッドを通じて結果だけを利用することができます。

class DiscountCalculator {
    private $rate = 0.1;

    private function calculateDiscount($amount) {
        return $amount * $this->rate;
    }

    public function getFinalAmount($amount) {
        $discount = $this->calculateDiscount($amount);
        return $amount - $discount;
    }
}

この設計では、calculateDiscountメソッドはクラス内部でのみ利用され、外部からは結果を取得するgetFinalAmountメソッドが公開されています。これにより、内部ロジックの変更があった場合でも、クラスの利用者はその影響を受けずにコードを使用し続けることができます。

カプセル化による拡張性の向上

カプセル化は、クラスの拡張性を高める役割も持っています。クラス内部の実装が外部に影響しないため、内部のロジックやデータ構造を変更する際に、既存のコードとの互換性を保ちながら新機能を追加することができます。

たとえば、次の例では、カプセル化されたメソッドを利用して新しい機能を追加できますが、外部に公開されているメソッドのインターフェースはそのまま維持されています。

class EnhancedDiscountCalculator extends DiscountCalculator {
    private $additionalDiscountRate = 0.05;

    public function getFinalAmount($amount) {
        $baseAmount = parent::getFinalAmount($amount);
        $additionalDiscount = $baseAmount * $this->additionalDiscountRate;
        return $baseAmount - $additionalDiscount;
    }
}

このように、カプセル化によってクラスの内部構造を保護することで、既存のコードに影響を与えることなく、柔軟に機能を拡張できます。

カプセル化は、クラスの設計を堅牢かつ保守しやすいものにし、拡張や変更を行う際にも安定した動作を保証するために欠かせない概念です。適切なアクセス修飾子を用いて、データやロジックの隠蔽を実現することで、クラスの利用者にとって信頼性の高いインターフェースを提供できます。

継承とアクセス修飾子の関係

PHPにおける継承は、既存のクラス（親クラス）の機能をそのまま利用しつつ、追加の機能や変更を加えたクラス（子クラス）を作成する手法です。このとき、public、private、protectedといったアクセス修飾子が重要な役割を果たします。特に、protectedは、親クラスのプロパティやメソッドを子クラスに引き継ぎ、内部的に共有できる設計を可能にします。一方で、privateメンバーは継承されても子クラスからは直接アクセスできません。

publicと継承

publicなプロパティやメソッドは、親クラスから継承され、子クラスでもそのまま利用できます。publicメンバーは、クラスの外部からもアクセス可能であるため、継承後も外部から直接呼び出すことができます。次の例では、親クラスVehicleのpublicメソッドが子クラスCarでも利用可能です。

class Vehicle {
    public function start() {
        return "Vehicle started";
    }
}

class Car extends Vehicle {
    public function drive() {
        return $this->start() . " and driving!";
    }
}

$car = new Car();
echo $car->drive();  // "Vehicle started and driving!"が出力される

この例では、Vehicleクラスのpublicメソッドstartが、Carクラスでもそのまま使用されています。

protectedと継承

protectedなプロパティやメソッドは、親クラスから子クラスに継承されますが、クラスの外部からはアクセスできません。これにより、クラス内または継承関係のあるクラス内でのみ、プロパティやメソッドを操作できるようにすることが可能です。次の例では、Animalクラスのprotectedメソッドが、子クラスDogで使用されています。

class Animal {
    protected $type = "Mammal";

    protected function getType() {
        return $this->type;
    }
}

class Dog extends Animal {
    public function describe() {
        return "This is a " . $this->getType();
    }
}

$dog = new Dog();
echo $dog->describe();  // "This is a Mammal"が出力される

この例では、AnimalクラスのprotectedメソッドgetTypeが、子クラスDog内で利用されていますが、外部から直接呼び出すことはできません。この設計により、親クラスの内部データを保護しながら、子クラスでそれを利用した機能拡張が可能になります。

privateと継承

privateなプロパティやメソッドは、親クラスから子クラスには継承されますが、子クラスから直接アクセスすることはできません。privateメンバーは、親クラスの内部でのみ使用でき、クラスの外部や継承クラスからは完全に隠されています。例えば、次のコードでは、親クラスPersonのprivateメソッドは子クラスEmployeeでは利用できません。

class Person {
    private $name = "John";

    private function getName() {
        return $this->name;
    }
}

class Employee extends Person {
    public function showName() {
        // return $this->getName();  // エラーになる
        return "Access denied";
    }
}

$employee = new Employee();
echo $employee->showName();  // "Access denied"が出力される

この例では、PersonクラスのprivateメソッドgetNameは、Employeeクラスでアクセスできません。privateは親クラス内でのみにアクセスが許されるため、子クラスでの再利用が制限されます。

protectedによる柔軟な継承設計

protectedを利用することで、親クラスの内部構造をある程度保護しながらも、子クラスでそれを利用し、拡張できるという柔軟な設計が可能になります。例えば、親クラスで重要なデータをprotectedとして管理し、子クラスでそれを加工・利用する場合に非常に便利です。

class BankAccount {
    protected $balance = 1000;

    protected function getBalance() {
        return $this->balance;
    }
}

class SavingsAccount extends BankAccount {
    public function calculateInterest() {
        return $this->getBalance() * 0.05;  // 親クラスのprotectedメソッドにアクセス
    }
}

$account = new SavingsAccount();
echo $account->calculateInterest();  // 利子計算の結果が出力される

このように、protectedを利用すると、親クラスの重要なロジックを隠蔽しつつ、継承クラスでそのロジックを利用して新たな機能を作り出すことができます。

継承とアクセス修飾子を適切に組み合わせることで、クラス間の再利用性を高めつつ、外部への不必要な公開を防ぎ、安全かつ柔軟なコード設計を実現できます。

実践例：アクセス修飾子を活用したクラス設計

PHPのクラス設計において、public、private、protectedを適切に使い分けることで、柔軟かつ安全な設計が可能です。ここでは、アクセス修飾子を効果的に組み合わせた実践的なクラス設計の例を紹介します。これにより、データの保護、内部処理の隠蔽、そして拡張性を両立したコードをどのように構築できるかを理解することができます。

顧客情報管理システムの例

次の例では、顧客の個人情報を管理するシステムを構築しています。顧客の名前やメールアドレスは外部からアクセス可能ですが、顧客IDや内部処理に関する情報は保護されます。加えて、システム内部でしか必要ないメソッドやプロパティをカプセル化し、外部の干渉を防いでいます。

class Customer {
    private $customerId;
    protected $email;
    public $name;

    public function __construct($name, $email, $customerId) {
        $this->name = $name;
        $this->email = $email;
        $this->customerId = $customerId;
    }

    public function updateEmail($newEmail) {
        if ($this->validateEmail($newEmail)) {
            $this->email = $newEmail;
        }
    }

    public function getCustomerInfo() {
        return "Name: " . $this->name . ", Email: " . $this->email;
    }

    private function validateEmail($email) {
        return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
    }

    protected function getCustomerId() {
        return $this->customerId;
    }
}

この例では、Customerクラスの設計にアクセス修飾子が活用されています。

  • private $customerId: 顧客IDは外部から直接アクセスできないようにprivateとして定義されています。IDはシステム内部でのみ使用されるため、保護されています。
  • protected $email: メールアドレスは、将来的に他のクラス（例えば、メール送信クラス）が継承して使用できるようにprotectedとして定義されています。これにより、外部から直接アクセスされることを防ぎつつ、継承クラスで再利用可能です。
  • public $name: 顧客名は外部から自由にアクセス・更新可能な情報であるため、publicとして定義されています。

メール送信機能を拡張した例

このCustomerクラスを継承して、メール送信機能を持つクラスCustomerMailerを作成します。ここでは、protectedおよびprivateメンバーがどのように子クラスで利用されるかを示しています。

class CustomerMailer extends Customer {
    public function sendWelcomeEmail() {
        if ($this->email) {
            return "Welcome email sent to " . $this->email;
        }
        return "Email address not set.";
    }

    public function getCustomerDetails() {
        return "Customer ID: " . $this->getCustomerId() . ", Name: " . $this->name;
    }
}

$customer = new CustomerMailer("Alice", "alice@example.com", 12345);
echo $customer->getCustomerInfo();       // 顧客情報を表示
echo $customer->sendWelcomeEmail();      // メール送信機能を実行
echo $customer->getCustomerDetails();    // 顧客IDにアクセス（protectedメソッドを使用）

このCustomerMailerクラスでは、次のポイントが注目されます。

  • protectedメソッドgetCustomerId: このメソッドは親クラスCustomer内では外部に公開されていませんが、CustomerMailer内で利用することができ、顧客IDを取得できます。
  • publicメソッドsendWelcomeEmail: protectedとして定義されていた$emailを利用して、顧客に対してメールを送信する処理が実装されています。

設計のポイント

この実践例から、以下の設計ポイントが見えてきます。

  1. データの保護と操作の分離: privateとprotectedを使って、重要なデータ（顧客IDや内部のバリデーションロジック）をカプセル化し、外部からの直接アクセスを防ぎます。これにより、システムの重要な部分が意図せず改変されることを防止します。
  2. 柔軟な拡張性: protectedメンバーを使うことで、親クラスのロジックを安全に継承しつつ、必要に応じて機能を拡張できます。CustomerMailerクラスでは、Customerクラスの機能をそのまま利用しながら、新たなメール送信機能を追加しています。
  3. 内部ロジックの隠蔽: privateメソッドvalidateEmailのように、外部に見せる必要のない処理を内部に隠すことで、クラスの利用者が誤って重要な処理にアクセスすることを防ぎ、メンテナンス性を向上させています。

このように、アクセス修飾子を使ったクラス設計は、システムの安全性や保守性を高め、拡張に柔軟な構造を持つ堅牢なプログラムの基盤となります。

アクセス修飾子の間違った使い方と注意点

アクセス修飾子を使うことで、クラスのデータ保護や拡張性を高めることができますが、誤った使い方をすると、逆に設計が複雑になり、バグを生みやすくなります。ここでは、よくあるアクセス修飾子の間違った使い方や、それに伴う設計上の問題点について解説し、注意すべきポイントを紹介します。

publicの乱用による安全性の低下

publicを必要以上に多用することは、コードの安全性を損なう大きな原因となります。publicで宣言されたプロパティやメソッドは、クラスの外部から無制限にアクセス可能であるため、不注意な操作や予期しない変更が容易に行われてしまいます。特に、データの一貫性が重要なプロジェクトにおいては、publicプロパティに対する直接的なアクセスがバグの原因になることがあります。

例えば、次のコードはpublicプロパティを乱用した例です。

class Account {
    public $balance;
}

$account = new Account();
$account->balance = -1000;  // 意図しない値を簡単に設定できる

このように、publicプロパティを使うと、クラスの外部から意図しない値が設定される危険性があります。balanceプロパティは、通常、適切なバリデーションを通じてのみ変更されるべきですが、publicにすると制御が失われます。

解決策: データの一貫性や安全性が重要なプロパティには、privateやprotectedを使用し、publicメソッドを介して値を操作するようにします。

class Account {
    private $balance;

    public function setBalance($amount) {
        if ($amount >= 0) {
            $this->balance = $amount;
        }
    }

    public function getBalance() {
        return $this->balance;
    }
}

これにより、外部からの不正な操作を防ぎ、データの整合性を維持できます。

privateの過剰な使用による拡張性の欠如

privateを過剰に使用すると、クラスの内部構造が厳しく隠蔽されるため、継承によるクラスの拡張が難しくなることがあります。privateメンバーは親クラスからしかアクセスできないため、子クラスで必要な機能が利用できなくなることがあります。

例えば、次の例では、親クラスPersonのprivateプロパティが子クラスEmployeeで再利用できず、継承の利点が失われています。

class Person {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

class Employee extends Person {
    public function getName() {
        // return $this->name;  // エラー: privateなのでアクセス不可
        return "Access denied";
    }
}

このように、privateの過剰な使用は、コードの再利用性を制限する要因となります。

解決策: クラス内で重要なロジックやデータを隠蔽したいが、継承クラスでも再利用したい場合は、protectedを使用しましょう。これにより、クラスの外部からは隠蔽しつつ、子クラス内では利用可能な設計が可能です。

class Person {
    protected $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

class Employee extends Person {
    public function getName() {
        return $this->name;  // 継承クラスからアクセス可能
    }
}

protectedの誤用による意図しないアクセスの可能性

protectedを無闇に使うと、必要以上に親クラスの内部構造を公開してしまい、予期せぬバグを引き起こすことがあります。protectedメンバーは継承関係にあるクラス内でアクセス可能ですが、すべての子クラスがそれを利用する必要があるわけではありません。

例えば、以下のコードでは、protectedメンバーに対する不必要なアクセスが発生する可能性があります。

class Vehicle {
    protected $fuel = 100;

    public function useFuel($amount) {
        $this->fuel -= $amount;
    }
}

class ElectricCar extends Vehicle {
    public function chargeBattery() {
        $this->fuel += 50;  // 不自然な操作
    }
}

ElectricCarは本来燃料を使用しない車両ですが、protectedプロパティにアクセスできるため、不適切に燃料を操作してしまっています。

解決策: 継承クラスで必ず使用するわけではないプロパティやメソッドは、むしろprivateにして、親クラス内部に隠蔽し、必要に応じてpublicメソッドで制御するのが適切です。

まとめ

アクセス修飾子は、PHPのクラス設計において非常に強力なツールですが、誤った使い方をすると、コードの安全性や拡張性に悪影響を与えることがあります。publicの乱用はデータの安全性を低下させ、privateの過剰な使用は拡張性を損ないます。また、protectedの誤用は、意図しない操作を許してしまう危険性があります。各修飾子の特性を理解し、適切に使い分けることで、堅牢で柔軟なコード設計を実現しましょう。

応用：依存性注入とアクセス修飾子

依存性注入（Dependency Injection）は、ソフトウェア開発において広く用いられるデザインパターンの一つであり、オブジェクト間の依存関係を外部から注入することで、クラスの柔軟性やテストの容易さを向上させる手法です。アクセス修飾子を使うことで、依存性注入をより安全かつ効果的に行うことができます。ここでは、依存性注入とアクセス修飾子の活用方法を解説します。

依存性注入とは

依存性注入は、クラスが他のオブジェクト（依存するクラス）に依存している場合、その依存オブジェクトをクラスの外部から注入する設計パターンです。これにより、クラスは自ら依存オブジェクトを生成せず、外部で準備された依存オブジェクトを受け取る形で処理が行われます。この手法は、クラスの独立性を保ち、テスト時にモックオブジェクトを容易に差し替えることができる利点があります。

アクセス修飾子を利用した依存性注入

依存性注入を実装する際、依存オブジェクトをprivateプロパティとして定義し、外部から直接アクセスされないようにすることが一般的です。依存オブジェクトは、publicなコンストラクタやセッターメソッドを通じて注入されます。これにより、依存関係を外部に隠しつつ、適切な注入が可能となります。

次の例では、Loggerクラスの依存性をUserServiceクラスに注入しています。

class Logger {
    public function log($message) {
        echo "Log: " . $message . "\n";
    }
}

class UserService {
    private $logger;

    public function __construct(Logger $logger) {
        $this->logger = $logger;  // 依存オブジェクトを注入
    }

    public function createUser($name) {
        // ユーザー作成ロジック
        $this->logger->log("User created: " . $name);
    }
}

$logger = new Logger();
$userService = new UserService($logger);
$userService->createUser("Alice");

この設計のポイントは、次の通りです。

  • private $logger: ロガーは外部から直接アクセスできないprivateプロパティとして宣言されています。これにより、依存オブジェクトの不正な操作を防ぎ、クラスの内部でのみ安全に使用できます。
  • public function __construct: コンストラクタはpublicとして宣言されており、UserServiceクラスを初期化する際に、Loggerオブジェクトを外部から注入します。

このように、アクセス修飾子を使って依存オブジェクトの保護と注入を両立させることができます。

セッターによる依存性注入

依存オブジェクトを必須とせず、後から設定する場合には、セッターメソッドを用いた依存性注入が有効です。これにより、依存オブジェクトを動的に変更できる柔軟性が得られます。

class UserService {
    private $logger;

    public function setLogger(Logger $logger) {
        $this->logger = $logger;  // 外部から依存オブジェクトを注入
    }

    public function createUser($name) {
        if ($this->logger) {
            $this->logger->log("User created: " . $name);
        }
    }
}

$logger = new Logger();
$userService = new UserService();
$userService->setLogger($logger);
$userService->createUser("Bob");

セッターによる依存性注入では、publicメソッドを通じてprivateプロパティに依存オブジェクトを設定しています。この方法は、依存オブジェクトをクラスの外部で柔軟に管理したい場合に便利です。

依存性注入とテストの容易さ

依存性注入の大きな利点は、テストの際にモックオブジェクトを簡単に差し替えることができる点です。モックオブジェクトは、本番環境で使用するオブジェクトの代替として、テストのために軽量なオブジェクトを提供するものです。これにより、依存するオブジェクトの動作に影響されず、個々のクラスやメソッドのテストが可能になります。

例えば、Loggerクラスをモックして、ログ出力を行わない軽量なテストを行うことができます。

class MockLogger {
    public function log($message) {
        // テスト用のモックログ
    }
}

$mockLogger = new MockLogger();
$userService = new UserService($mockLogger);
$userService->createUser("TestUser");  // ログは出力されない

このように、依存性注入を用いることで、実際のLoggerクラスを使用せず、テスト環境に合わせた依存オブジェクトを簡単に注入できます。

まとめ

依存性注入は、クラス間の依存関係を外部から制御し、クラスの独立性やテストの柔軟性を高める重要な設計パターンです。アクセス修飾子を活用して、依存オブジェクトのアクセス範囲を制限し、安全かつ効果的に注入を行うことができます。コンストラクタやセッターメソッドを通じて適切に依存オブジェクトを注入し、保守性の高いコードを実現しましょう。

演習問題：アクセス修飾子を使ったクラス設計を実践

ここでは、これまで学んだpublic、private、protectedのアクセス修飾子の知識を活用し、実際にクラスを設計する演習問題を提示します。この演習を通じて、アクセス修飾子の適切な使い方やクラス設計のコツを身につけましょう。

演習問題 1: 銀行口座クラスの設計

次の要件を満たす「銀行口座（BankAccount）」クラスを設計してください。

  1. 口座の残高は外部から直接変更できないようにする。privateを使用。
  2. 残高を増やすためのdepositメソッドを提供する。引数には入金額を渡す。
  3. 残高を減らすためのwithdrawメソッドを提供する。引数には引き出す金額を渡す。
  4. 残高が足りない場合は、引き出しができないようにする。
  5. 残高を確認するためのgetBalanceメソッドを提供する。
  6. 口座番号は保護され、子クラスで利用できるようにする。protectedを使用。

設計例:

class BankAccount {
    private $balance;
    protected $accountNumber;

    public function __construct($accountNumber, $initialBalance = 0) {
        $this->accountNumber = $accountNumber;
        $this->balance = $initialBalance;
    }

    public function deposit($amount) {
        if ($amount > 0) {
            $this->balance += $amount;
        }
    }

    public function withdraw($amount) {
        if ($amount > 0 && $this->balance >= $amount) {
            $this->balance -= $amount;
        }
    }

    public function getBalance() {
        return $this->balance;
    }
}

演習問題 2: 継承クラスを使った銀行口座の拡張

上記の「銀行口座（BankAccount）」クラスを継承して、「貯蓄口座（SavingsAccount）」クラスを設計してください。次の追加要件を満たしてください。

  1. 毎年の利子を計算するcalculateInterestメソッドを追加する。
  2. 利率はprotectedプロパティとして、初期値は3%とする。
  3. 親クラスのgetBalanceメソッドを使って利子を計算し、残高に加える機能を実装する。

設計例:

class SavingsAccount extends BankAccount {
    protected $interestRate = 0.03;

    public function calculateInterest() {
        $interest = $this->getBalance() * $this->interestRate;
        $this->deposit($interest);
    }
}

演習問題 3: テストのためのモッククラス作成

依存性注入の概念を活用して、Loggerクラスを注入する形で「ユーザーサービス（UserService）」クラスを再設計してください。以下の要件に基づいて、モッククラスを使ってテストできるようにします。

  1. UserServiceクラスがユーザー作成時にログを記録する。
  2. ログを記録するためのLoggerクラスは外部から注入する。
  3. テストの際には、Loggerクラスの代わりにモッククラスを使用してログ記録をスキップする。

モッククラス例:

class MockLogger {
    public function log($message) {
        // テスト用のダミー処理
    }
}

class UserService {
    private $logger;

    public function __construct($logger) {
        $this->logger = $logger;
    }

    public function createUser($name) {
        // ユーザー作成ロジック
        $this->logger->log("User created: " . $name);
    }
}

まとめ

これらの演習を通じて、アクセス修飾子を活用したクラス設計のスキルを実践的に深めることができます。実際に手を動かしてコードを設計することで、アクセス修飾子の使い方がより自然に理解できるようになります。

まとめ

本記事では、PHPにおけるアクセス修飾子（public、private、protected）の役割と使い方について詳しく解説し、それらを活用した柔軟なクラス設計の方法を紹介しました。また、実践例や演習問題を通じて、アクセス修飾子の正しい使い方や、依存性注入、継承を活かした拡張性の高い設計方法も学びました。アクセス修飾子を適切に使い分けることで、データの保護や再利用性を高め、より堅牢でメンテナンスしやすいコードを作成できるようになります。

PHP
クラス設計 アクセス修飾子 PHP

コメント

コメントする

目次