ストラテジーパターンは、ソフトウェア開発において、異なるアルゴリズムや動作を動的に切り替えるためのデザインパターンです。これにより、コードの再利用性や拡張性を高め、変更に強い柔軟な設計を実現できます。特に、Javaではストラテジーパターンを利用することで、例えばソートアルゴリズムや支払い方法のような処理を状況に応じて簡単に変更できるようになります。本記事では、Javaでのストラテジーパターンの具体的な実装方法や活用例を交えながら、アルゴリズムの動的切り替えについて詳しく解説していきます。
ストラテジーパターンとは
ストラテジーパターンは、GoF（Gang of Four）が提唱するデザインパターンの一つで、オブジェクトの振る舞いを動的に切り替えることを可能にする手法です。特定のタスクに対して複数の異なるアルゴリズムや処理を実装し、それを実行時に選択できるように設計します。これにより、アルゴリズムの選択や変更が柔軟に行えるため、コードの可読性や保守性が向上します。
用途と目的
ストラテジーパターンは、同じ目的を達成するために複数の方法が存在する場合や、アルゴリズムを頻繁に変更・拡張する必要があるケースで有効です。これにより、各アルゴリズムを独立したクラスとして実装でき、クライアントコードへの影響を最小限に抑えてアルゴリズムの追加や変更が可能になります。
ストラテジーパターンの構成要素
ストラテジーパターンには、いくつかの重要な構成要素があり、それぞれが特定の役割を担っています。これらの要素を理解することで、パターンの仕組みをより深く理解できます。
1. Strategy インターフェース
Strategy は、共通のアルゴリズムや処理を抽象的に定義するインターフェースです。これにより、異なる具体的なアルゴリズムを同一のインターフェースを通じて利用できるようになります。例えば、ソートアルゴリズムを切り替える場合、このインターフェースに sort() メソッドを定義します。
public interface Strategy {
void execute();
}2. Concrete Strategy（具体的なアルゴリズムクラス）
Strategy インターフェースを実装するクラスです。各クラスが異なるアルゴリズムや処理を実装します。例えば、バブルソートやクイックソートなど、それぞれのアルゴリズムが Strategy を実装して具体的な処理を提供します。
public class BubbleSortStrategy implements Strategy {
public void execute() {
System.out.println("バブルソートを実行");
}
}
public class QuickSortStrategy implements Strategy {
public void execute() {
System.out.println("クイックソートを実行");
}
}3. Context（コンテキストクラス）
Context クラスは、実際にアルゴリズムを利用する役割を担います。Strategy を保持し、そのメソッドを呼び出して処理を実行します。これにより、どのアルゴリズムを使用するかは Context クラスが決定し、クライアントコードからは Context を通じてアルゴリズムを利用するだけで済みます。
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}この構成により、アルゴリズムを簡単に差し替えたり、追加したりできるようになります。
ストラテジーパターンのメリット
ストラテジーパターンを利用することで、システム全体の柔軟性や保守性が向上します。ここでは、ストラテジーパターンを採用することによる主なメリットについて説明します。
1. 保守性の向上
ストラテジーパターンでは、各アルゴリズムが独立したクラスとして実装されるため、特定のアルゴリズムに変更を加える際、他のアルゴリズムやコードに影響を与えません。この分離により、変更が必要な箇所だけを簡単に修正でき、システムの保守がしやすくなります。
2. 拡張性の向上
新しいアルゴリズムを追加する際、既存のコードを変更することなく、新たな Strategy クラスを作成するだけで対応できます。これにより、新しい要件や機能追加に対して柔軟に対応でき、拡張性が高まります。
3. 再利用性の向上
異なるプロジェクトやシステムで、同じアルゴリズムが再利用できるのもストラテジーパターンの強みです。各アルゴリズムは独立したモジュールとして機能するため、複数のプロジェクトで同じ Strategy クラスを再利用できます。
4. 条件分岐の削減
ストラテジーパターンを採用することで、条件分岐（ifやswitch文）によるアルゴリズムの選択を排除できます。これにより、コードの見通しがよくなり、可読性が向上します。各アルゴリズムはインターフェースを通じて実装されるため、実行時に簡単に切り替えることが可能です。
ストラテジーパターンを使うことで、複雑な条件分岐を排除し、メンテナンスや拡張が容易なシステムを構築できます。
Javaでストラテジーパターンを実装する手順
Javaでストラテジーパターンを実装する際の基本的な手順を紹介します。このパターンは、アルゴリズムの切り替えを簡単にし、柔軟なプログラムを作成するための方法です。
1. Strategyインターフェースの定義
まず、すべてのアルゴリズムで共通の操作を定義するインターフェースを作成します。ここでは、具体的なアルゴリズムがこのインターフェースを実装し、動的に選択されることになります。
public interface Strategy {
void execute();
}2. 具体的なアルゴリズムクラスの実装
次に、Strategy インターフェースを実装した具体的なアルゴリズムクラスを作成します。この例では、2つの異なるアルゴリズムを実装します。
public class BubbleSortStrategy implements Strategy {
@Override
public void execute() {
System.out.println("バブルソートを実行します");
}
}
public class QuickSortStrategy implements Strategy {
@Override
public void execute() {
System.out.println("クイックソートを実行します");
}
}3. Contextクラスの作成
次に、選択したアルゴリズムを利用する Context クラスを作成します。Context クラスは Strategy インターフェースを保持し、クライアントから指定されたアルゴリズムを実行します。
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}4. クライアントコードでのアルゴリズム切り替え
クライアントコードで、動的にアルゴリズムを切り替えながら実行します。異なる戦略を簡単に切り替えることができ、柔軟な実装が可能です。
public class StrategyPatternDemo {
public static void main(String[] args) {
// バブルソートを使用
Context context = new Context(new BubbleSortStrategy());
context.executeStrategy();
// クイックソートを使用
context = new Context(new QuickSortStrategy());
context.executeStrategy();
}
}このように、Context クラスを通じて異なる Strategy を簡単に切り替えることができます。この実装により、プログラムの拡張や保守が容易になり、柔軟にアルゴリズムを変更することが可能です。
アルゴリズムの具体例1: ソートアルゴリズムの切り替え
ストラテジーパターンの典型的な使用例として、ソートアルゴリズムの動的な切り替えがあります。特定の条件やデータセットに応じて最適なソート方法を選択することで、パフォーマンスを最適化できます。
バブルソートとクイックソートの切り替え
バブルソートは単純で小規模のデータセットに適していますが、大規模なデータには効率が悪くなります。一方、クイックソートは効率的ですが、実装がやや複雑です。ここでは、ストラテジーパターンを使用して、データセットに応じてこれら2つのソートアルゴリズムを動的に切り替える例を見てみましょう。
Strategyインターフェースの定義
まず、すべてのソートアルゴリズムが実装する共通のインターフェースを定義します。
public interface SortStrategy {
void sort(int[] numbers);
}バブルソートの実装
次に、バブルソートを実装するクラスを作成します。
public class BubbleSortStrategy implements SortStrategy {
@Override
public void sort(int[] numbers) {
int n = numbers.length;
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (numbers[j] > numbers[j+1]) {
// 交換
int temp = numbers[j];
numbers[j] = numbers[j+1];
numbers[j+1] = temp;
}
}
}
System.out.println("バブルソートでソートしました");
}
}クイックソートの実装
次に、クイックソートを実装するクラスを作成します。
public class QuickSortStrategy implements SortStrategy {
@Override
public void sort(int[] numbers) {
quickSort(numbers, 0, numbers.length - 1);
System.out.println("クイックソートでソートしました");
}
private void quickSort(int[] numbers, int low, int high) {
if (low < high) {
int pi = partition(numbers, low, high);
quickSort(numbers, low, pi - 1);
quickSort(numbers, pi + 1, high);
}
}
private int partition(int[] numbers, int low, int high) {
int pivot = numbers[high];
int i = (low - 1);
for (int j = low; j < high; j++) {
if (numbers[j] < pivot) {
i++;
int temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
}
}
int temp = numbers[i + 1];
numbers[i + 1] = numbers[high];
numbers[high] = temp;
return i + 1;
}
}Contextクラスを使ったソートアルゴリズムの切り替え
次に、Context クラスを使って、実行時にどのソートアルゴリズムを使用するかを動的に切り替えます。
public class SortContext {
private SortStrategy strategy;
public SortContext(SortStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(SortStrategy strategy) {
this.strategy = strategy;
}
public void executeSort(int[] numbers) {
strategy.sort(numbers);
}
}クライアントコードでの実行例
クライアントコードでは、データのサイズや特性に基づいて適切なソートアルゴリズムを選択し、SortContext クラスを介して実行します。
public class StrategyPatternSortDemo {
public static void main(String[] args) {
int[] numbers = {5, 2, 9, 1, 5, 6};
// 小規模データの場合はバブルソートを使用
SortContext context = new SortContext(new BubbleSortStrategy());
context.executeSort(numbers);
// 大規模データにはクイックソートを使用
context.setStrategy(new QuickSortStrategy());
context.executeSort(numbers);
}
}このように、ストラテジーパターンを使うことで、ソートアルゴリズムを状況に応じて動的に切り替えることができ、柔軟なシステムを構築できます。
アルゴリズムの具体例2: 支払い方法の切り替え
ストラテジーパターンは、支払い方法のようなビジネスロジックにおいても非常に有効です。クレジットカード、PayPal、銀行振込など、異なる支払い方法を動的に切り替えることができるため、利用者に柔軟な選択肢を提供できます。
支払い方法の選択
オンラインショッピングなどでは、複数の支払い方法を提供することが一般的です。ストラテジーパターンを利用することで、各支払い方法を個別に実装し、選択に応じて適切な処理を実行することが可能です。
Strategyインターフェースの定義
まず、すべての支払い方法が実装する共通のインターフェースを定義します。
public interface PaymentStrategy {
void pay(int amount);
}クレジットカード支払いの実装
クレジットカード支払いを実装するクラスです。カード情報を入力し、決済を行います。
public class CreditCardPaymentStrategy implements PaymentStrategy {
private String cardNumber;
private String cardHolderName;
private String cvv;
public CreditCardPaymentStrategy(String cardNumber, String cardHolderName, String cvv) {
this.cardNumber = cardNumber;
this.cardHolderName = cardHolderName;
this.cvv = cvv;
}
@Override
public void pay(int amount) {
System.out.println("クレジットカードで " + amount + " 円支払いました。");
}
}PayPal支払いの実装
次に、PayPalでの支払いを実装するクラスです。PayPalアカウントを使用して決済を行います。
public class PayPalPaymentStrategy implements PaymentStrategy {
private String email;
public PayPalPaymentStrategy(String email) {
this.email = email;
}
@Override
public void pay(int amount) {
System.out.println("PayPalアカウント " + email + " で " + amount + " 円支払いました。");
}
}銀行振込の実装
銀行振込による支払いを実装したクラスです。
public class BankTransferPaymentStrategy implements PaymentStrategy {
private String bankAccount;
public BankTransferPaymentStrategy(String bankAccount) {
this.bankAccount = bankAccount;
}
@Override
public void pay(int amount) {
System.out.println("銀行振込で " + amount + " 円支払いました。");
}
}Contextクラスを使った支払い方法の切り替え
Context クラスを作成して、実行時に支払い方法を選択できるようにします。
public class PaymentContext {
private PaymentStrategy paymentStrategy;
public PaymentContext(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void executePayment(int amount) {
paymentStrategy.pay(amount);
}
}クライアントコードでの実行例
クライアント側では、ユーザーの選択に基づいて支払い方法を動的に切り替えます。
public class StrategyPatternPaymentDemo {
public static void main(String[] args) {
// クレジットカード支払い
PaymentContext context = new PaymentContext(new CreditCardPaymentStrategy("123456789", "John Doe", "123"));
context.executePayment(10000);
// PayPal支払い
context.setPaymentStrategy(new PayPalPaymentStrategy("john.doe@example.com"));
context.executePayment(20000);
// 銀行振込支払い
context.setPaymentStrategy(new BankTransferPaymentStrategy("000123456789"));
context.executePayment(15000);
}
}このように、支払い方法をストラテジーパターンで実装することで、柔軟な支払いシステムを構築できます。新しい支払い方法を追加する際も、他のコードに影響を与えずに簡単に拡張可能です。
ストラテジーパターンを使ったパフォーマンスの向上
ストラテジーパターンは、システムのパフォーマンス最適化にも寄与します。特に、大規模なシステムや多様な操作を行うアプリケーションでは、アルゴリズムの選択や変更がパフォーマンスに大きな影響を与えることがあります。ここでは、ストラテジーパターンがどのようにパフォーマンス向上に役立つかを説明します。
1. アルゴリズムの最適な選択によるパフォーマンスの最適化
ストラテジーパターンを使用することで、特定の状況やデータセットに応じた最適なアルゴリズムを選択できます。例えば、ソートアルゴリズムにおいて、データのサイズや特性に応じてクイックソートやマージソートなど、最適なアルゴリズムを選ぶことができます。これにより、不要な計算リソースを節約し、システム全体のパフォーマンスを向上させることが可能です。
if (data.length < 100) {
context.setStrategy(new BubbleSortStrategy());
} else {
context.setStrategy(new QuickSortStrategy());
}
context.executeStrategy();このように、データ量に応じて軽量なアルゴリズムを選択することで、過剰なリソースの消費を抑えます。
2. 条件分岐の削減による処理効率の向上
ストラテジーパターンを使用することで、従来の if-else や switch 文を使用した複雑な条件分岐を排除でき、コードの可読性と実行効率が向上します。各アルゴリズムが独立したクラスに分離されているため、特定のアルゴリズムを選択する際に動的にクラスを指定するだけで、余計な条件分岐が不要になります。これにより、処理のオーバーヘッドを減らし、システムのレスポンスが向上します。
3. キャッシュやメモリ管理の改善
アルゴリズムの選択に応じて、メモリ使用量を最適化することが可能です。ストラテジーパターンを適切に設計することで、メモリを大量に消費するアルゴリズムを避けることができ、特定の状況ではメモリ消費の少ないアルゴリズムを選択することも可能です。例えば、大量のデータを扱う場合、効率的なメモリ管理を行うアルゴリズムを選ぶことで、ガベージコレクションの頻度を減らし、アプリケーションのパフォーマンスを高めることができます。
4. システム負荷に応じたアルゴリズムの適応
システム全体の負荷が高まった際に、軽量で高速なアルゴリズムを使用することで、リソースを節約し、レスポンス時間を短縮できます。逆に、リソースに余裕がある場合は、精度の高いアルゴリズムを選択することも可能です。このように、動的な負荷に応じたアルゴリズムの切り替えにより、効率的なシステム運用が可能となります。
5. 並列処理との組み合わせ
ストラテジーパターンを並列処理と組み合わせることで、さらにパフォーマンスを向上させることが可能です。例えば、大量のデータを並列で処理し、各スレッドで異なるアルゴリズムを適用することで、全体の処理速度を大幅に向上させることができます。Javaの ForkJoinPool や ExecutorService などを使用して、複数のストラテジーを同時に実行することも可能です。
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> {
context.setStrategy(new QuickSortStrategy());
context.executeStrategy();
});
executor.submit(() -> {
context.setStrategy(new MergeSortStrategy());
context.executeStrategy();
});
executor.shutdown();ストラテジーパターンを適切に活用することで、システムのパフォーマンスを効率的に管理し、最適化することが可能です。
ストラテジーパターンと他のデザインパターンの違い
ストラテジーパターンは、他のデザインパターンとよく比較されますが、それぞれ異なる目的や利点があります。ここでは、特にデコレーターパターンやファクトリーパターンとの違いを見ていきましょう。
1. ストラテジーパターン vs. デコレーターパターン
ストラテジーパターンとデコレーターパターンは、どちらもオブジェクトの振る舞いを動的に変えるために使用されますが、そのアプローチには違いがあります。
共通点
どちらのパターンもオブジェクトの機能や振る舞いを動的に変更するために使われ、特定の操作に対して異なるアルゴリズムや処理を選択できます。また、オープン/クローズドの原則に従っており、新しい機能を追加する際に既存のコードを変更せずに拡張可能です。
相違点
ストラテジーパターンは、特定のアルゴリズムを独立したクラスで実装し、実行時に選択するという方式です。これは、主に振る舞いを差し替えることを目的としています。一方、デコレーターパターンは、オブジェクトに対して機能を追加することが目的であり、既存のオブジェクトをラップして機能を拡張します。
例えば、ストラテジーパターンではソートアルゴリズムを動的に切り替えることが可能ですが、デコレーターパターンでは、出力にログを追加するなど、オブジェクトに追加の機能を重ねていくことが可能です。
// ストラテジー: ソートアルゴリズムを切り替える
context.setStrategy(new QuickSortStrategy());
context.executeStrategy();
// デコレーター: 機能を追加
Component component = new LoggingDecorator(new ConcreteComponent());
component.operation();2. ストラテジーパターン vs. ファクトリーパターン
ファクトリーパターンは、オブジェクトの生成を集中管理するために使われるパターンで、主に「どのオブジェクトを生成するか」を決定することに焦点を当てています。一方、ストラテジーパターンは「どの振る舞いを実行するか」を実行時に動的に選択することを目的としています。
共通点
両パターンとも、オブジェクト指向の柔軟性を高め、動的な変更をサポートします。特定の条件に応じて異なる処理を提供する点では共通していますが、それを実現する方法と目的が異なります。
相違点
ファクトリーパターンは、オブジェクトの生成ロジックを抽象化し、どのクラスのオブジェクトを作成するかを決定するために使われます。一方、ストラテジーパターンは、オブジェクト自体は既に存在しており、振る舞いを変更するために使用されます。ファクトリーパターンは、複雑なオブジェクト生成のカプセル化に優れており、ストラテジーパターンは動的なアルゴリズム選択に優れています。
// ファクトリーパターン：オブジェクト生成を管理
PaymentFactory factory = new PaymentFactory();
PaymentStrategy payment = factory.createPaymentMethod("PayPal");
payment.pay(amount);
// ストラテジーパターン：アルゴリズムを動的に変更
context.setStrategy(new CreditCardPaymentStrategy("123456"));
context.executeStrategy();3. ストラテジーパターンの適用場面
ストラテジーパターンは、異なるアルゴリズムやロジックを動的に切り替える必要がある場合に適しています。特に、頻繁にアルゴリズムの変更や追加が行われる状況では、このパターンが有効です。
例えば、支払い方法の切り替えや、ゲームAIの挙動を動的に変化させる場合、ストラテジーパターンがよく利用されます。また、他のデザインパターンと組み合わせることで、より強力で柔軟なアプリケーションを構築できます。
これらのパターンを理解し、適切に使い分けることで、柔軟で保守性の高いシステムを設計することが可能になります。
ストラテジーパターンの応用例
ストラテジーパターンは、さまざまな分野で柔軟なアルゴリズムの切り替えが求められるシステムに応用されています。ここでは、ゲーム開発やデータ処理など、実際のプロジェクトでの応用例を紹介します。
1. ゲーム開発におけるAIの行動パターン切り替え
ゲーム開発では、キャラクターや敵のAIが異なる状況に応じてさまざまな行動パターンをとる必要があります。例えば、敵キャラクターがプレイヤーに近づく、逃げる、攻撃するなどの行動を動的に切り替える場合に、ストラテジーパターンが有効です。これにより、各行動を独立したクラスとして実装し、ゲームの状況に応じて行動パターンを動的に選択できます。
public interface EnemyStrategy {
void execute();
}
public class AggressiveStrategy implements EnemyStrategy {
@Override
public void execute() {
System.out.println("敵が攻撃を開始します！");
}
}
public class DefensiveStrategy implements EnemyStrategy {
@Override
public void execute() {
System.out.println("敵が防御態勢に入ります！");
}
}Context クラスを用いて、敵のAI行動を選択し、状況に応じて切り替えます。
public class EnemyContext {
private EnemyStrategy strategy;
public void setStrategy(EnemyStrategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
// 使用例
EnemyContext context = new EnemyContext();
context.setStrategy(new AggressiveStrategy());
context.executeStrategy();
context.setStrategy(new DefensiveStrategy());
context.executeStrategy();この方法を利用することで、ゲームプレイの中でAIの行動を柔軟に変化させることができます。新しい行動パターンを追加する際も、既存のコードに影響を与えずに拡張が可能です。
2. データ処理におけるフィルタリングアルゴリズムの切り替え
ビッグデータやデータサイエンスの分野では、データセットに対して異なるフィルタリングや分析アルゴリズムを適用することがよくあります。ストラテジーパターンを使うことで、データの種類や処理の目的に応じてアルゴリズムを動的に切り替えることができます。
例えば、特定の条件に基づいて異なるフィルタリング戦略を選択する場合、ストラテジーパターンが効果的です。
public interface FilterStrategy {
void filter(List<String> data);
}
public class ContainsFilterStrategy implements FilterStrategy {
private String keyword;
public ContainsFilterStrategy(String keyword) {
this.keyword = keyword;
}
@Override
public void filter(List<String> data) {
data.stream()
.filter(s -> s.contains(keyword))
.forEach(System.out::println);
}
}
public class LengthFilterStrategy implements FilterStrategy {
private int length;
public LengthFilterStrategy(int length) {
this.length = length;
}
@Override
public void filter(List<String> data) {
data.stream()
.filter(s -> s.length() > length)
.forEach(System.out::println);
}
}Context クラスを使って、必要に応じてフィルタリングアルゴリズムを動的に変更します。
public class FilterContext {
private FilterStrategy strategy;
public FilterContext(FilterStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(FilterStrategy strategy) {
this.strategy = strategy;
}
public void executeFilter(List<String> data) {
strategy.filter(data);
}
}
// 使用例
List<String> data = Arrays.asList("apple", "banana", "cherry", "date");
FilterContext context = new FilterContext(new ContainsFilterStrategy("a"));
context.executeFilter(data);
context.setStrategy(new LengthFilterStrategy(5));
context.executeFilter(data);このように、データのフィルタリングロジックを状況に応じて切り替えることができ、複雑なデータ処理を柔軟に実装できます。
3. GUIアプリケーションにおける描画アルゴリズムの切り替え
GUIアプリケーションでは、描画処理のアルゴリズムをストラテジーパターンで切り替えることが可能です。たとえば、異なる描画スタイルやレンダリング手法を使用する際、ユーザーの操作や状況に応じて描画アルゴリズムを動的に変更できます。
public interface DrawingStrategy {
void draw();
}
public class LineDrawingStrategy implements DrawingStrategy {
@Override
public void draw() {
System.out.println("直線を描画します");
}
}
public class CircleDrawingStrategy implements DrawingStrategy {
@Override
public void draw() {
System.out.println("円を描画します");
}
}Context クラスで描画方法を動的に選択します。
public class DrawingContext {
private DrawingStrategy strategy;
public void setStrategy(DrawingStrategy strategy) {
this.strategy = strategy;
}
public void executeDraw() {
strategy.draw();
}
}
// 使用例
DrawingContext context = new DrawingContext();
context.setStrategy(new LineDrawingStrategy());
context.executeDraw();
context.setStrategy(new CircleDrawingStrategy());
context.executeDraw();GUIアプリケーションでユーザーが選んだオプションに応じて描画方法を変更でき、インタラクティブなアプリケーションを構築する際に有効です。
ストラテジーパターンを使うことで、異なるシナリオに適応しやすいコードを実装でき、システムの柔軟性と拡張性を高めることができます。
演習問題: 自分でアルゴリズムを切り替えるコードを書いてみよう
ここでは、ストラテジーパターンを実際に実装してみる演習問題を提供します。以下の手順に従って、アルゴリズムの動的な切り替えを試してみてください。
演習課題の概要
今回の課題では、異なる「割引アルゴリズム」を実装し、状況に応じて割引方法を切り替えるプログラムを作成してもらいます。たとえば、クリスマスセールや新規ユーザー向けの割引など、複数の割引アルゴリズムを用意し、実行時に選択できるようにします。
課題の手順
- Strategyインターフェースを定義する
DiscountStrategyインターフェースを作成し、applyDiscount()メソッドを定義してください。このメソッドは、購入金額に対して割引を適用し、最終価格を返すものとします。
public interface DiscountStrategy {
double applyDiscount(double price);
}- 具体的な割引アルゴリズムクラスを作成する
2つ以上の具体的な割引アルゴリズムを作成してください。例えば、次のような割引を実装できます：
- クリスマス割引：10%割引
- 新規ユーザー割引：500円の固定割引
public class ChristmasDiscountStrategy implements DiscountStrategy {
@Override
public double applyDiscount(double price) {
return price * 0.9; // 10%割引
}
}
public class NewUserDiscountStrategy implements DiscountStrategy {
@Override
public double applyDiscount(double price) {
return price - 500; // 500円の割引
}
}- Contextクラスを作成する
DiscountContextクラスを作成し、選択したDiscountStrategyを実行するクラスを実装してください。このクラスは、購入金額と現在の割引戦略に基づいて最終価格を計算します。
public class DiscountContext {
private DiscountStrategy strategy;
public DiscountContext(DiscountStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(DiscountStrategy strategy) {
this.strategy = strategy;
}
public double calculatePrice(double price) {
return strategy.applyDiscount(price);
}
}- クライアントコードを作成する
最後に、クライアントコードで割引アルゴリズムを動的に切り替え、適用します。最初にChristmasDiscountStrategyを使用し、次にNewUserDiscountStrategyを使用して結果を確認してください。
public class StrategyPatternDiscountDemo {
public static void main(String[] args) {
double price = 10000; // 商品の価格
// クリスマス割引を適用
DiscountContext context = new DiscountContext(new ChristmasDiscountStrategy());
System.out.println("クリスマス割引後の価格: " + context.calculatePrice(price));
// 新規ユーザー割引を適用
context.setStrategy(new NewUserDiscountStrategy());
System.out.println("新規ユーザー割引後の価格: " + context.calculatePrice(price));
}
}演習後のポイント
この演習を通じて、ストラテジーパターンを利用してアルゴリズムの切り替えを実装する経験を積んでください。今後、異なるアルゴリズムを動的に適用したいときにこのパターンが役立つはずです。
拡張課題：新しい割引アルゴリズムを追加する場合、既存のコードに影響を与えずに DiscountStrategy を実装する新しいクラスを追加するだけで済むことに注目してください。
まとめ
本記事では、Javaにおけるストラテジーパターンの基本概念から、アルゴリズムの動的な切り替え方法について解説しました。ストラテジーパターンは、複数のアルゴリズムや処理を柔軟に切り替えることができ、保守性や拡張性を高めるために非常に有用です。ゲームAIの行動切り替えや支払い方法の選択、データ処理など、さまざまな実践的な応用例を通じて、パターンの有効性を理解していただけたと思います。適切な場面でストラテジーパターンを活用し、柔軟で拡張性のあるシステムを構築していきましょう。
コメント