TypeScriptでのアクセス指定子（public, private, protected）を使用することで、コードの設計がより直感的で安全になります。これにより、クラスのプロパティや関数に対して外部からのアクセスを制限し、エンカプセル化を強化できます。本記事では、アクセス指定子を用いた関数とプロパティの設計ガイドとして、各指定子の役割や使い方、具体的な設計例を詳しく解説します。TypeScript初心者から中級者まで、効果的にアクセス指定子を使いこなすための知識を提供します。
アクセス指定子とは
TypeScriptにおけるアクセス指定子とは、クラスのプロパティやメソッドに対して、外部からどのようにアクセスできるかを制御するためのキーワードです。主にpublic、private、protectedの3種類があり、それぞれ異なるアクセス権限を定義します。これにより、コードの安全性と一貫性を保ちながら、クラス設計の柔軟性を高めることが可能です。
アクセス指定子を適切に使用することで、不要なデータの露出を防ぎ、内部ロジックを隠蔽することができます。これにより、クラス間の依存関係が減り、メンテナンスが容易になります。
publicアクセス指定子の使用方法
publicアクセス指定子は、TypeScriptでデフォルトのアクセス修飾子であり、クラスのプロパティやメソッドを外部から自由にアクセス可能にします。publicが明示的に指定されていなくても、すべてのプロパティやメソッドは自動的にpublicと見なされます。
publicの利点
public修飾子を使うことで、クラスの外部からプロパティやメソッドにアクセスして操作できるため、オブジェクト指向設計において非常に便利です。例えば、外部から直接プロパティの値を参照したり、関数を呼び出したりすることができます。
class Person {
public name: string;
constructor(name: string) {
this.name = name;
}
public greet(): string {
return `Hello, my name is ${this.name}`;
}
}
const person = new Person("Alice");
console.log(person.name); // Alice
console.log(person.greet()); // Hello, my name is Aliceこの例では、nameプロパティとgreetメソッドがpublicとして定義されているため、クラスの外部から自由にアクセスできます。
publicの使用時の注意点
publicを多用すると、意図しない変更や操作がクラス外部から行われる可能性があります。そのため、セキュリティが重要なデータやロジックには、慎重に使用する必要があります。
privateアクセス指定子の使用方法
privateアクセス指定子は、クラスのプロパティやメソッドを外部からのアクセスから完全に隠すために使用されます。privateで指定された要素は、同じクラス内でしかアクセスすることができず、外部から直接アクセスすることはできません。これにより、データの保護とクラスの内部実装の隠蔽を実現できます。
privateの利点
privateを使用すると、クラスの内部でしか操作できないプロパティやメソッドを定義できます。これにより、外部から意図しない操作が行われるリスクを減らし、クラスの一貫性と安全性を高めることが可能です。例えば、重要なデータや内部処理はprivateとして定義することで、外部から直接変更されないように保護できます。
class BankAccount {
private balance: number;
constructor(initialBalance: number) {
this.balance = initialBalance;
}
public deposit(amount: number): void {
this.balance += amount;
}
public getBalance(): number {
return this.balance;
}
}
const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // 1500
console.log(account.balance); // エラー: 'balance' はプライベートプロパティですこの例では、balanceプロパティがprivateとして定義されているため、クラスの外部から直接アクセスすることはできません。アクセスはクラス内のメソッドを通じて行います。
privateの使用時の注意点
privateに指定されたプロパティやメソッドは、テストやデバッグ時にアクセスが困難になることがあります。そのため、テスト用のメソッドやアクセサメソッドを導入するなど、柔軟性を持たせる設計が求められる場合があります。
protectedアクセス指定子の使用方法
protectedアクセス指定子は、クラスのプロパティやメソッドを、クラス自体およびそのサブクラス（派生クラス）からのみアクセス可能にするものです。これは、クラス内部のロジックを継承したクラスで利用できるようにしつつ、クラス外部からの直接のアクセスを制限したい場合に役立ちます。privateとは異なり、サブクラスではアクセス可能ですが、外部からはアクセスできません。
protectedの利点
protectedを使うことで、基底クラスのプロパティやメソッドを、サブクラスで柔軟に利用できるようになります。例えば、基底クラスの内部データをサブクラスに引き継ぎ、追加機能を実装する際に非常に有効です。これは、オブジェクト指向プログラミングにおける「継承」の概念を活かすために重要です。
class Vehicle {
protected speed: number = 0;
public accelerate(amount: number): void {
this.speed += amount;
}
public getSpeed(): number {
return this.speed;
}
}
class Car extends Vehicle {
public boost(): void {
this.accelerate(50); // 基底クラスのprotectedメソッドを利用
}
}
const myCar = new Car();
myCar.boost();
console.log(myCar.getSpeed()); // 50この例では、Vehicleクラスのspeedプロパティがprotectedとして定義されていますが、Carクラスはこのプロパティにアクセスして操作することができます。しかし、myCar.speedのようにクラス外部から直接アクセスすることはできません。
protectedの使用時の注意点
protectedを使うと、サブクラスでの再利用性が向上しますが、過度に使用するとクラス間の依存が強くなり、設計が複雑になる可能性があります。クラスの意図する責任範囲を明確にし、必要以上にprotectedプロパティやメソッドを公開しないように注意が必要です。
アクセス指定子を使ったクラスの設計例
ここでは、public、private、protectedのアクセス指定子を適切に使用したクラス設計の具体例を示します。これにより、アクセス指定子を活用したプロパティやメソッドの設計方法を理解できます。
クラス設計例: ユーザー認証システム
次の例では、ユーザー認証システムをシミュレートするUserクラスを設計しています。このクラスでは、publicを使って外部からアクセス可能なメソッドを定義し、privateで機密データを保護し、protectedでサブクラスから拡張可能なメソッドを提供しています。
class User {
public username: string;
private password: string;
protected role: string;
constructor(username: string, password: string, role: string) {
this.username = username;
this.password = password;
this.role = role;
}
// 外部から認証を行うメソッド（public）
public authenticate(inputPassword: string): boolean {
return this.verifyPassword(inputPassword);
}
// パスワードの検証（private）
private verifyPassword(inputPassword: string): boolean {
return this.password === inputPassword;
}
// ロール情報を取得するメソッド（protected）
protected getRole(): string {
return this.role;
}
}
class AdminUser extends User {
constructor(username: string, password: string) {
super(username, password, "admin");
}
public accessAdminPanel(): boolean {
return this.getRole() === "admin";
}
}
const user = new User("Alice", "password123", "user");
console.log(user.authenticate("password123")); // true
console.log(user.username); // Alice
// console.log(user.password); // エラー: 'password' はプライベート
// console.log(user.getRole()); // エラー: 'getRole' はプロテクテッド
const admin = new AdminUser("Bob", "adminPass");
console.log(admin.accessAdminPanel()); // true設計例の解説
publicアクセス指定子:usernameプロパティとauthenticateメソッドはpublicとして定義されており、クラス外部から自由にアクセスできます。このように、ユーザー名や認証機能は外部からアクセスする必要があるため、publicとして設計されています。privateアクセス指定子:passwordプロパティとverifyPasswordメソッドはprivateとして定義されており、クラス外部から直接アクセスすることはできません。これはセキュリティ上、パスワードの情報を外部に公開しないようにするためです。protectedアクセス指定子:roleプロパティとgetRoleメソッドはprotectedとして定義され、サブクラスでのみアクセス可能です。これにより、AdminUserクラスはgetRoleメソッドを利用して、管理者権限のチェックができますが、クラス外部から直接この情報にアクセスすることはできません。
クラス設計でのアクセス指定子の利点
この設計により、ユーザー名や認証機能は外部から利用可能にしつつ、パスワードやロール情報などの機密データは適切に保護されています。アクセス指定子を適切に使うことで、クラスの内部実装を隠蔽し、外部からの意図しない操作を防ぎつつ、継承関係の中で柔軟に拡張可能な構造を実現できます。
関数にアクセス指定子を設定するメリット
TypeScriptでは、関数にアクセス指定子（public、private、protected）を設定することで、クラスのメソッドの公開範囲を制御できます。これにより、クラスの設計をより効率的かつ安全に行うことが可能です。アクセス指定子を関数に適用することで得られるいくつかの具体的なメリットについて見ていきましょう。
コードの安全性向上
アクセス指定子を使うことで、クラスの外部から意図しない方法で関数を呼び出すことを防ぐことができます。例えば、内部的な処理や、他の関数からのみ呼ばれるべきヘルパー関数をprivateにすることで、外部から直接アクセスされることを防ぎます。
class Payment {
public processPayment(amount: number): void {
if (this.validateTransaction()) {
console.log(`Processing payment of $${amount}`);
}
}
// 外部からはアクセスできないようにする（private）
private validateTransaction(): boolean {
console.log("Validating transaction...");
return true;
}
}
const payment = new Payment();
payment.processPayment(100); // Validating transaction... Processing payment of $100
// payment.validateTransaction(); // エラー: 'validateTransaction' はプライベートメソッドこの例では、validateTransactionメソッドをprivateとして定義することで、支払い処理の一部としてのみ内部で使用され、外部からは直接呼び出せなくなっています。これにより、内部ロジックを安全に隠蔽できます。
クラスの一貫性とカプセル化の向上
クラスの外部から必要なメソッドだけをpublicにすることで、クラスのインターフェースをシンプルに保つことができます。余計なメソッドが外部に露出しないため、クラスの一貫性とカプセル化が向上し、保守性が高まります。
class UserAccount {
public resetPassword(): void {
this.sendEmail();
}
// 内部ロジックのためのメソッド（private）
private sendEmail(): void {
console.log("Sending password reset email...");
}
}
const account = new UserAccount();
account.resetPassword(); // Sending password reset email...
// account.sendEmail(); // エラー: 'sendEmail' はプライベートメソッドこのように、resetPasswordメソッドは外部から利用可能ですが、実際のメール送信処理であるsendEmailメソッドは外部からはアクセスできません。これにより、ユーザーにはシンプルで一貫性のあるインターフェースを提供しつつ、内部処理は隠蔽できます。
柔軟な拡張と保守性の向上
protectedを使うことで、継承したクラスで特定の関数にアクセス可能にし、サブクラスでのカスタマイズや拡張を容易にします。これにより、クラス設計に柔軟性を持たせることができます。
class Employee {
protected calculateBonus(): number {
return 1000;
}
public getSalary(): number {
return 50000 + this.calculateBonus();
}
}
class Manager extends Employee {
// ボーナスをカスタマイズ
protected calculateBonus(): number {
return 2000;
}
}
const manager = new Manager();
console.log(manager.getSalary()); // 52000この例では、calculateBonusメソッドをprotectedにすることで、Managerクラスでボーナスの計算方法を自由に変更できるようにしていますが、外部からは直接アクセスできません。これにより、継承したクラスでの柔軟な拡張が可能になります。
リファクタリング時の安全性
アクセス指定子を設定することで、将来的にコードをリファクタリングする際、外部から呼び出されていないprivateメソッドやprotectedメソッドに関しては、安心して変更を加えることができます。外部依存がないため、意図しない影響を避けやすくなります。
以上のように、アクセス指定子を関数に設定することは、TypeScriptにおけるクラス設計の柔軟性、安全性、一貫性を向上させ、保守しやすいコードを実現するために重要です。
アクセス指定子を使った関数設計のベストプラクティス
TypeScriptでアクセス指定子を使った関数設計を行う際、適切に指定子を活用することで、クラスの柔軟性と安全性を高め、効率的なコード構造を実現できます。ここでは、アクセス指定子を使った関数設計におけるベストプラクティスを紹介します。
必要な関数だけを公開する
クラスの外部に公開する関数は、クラスの使用者が直接アクセスする必要があるものだけに限定することが重要です。これにより、クラスのインターフェースが明確になり、不要な機能の混乱を避けられます。クラスの内部でのみ使用される関数は、privateやprotectedとして定義することで、意図しない呼び出しを防ぎます。
class ShoppingCart {
private items: string[] = [];
public addItem(item: string): void {
this.items.push(item);
this.updateTotal();
}
public getItems(): string[] {
return this.items;
}
// 外部から直接呼び出される必要はない関数（private）
private updateTotal(): void {
console.log(`Total updated for ${this.items.length} items.`);
}
}
const cart = new ShoppingCart();
cart.addItem("Book");
console.log(cart.getItems()); // ['Book']
// cart.updateTotal(); // エラー: 'updateTotal' はプライベートメソッドこの例では、addItemやgetItemsはpublicとして外部に公開されていますが、updateTotalは内部でのみ必要な処理なのでprivateとしています。これにより、利用者にとって不必要なメソッドを隠し、クラスの利用が簡潔になります。
継承を考慮した関数設計
クラスを拡張することを想定した設計では、継承元のクラスでprotectedを使ってサブクラスからアクセス可能な関数を定義することが有効です。これにより、サブクラスで基本的なロジックを再利用しながら、特定の部分をオーバーライドして機能をカスタマイズできます。
class Employee {
protected calculatePay(): number {
return 4000;
}
public getMonthlyPay(): number {
return this.calculatePay();
}
}
class Manager extends Employee {
protected calculatePay(): number {
return 6000;
}
}
const manager = new Manager();
console.log(manager.getMonthlyPay()); // 6000このように、calculatePayをprotectedにすることで、継承先のManagerクラスでこのメソッドをオーバーライドして独自の給与計算ができるようにしています。これにより、コードの再利用と拡張がスムーズになります。
関数に責任範囲を持たせる
アクセス指定子を使った関数設計では、各関数が明確な責任範囲を持つように設計することが重要です。1つの関数が複数の役割を持つと、コードの可読性が低下し、保守が難しくなります。特定のロジックや役割に限定することで、関数が適切に機能を分担し、クラス全体が整理されます。
class Order {
private items: string[] = [];
public addItem(item: string): void {
this.items.push(item);
}
public checkout(): void {
this.validateOrder();
this.processPayment();
}
// 注文のバリデーション処理（private）
private validateOrder(): void {
if (this.items.length === 0) {
throw new Error("注文に商品がありません。");
}
}
// 支払い処理（private）
private processPayment(): void {
console.log("支払い処理中...");
}
}この例では、checkout関数に注文の処理責任を持たせていますが、バリデーションと支払い処理はprivateメソッドとして分離されています。これにより、各関数が単一の責任を持つようになり、コードが整理され、理解しやすくなります。
変更の影響を最小限に抑える
アクセス指定子を使用することで、将来の変更に伴う影響範囲を最小限に抑えることができます。privateやprotectedを適切に設定することで、外部の利用者に対する依存を減らし、内部的なロジックの変更が簡単になります。これにより、コードの保守性が向上し、意図しない影響を防ぎます。
例えば、privateメソッドに変更があった場合でも、クラス外部に公開されていないため、他の部分に影響を与えにくい設計になります。
テストを考慮したアクセス指定子の使用
テストの際、privateメソッドやprotectedメソッドは直接テストできません。テスト用に関数のアクセス指定子を調整したり、テスト時に限りモック化できるよう設計を工夫することで、テストのしやすさも考慮することが重要です。
アクセス指定子を活用した関数設計により、コードの構造を整理し、メンテナンスが容易で拡張性の高い設計を行うことができます。
アクセス指定子を用いたカプセル化の応用
TypeScriptにおけるカプセル化は、アクセス指定子を活用してクラスの内部実装を外部から隠蔽し、コードの安全性や可読性を向上させる重要な概念です。アクセス指定子を適切に使用することで、クラスのプロパティやメソッドへのアクセスを制限し、内部ロジックを保護しながら、必要な部分のみを外部に公開できます。ここでは、アクセス指定子を使ったカプセル化の具体的な応用方法を紹介します。
内部状態の保護
アクセス指定子を用いることで、クラスの内部状態を外部から変更できないように保護できます。例えば、private修飾子を使用して、クラス内でのみアクセスできるプロパティやメソッドを定義し、外部から意図しない変更が行われないようにすることが可能です。
class BankAccount {
private balance: number;
constructor(initialBalance: number) {
this.balance = initialBalance;
}
// 残高を外部に公開するメソッド（外部からbalanceに直接アクセスできない）
public getBalance(): number {
return this.balance;
}
// 残高を更新するメソッド（balanceはprivate）
public deposit(amount: number): void {
if (amount > 0) {
this.balance += amount;
}
}
}
const account = new BankAccount(1000);
console.log(account.getBalance()); // 1000
account.deposit(500);
console.log(account.getBalance()); // 1500
// account.balance = 2000; // エラー: 'balance' はプライベートプロパティこの例では、balanceプロパティはprivateとして定義されており、外部から直接アクセスすることはできません。代わりに、getBalanceとdepositメソッドを通じて残高の操作を行います。これにより、クラスの内部状態が保護され、予期せぬ変更を防ぎます。
内部ロジックの隠蔽
privateやprotectedアクセス指定子を使用することで、クラス内部のロジックを隠蔽し、外部から見えないようにすることができます。これにより、クラスの内部で行われる詳細な処理を公開する必要がなくなり、クラスのインターフェースが簡潔でわかりやすくなります。
class TemperatureSensor {
private temperature: number = 0;
// 外部に公開する温度取得メソッド
public getTemperature(): number {
this.readSensor();
return this.temperature;
}
// センサーから温度を取得する内部処理（private）
private readSensor(): void {
console.log("Reading from sensor...");
this.temperature = 25; // 実際にはセンサーからデータを取得
}
}
const sensor = new TemperatureSensor();
console.log(sensor.getTemperature()); // Reading from sensor... 25
// sensor.readSensor(); // エラー: 'readSensor' はプライベートメソッドこの例では、readSensorメソッドは内部ロジックとしてprivateで定義されています。外部からは直接センサーの読み取り処理を実行できず、代わりにgetTemperatureメソッドを通じて温度データを取得します。これにより、クラスの内部処理を隠し、外部にはシンプルなインターフェースのみを提供しています。
拡張性を保ちながら隠蔽する
protectedを使うと、クラス内部のロジックを隠しつつ、サブクラスでの拡張を許可できます。これにより、基底クラスのカプセル化を保ちながら、サブクラスで特定の機能を拡張できます。
class Vehicle {
protected speed: number = 0;
public accelerate(amount: number): void {
this.speed += amount;
}
public getSpeed(): number {
return this.speed;
}
}
class ElectricCar extends Vehicle {
private batteryLevel: number = 100;
public chargeBattery(): void {
this.batteryLevel = 100;
}
public accelerate(amount: number): void {
if (this.batteryLevel > 0) {
super.accelerate(amount);
this.batteryLevel -= amount * 0.1;
}
}
}
const car = new ElectricCar();
car.accelerate(50);
console.log(car.getSpeed()); // 50この例では、Vehicleクラスのspeedプロパティはprotectedとして定義されており、外部からはアクセスできませんが、ElectricCarクラスで拡張して利用することが可能です。これにより、継承を使ってクラスの拡張性を保ちながら、内部のロジックは隠蔽されています。
APIの簡潔化とメンテナンス性の向上
カプセル化を実現することで、クラスのAPIを簡潔に保つことができ、メンテナンスが容易になります。外部に公開するメソッドやプロパティを最小限にすることで、クラスの使用方法が明確になり、コードの理解がしやすくなります。
カプセル化を適切に行うことで、クラスの内部構造を変更しても、外部に影響を与えない設計が可能になり、変更時の影響範囲を最小限に抑えることができます。
以上のように、アクセス指定子を使ったカプセル化は、クラスの安全性、柔軟性、メンテナンス性を向上させ、効果的なオブジェクト指向設計を実現するために重要です。
アクセス指定子を用いたエラーハンドリング
アクセス指定子を活用することで、クラス内部のエラーハンドリングのロジックを隠蔽し、外部からの不正な操作や意図しないエラーを防ぐことができます。適切にエラーハンドリングを行うことで、コードの堅牢性を向上させ、予期しない動作を未然に防ぐことが可能です。ここでは、アクセス指定子を用いたエラーハンドリングの方法とその利点について説明します。
内部エラーハンドリングの隠蔽
エラーハンドリングに関連するロジックは、クラス内部でのみ使用されることが多いため、privateやprotectedを使って外部から隠蔽することが推奨されます。これにより、エラーハンドリングの詳細を外部に公開する必要がなくなり、クラスの設計がシンプルになります。
class UserRegistration {
private users: string[] = [];
public registerUser(username: string): void {
if (this.validateUsername(username)) {
this.users.push(username);
console.log(`User ${username} registered successfully.`);
} else {
this.handleError("Invalid username");
}
}
// ユーザー名の検証（private）
private validateUsername(username: string): boolean {
return username.length > 3;
}
// エラーハンドリング（private）
private handleError(errorMessage: string): void {
console.error(`Error: ${errorMessage}`);
}
}
const registration = new UserRegistration();
registration.registerUser("Al"); // Error: Invalid username
registration.registerUser("Alice"); // User Alice registered successfullyこの例では、validateUsernameおよびhandleErrorメソッドはprivateとして定義され、外部から直接呼び出すことはできません。エラーハンドリングのロジックはクラス内部で行われ、外部に公開されているのはregisterUserメソッドのみです。これにより、クラスの使用者はエラーハンドリングの詳細を気にする必要がなくなります。
サブクラスでのエラーハンドリングの拡張
protectedアクセス指定子を使うと、サブクラス内でエラーハンドリングを柔軟に拡張できます。これにより、基底クラスで基本的なエラーハンドリングを実装しつつ、特定のサブクラスでそのロジックをカスタマイズすることが可能です。
class API {
protected handleError(errorMessage: string): void {
console.error(`API Error: ${errorMessage}`);
}
public fetchData(): void {
// データの取得処理中にエラーが発生
this.handleError("Failed to fetch data.");
}
}
class AdvancedAPI extends API {
// エラーハンドリングのカスタマイズ
protected handleError(errorMessage: string): void {
console.error(`Advanced API Error: ${errorMessage}`);
}
public fetchDataWithRetry(): void {
try {
super.fetchData();
} catch (error) {
this.handleError("Retry failed.");
}
}
}
const api = new AdvancedAPI();
api.fetchData(); // API Error: Failed to fetch data.
api.fetchDataWithRetry(); // Advanced API Error: Retry failed.この例では、基底クラスAPIにprotectedなhandleErrorメソッドがあり、サブクラスAdvancedAPIでそのエラーハンドリングロジックをカスタマイズしています。これにより、サブクラスでのエラーハンドリングの拡張が可能になり、エラー処理をより柔軟に実装できます。
アクセス制御によるエラー発生の防止
アクセス指定子を正しく設定することで、外部からの不正な操作や不適切なアクセスによるエラー発生を防ぐことができます。例えば、privateやprotectedを使って、クラス外部から呼び出すべきではないメソッドやプロパティを隠すことで、不正なアクセスが原因のエラーを未然に防ぐことが可能です。
class FileHandler {
private filePath: string;
constructor(filePath: string) {
this.filePath = filePath;
}
public readFile(): void {
if (!this.validateFilePath()) {
this.handleError("Invalid file path.");
} else {
console.log(`Reading file from ${this.filePath}`);
}
}
// ファイルパスの検証（private）
private validateFilePath(): boolean {
return this.filePath.length > 0;
}
// エラーハンドリング（private）
private handleError(errorMessage: string): void {
console.error(`FileHandler Error: ${errorMessage}`);
}
}
const fileHandler = new FileHandler("");
fileHandler.readFile(); // FileHandler Error: Invalid file path.この例では、validateFilePathやhandleErrorはprivateメソッドとして定義されており、外部から直接アクセスできません。これにより、クラス外部からの不適切な操作によるエラーを防ぐことができます。
エラーハンドリングの一貫性の維持
アクセス指定子を使用することで、エラーハンドリングロジックを一貫してクラス内部に留めておくことができ、エラーメッセージや処理の統一性が保たれます。これにより、コードの可読性や保守性が向上し、エラーメッセージの形式や対応方法が一貫したものとなります。
アクセス指定子を用いたエラーハンドリングにより、クラスの堅牢性が向上し、クラス外部からの不正な操作を防ぐとともに、エラーメッセージや対応が統一されたシンプルで直感的なAPIを提供できます。
アクセス指定子とインターフェースの連携
TypeScriptでは、アクセス指定子とインターフェースを組み合わせることで、柔軟で強力なオブジェクト設計を行うことができます。インターフェースは、クラスが実装すべきメソッドやプロパティの定義を提供しますが、アクセス指定子自体はインターフェースには存在しません。そのため、アクセス指定子はクラス内部で実装時に制御され、インターフェースはそのクラスの外部インターフェースを定義します。
ここでは、インターフェースとアクセス指定子を効果的に連携させる方法を見ていきます。
インターフェースでの公開インターフェースの定義
インターフェースを使用することで、クラスの外部に公開するメソッドやプロパティの型や構造を定義できます。インターフェースはアクセス指定子を直接サポートしないため、publicとしてクラスで実装する部分のみを定義します。具体的なアクセス制御はクラス内部で行い、クラス外部からはインターフェースに定義された部分だけが見えるようにします。
interface AccountInterface {
getBalance(): number;
deposit(amount: number): void;
}
class Account implements AccountInterface {
private balance: number;
constructor(initialBalance: number) {
this.balance = initialBalance;
}
public getBalance(): number {
return this.balance;
}
public deposit(amount: number): void {
if (amount > 0) {
this.balance += amount;
} else {
this.handleError("Invalid deposit amount");
}
}
private handleError(errorMessage: string): void {
console.error(`Error: ${errorMessage}`);
}
}
const myAccount: AccountInterface = new Account(1000);
myAccount.deposit(500);
console.log(myAccount.getBalance()); // 1500この例では、AccountクラスがAccountInterfaceを実装し、getBalanceとdepositメソッドを公開しています。一方、handleErrorメソッドやbalanceプロパティはprivateとして定義されており、インターフェース外部からはアクセスできません。これにより、インターフェースを通じて公開された部分だけが外部から見えるようになり、内部の詳細は隠蔽されます。
インターフェースとアクセス制御の応用
インターフェースは、クラスの外部インターフェースを定義するために用いられるため、アクセス指定子はクラス側で制御します。これにより、インターフェースは必要な部分だけを公開し、内部のロジックを隠す設計が可能です。また、クラスの継承や拡張時にも、この構造が役立ちます。
interface VehicleInterface {
accelerate(amount: number): void;
getSpeed(): number;
}
class Vehicle implements VehicleInterface {
protected speed: number = 0;
public accelerate(amount: number): void {
this.speed += amount;
}
public getSpeed(): number {
return this.speed;
}
}
class Car extends Vehicle {
public turboBoost(): void {
this.accelerate(50);
}
}
const myCar: VehicleInterface = new Car();
myCar.accelerate(20);
console.log(myCar.getSpeed()); // 20この例では、VehicleInterfaceがaccelerateメソッドとgetSpeedメソッドを定義し、Vehicleクラスがそれを実装しています。Vehicleクラスではprotectedなspeedプロパティを使用しており、これはサブクラスでのみアクセス可能です。このように、インターフェースで定義された公開部分と、クラス内部で制御されたアクセス指定子を使い分けることで、クラスの拡張性とカプセル化を両立できます。
インターフェースの利点とアクセス指定子の使い分け
インターフェースを使用することで、外部から見えるクラスのAPIを明確に定義し、アクセス指定子でクラス内部の詳細を制御することで、セキュリティや拡張性を向上させることができます。これにより、複雑なビジネスロジックを扱うクラスでも、クラス外部からのアクセス範囲を最小限にし、不要なデータへのアクセスを制限することが可能です。
主な利点:
- セキュリティ強化: アクセス指定子により、クラス内部のデータを隠し、外部からの意図しない操作を防ぎます。
- 可読性向上: インターフェースで公開部分を明確にし、クラスの使用者がどのメソッドやプロパティを使えるか理解しやすくします。
- 柔軟な拡張: 継承やサブクラスでの拡張に対応しやすい設計が可能です。
以上のように、TypeScriptではアクセス指定子とインターフェースを組み合わせて使うことで、柔軟かつ安全なクラス設計が実現できます。
まとめ
本記事では、TypeScriptにおけるアクセス指定子（public、private、protected）を活用した関数とプロパティの設計方法について詳しく解説しました。アクセス指定子を適切に使うことで、クラスの安全性を高め、内部ロジックを隠蔽しながら、柔軟なクラス設計が可能になります。また、インターフェースとの連携により、明確で使いやすいAPIを提供しつつ、内部の実装を保護することができました。これにより、保守性が向上し、効率的なコード設計が実現します。
コメント