Javaのオブジェクト指向プログラミングにおいて、ポリモーフィズム（多態性）は、コードの再利用性と柔軟性を高める重要な概念です。特に、Javaのインターフェースを利用することで、異なるクラス間で共通の動作を持たせつつ、それぞれのクラスが独自の実装を持つことが可能になります。本記事では、インターフェースを活用してポリモーフィズムを効果的に実装する方法を具体例を交えながら解説し、実践的なプログラム設計の技法を学びます。
ポリモーフィズムとは
ポリモーフィズムとは、オブジェクト指向プログラミングにおいて、同じ操作を異なるクラスのオブジェクトで実行できる性質を指します。Javaでは、同じメソッド名で異なる実装を持つ複数のクラスを扱うことができるため、コードの柔軟性と再利用性が向上します。これにより、コードの変更を最小限に抑えつつ、新しい機能を追加することが容易になります。ポリモーフィズムは、インターフェースや継承を活用することで実現され、開発者に強力な設計ツールを提供します。
インターフェースの基本
Javaにおけるインターフェースは、クラスが実装すべきメソッドの宣言を含む型定義の一種です。インターフェースは、メソッドのシグネチャ（名前、引数、戻り値の型）だけを定義し、具体的な実装は持ちません。これにより、異なるクラスが同じインターフェースを実装することで、共通の動作を提供しつつ、それぞれのクラスで独自の実装を持たせることが可能になります。
例えば、AnimalというインターフェースにmakeSound()メソッドを定義した場合、DogクラスとCatクラスはそれぞれこのメソッドを異なる方法で実装します。これにより、Animal型のオブジェクトを扱うコードは、DogやCatの詳細を気にすることなく、makeSound()を呼び出すことができるようになります。インターフェースは、このようにしてポリモーフィズムの基盤を提供します。
インターフェースを使ったポリモーフィズムの実装例
Javaでインターフェースを使用してポリモーフィズムを実装する具体例を見てみましょう。例えば、動物の鳴き声を表現するAnimalインターフェースを考えてみます。このインターフェースにはmakeSound()メソッドが定義されており、これを実装するクラスごとに異なる鳴き声を表現します。
// Animalインターフェースの定義
interface Animal {
void makeSound();
}
// Dogクラスの実装
class Dog implements Animal {
public void makeSound() {
System.out.println("Woof!");
}
}
// Catクラスの実装
class Cat implements Animal {
public void makeSound() {
System.out.println("Meow!");
}
}
public class Main {
public static void main(String[] args) {
// インターフェースを使用したポリモーフィズム
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.makeSound(); // 出力: Woof!
myCat.makeSound(); // 出力: Meow!
}
}この例では、Animalインターフェースを使用して、DogとCatクラスがそれぞれ異なる鳴き声を持つメソッドを実装しています。MainクラスでAnimal型のオブジェクトを宣言し、DogやCatのインスタンスを代入することで、makeSound()メソッドを呼び出す際にポリモーフィズムが発揮されます。
このように、インターフェースを使って共通のメソッドを定義し、各クラスが独自の実装を提供することで、異なるクラス間で一貫したインターフェースを利用できるようになります。これにより、コードの柔軟性が高まり、後からクラスを追加しても既存のコードに影響を与えることなく、新しい機能を追加できます。
インターフェースと抽象クラスの違い
Javaには、インターフェースと抽象クラスという2つの主要な構造があり、どちらもポリモーフィズムの実現に役立ちますが、それぞれの使い方には明確な違いがあります。
インターフェースの特徴
インターフェースは、クラスが実装すべきメソッドのシグネチャを定義するだけで、具体的な実装を持たないことが特徴です。これにより、クラスに多重継承のような形で複数のインターフェースを実装させることが可能です。また、インターフェースは、実装するクラスに具体的な行動を強制することなく、共通の動作を定義する役割を果たします。
interface Flyable {
void fly();
}
interface Swimable {
void swim();
}
class Duck implements Flyable, Swimable {
public void fly() {
System.out.println("Duck is flying!");
}
public void swim() {
System.out.println("Duck is swimming!");
}
}この例では、DuckクラスがFlyableとSwimableの両方のインターフェースを実装しており、飛ぶ動作と泳ぐ動作を別々に定義しています。
抽象クラスの特徴
一方、抽象クラスは、メソッドのシグネチャだけでなく、部分的な実装を持つことができます。また、インターフェースとは異なり、抽象クラスは多重継承ができません。抽象クラスは、共通の機能を提供しつつ、具体的な実装をサブクラスに委ねることが主な目的です。
abstract class Animal {
abstract void makeSound();
void sleep() {
System.out.println("Sleeping...");
}
}
class Dog extends Animal {
public void makeSound() {
System.out.println("Woof!");
}
}この例では、Animalクラスが抽象クラスであり、makeSound()メソッドを抽象メソッドとして定義しつつ、sleep()メソッドの具体的な実装を提供しています。
使い分けのポイント
- インターフェースは、複数のクラスで共通のメソッドを定義し、クラスがそれらを実装する際の共通の契約を提供するために使用します。特に、クラスが異なるタイプの動作を組み合わせて実装する必要がある場合に有効です。
- 抽象クラスは、いくつかの共通機能を共有し、かつその一部をサブクラスで特化させたい場合に使用します。共通の基底クラスを提供しつつ、一部の動作をサブクラスに委ねることができます。
それぞれの特徴を理解し、状況に応じて使い分けることで、より柔軟で再利用可能なコードを作成することが可能です。
インターフェースを使ったコードのメリット
インターフェースを使用することで、Javaのコードは柔軟性と保守性が大幅に向上します。ここでは、インターフェースを利用することで得られる具体的なメリットについて説明します。
1. 柔軟なコード設計
インターフェースを利用することで、異なるクラスが共通のメソッドを実装することが可能になり、コードの柔軟性が向上します。これにより、クラスが持つ具体的な実装に依存することなく、インターフェースを通じて一貫した操作を行うことができます。たとえば、異なる動作を持つ複数のクラスに同じインターフェースを実装させることで、統一された方法でそれらのオブジェクトを操作できるようになります。
2. コードの再利用性の向上
インターフェースを使用することで、共通の動作を持つ異なるクラスに対して同じコードを再利用できるようになります。これにより、コードの重複を避け、メンテナンスが容易になります。たとえば、リストやコレクションなどのデータ構造を扱う際に、同じインターフェースを使用することで、異なる型のオブジェクトを同じ操作で扱うことができます。
3. プラグアンドプレイの設計が可能
インターフェースを利用することで、異なる実装を簡単に交換することが可能になります。これにより、コードの一部を変更することなく、新しい機能やクラスを追加することができます。たとえば、支払い処理システムを設計する際に、PaymentMethodというインターフェースを定義しておけば、クレジットカードや電子マネーなど、異なる支払い手段を簡単に追加することができます。
4. テストの容易さ
インターフェースを使ってコードを分離することで、単体テストが容易になります。モックオブジェクトやスタブを使って、実際のクラスの代わりにインターフェースを利用することで、他のクラスに影響を与えることなく特定の機能をテストすることができます。これにより、テストがより効率的に行えるようになります。
5. デザインパターンの活用
インターフェースは、数多くのデザインパターン（たとえば、StrategyパターンやFactoryパターン）で重要な役割を果たします。これらのパターンを活用することで、より保守性が高く、拡張性のあるコード設計が可能になります。
これらのメリットにより、インターフェースを活用することで、Javaのコードはより柔軟でメンテナンスしやすいものとなります。結果として、開発の効率が向上し、将来的な変更にも強い設計を実現できます。
インターフェースと継承の併用
インターフェースと継承を組み合わせて使用することで、Javaのコードはさらに柔軟で再利用可能になります。これにより、共通の動作を提供しつつ、具体的な実装をサブクラスに委ねることが可能になります。
インターフェースと継承の基本的な使い方
インターフェースは、クラスが実装すべき動作を定義し、継承はクラス間で共通の機能や属性を共有するために使用されます。たとえば、Vehicleという抽象クラスを作成し、その中に共通の属性（例：速度、重量）と基本的なメソッド（例：start()、stop()）を定義します。そして、FlyableやSwimableといったインターフェースを使用して、具体的な乗り物が飛行や航行などの動作を実装するようにします。
// 抽象クラス
abstract class Vehicle {
int speed;
int weight;
void start() {
System.out.println("Vehicle is starting");
}
void stop() {
System.out.println("Vehicle is stopping");
}
}
// インターフェース
interface Flyable {
void fly();
}
interface Swimable {
void swim();
}
// サブクラスとインターフェースの実装
class Airplane extends Vehicle implements Flyable {
public void fly() {
System.out.println("Airplane is flying");
}
}
class Boat extends Vehicle implements Swimable {
public void swim() {
System.out.println("Boat is swimming");
}
}この例では、AirplaneクラスとBoatクラスがそれぞれVehicleを継承しつつ、FlyableおよびSwimableインターフェースを実装しています。これにより、これらのクラスは共通のVehicle属性とメソッドを持ちながら、それぞれの動作を定義することができます。
設計パターンでの応用例
インターフェースと継承の併用は、さまざまな設計パターンで応用されます。例えば、Strategyパターンでは、動作をインターフェースで定義し、クラスごとに異なるアルゴリズムを提供します。これにより、動作の変更が必要な場合でもクラスの構造を変更することなく、新しいアルゴリズムを簡単に追加できます。
// Strategyパターンの例
interface PaymentStrategy {
void pay(int amount);
}
class CreditCardPayment implements PaymentStrategy {
public void pay(int amount) {
System.out.println("Paid " + amount + " using Credit Card");
}
}
class PayPalPayment implements PaymentStrategy {
public void pay(int amount) {
System.out.println("Paid " + amount + " using PayPal");
}
}
class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(int amount) {
strategy.pay(amount);
}
}この例では、PaymentStrategyインターフェースを実装する異なる支払い方法があり、PaymentContextクラスはどの支払い方法を使用するかを決定します。これにより、支払い方法を簡単に切り替えたり、新しい支払い方法を追加することが可能になります。
インターフェースと継承の利点
- 柔軟性の向上: インターフェースを用いて異なるクラスに共通の動作を提供しつつ、継承を用いて共通の機能を持たせることで、コードは柔軟かつ効率的になります。
- 再利用性の向上: インターフェースと継承を併用することで、コードの再利用性が向上し、開発効率が上がります。
- メンテナンス性の向上: コードの構造が明確になり、各クラスの責務が分離されるため、メンテナンスが容易になります。
このように、インターフェースと継承を組み合わせることで、Javaのコードはより強力で管理しやすくなります。これらを適切に活用することで、複雑なシステムでも効率的に設計・開発が可能となります。
実践的な応用例
インターフェースとポリモーフィズムを活用した実践的な応用例を紹介します。ここでは、より現実的なシナリオとして、eコマースシステムにおける注文処理のフレームワークを構築する例を見ていきます。
シナリオ: 支払い処理システムの設計
多くのeコマースプラットフォームでは、クレジットカードやPayPal、銀行振込など、さまざまな支払い方法を提供しています。各支払い方法には異なる処理が必要ですが、同じインターフェースを使って一貫した方法で処理を行うことができます。
支払いインターフェースの定義
まず、支払い処理を共通化するために、PaymentProcessorというインターフェースを定義します。このインターフェースは、processPayment()という共通のメソッドを持ちます。
interface PaymentProcessor {
void processPayment(double amount);
}支払い方法の具体的な実装
次に、異なる支払い方法ごとにインターフェースを実装したクラスを作成します。各クラスはprocessPayment()メソッドを実装し、支払い方法に応じた処理を行います。
class CreditCardProcessor implements PaymentProcessor {
public void processPayment(double amount) {
System.out.println("Processing credit card payment of $" + amount);
// クレジットカード処理ロジックをここに追加
}
}
class PayPalProcessor implements PaymentProcessor {
public void processPayment(double amount) {
System.out.println("Processing PayPal payment of $" + amount);
// PayPal処理ロジックをここに追加
}
}
class BankTransferProcessor implements PaymentProcessor {
public void processPayment(double amount) {
System.out.println("Processing bank transfer payment of $" + amount);
// 銀行振込処理ロジックをここに追加
}
}注文処理システムでの利用
注文処理システムでは、選択された支払い方法に応じて適切な支払い処理クラスをインスタンス化し、processPayment()メソッドを呼び出します。このように、インターフェースを利用することで、支払い処理の詳細に依存せずに一貫した方法で処理を行うことができます。
class Order {
private PaymentProcessor paymentProcessor;
public Order(PaymentProcessor paymentProcessor) {
this.paymentProcessor = paymentProcessor;
}
public void completeOrder(double amount) {
paymentProcessor.processPayment(amount);
System.out.println("Order completed!");
}
}
public class Main {
public static void main(String[] args) {
PaymentProcessor processor = new CreditCardProcessor();
Order order = new Order(processor);
order.completeOrder(100.0);
// PayPalでの支払い
processor = new PayPalProcessor();
order = new Order(processor);
order.completeOrder(200.0);
}
}この例では、OrderクラスがPaymentProcessorインターフェースを利用して、支払い方法に依存しない形で注文を処理しています。支払い方法を変更する際も、インターフェースを実装した別のクラスを使用するだけで、注文処理のロジックを変更する必要がありません。
インターフェースを用いた拡張の容易さ
この設計では、新しい支払い方法を追加する際にも既存のコードに影響を与えることなく、簡単に拡張できます。たとえば、新たにモバイル決済を追加する場合、MobilePaymentProcessorクラスを作成してPaymentProcessorインターフェースを実装するだけです。
class MobilePaymentProcessor implements PaymentProcessor {
public void processPayment(double amount) {
System.out.println("Processing mobile payment of $" + amount);
// モバイル決済処理ロジックをここに追加
}
}この新しいクラスを既存のOrderクラスに組み込むだけで、モバイル決済をサポートする注文処理が可能になります。このように、インターフェースを使った設計は、システムの拡張性を高め、保守を容易にします。
インターフェースを活用することで、コードの再利用性と柔軟性が大幅に向上し、開発プロセスが効率的になります。これにより、複雑なシステムでも容易に管理・拡張できるようになります。
インターフェースのトラブルシューティング
インターフェースを使用する際には、いくつかのよくある問題に直面することがあります。ここでは、インターフェースを利用したコードで発生しやすい問題とその解決策を紹介します。
1. 実装漏れによるコンパイルエラー
インターフェースを実装するクラスは、インターフェース内で宣言されたすべてのメソッドを具体的に実装しなければなりません。これを怠ると、コンパイル時にエラーが発生します。
問題例:
interface Vehicle {
void start();
void stop();
}
class Car implements Vehicle {
public void start() {
System.out.println("Car is starting");
}
// stop() メソッドが未実装
}解決策:
未実装のメソッドstop()を実装するか、クラスをabstractとして宣言し、サブクラスでこのメソッドを実装するようにします。
class Car implements Vehicle {
public void start() {
System.out.println("Car is starting");
}
public void stop() {
System.out.println("Car is stopping");
}
}2. デフォルトメソッドの競合
Java 8以降では、インターフェースにデフォルトメソッドを定義できるようになりましたが、複数のインターフェースから同じデフォルトメソッドを継承した場合、競合が発生することがあります。
問題例:
interface A {
default void show() {
System.out.println("Interface A");
}
}
interface B {
default void show() {
System.out.println("Interface B");
}
}
class C implements A, B {
// 競合によりコンパイルエラーが発生
}解決策:
クラスCでshow()メソッドをオーバーライドし、どのインターフェースのメソッドを使用するかを明示的に指定します。
class C implements A, B {
public void show() {
A.super.show(); // または B.super.show();
}
}3. インターフェースの変更による影響
インターフェースを変更すると、それを実装するすべてのクラスに影響を与える可能性があります。新しいメソッドを追加した場合、そのメソッドをすべての実装クラスで実装する必要があります。
問題例:
interface Vehicle {
void start();
void stop();
// 新たに追加されたメソッド
void accelerate();
}
// 既存の実装クラスにコンパイルエラーが発生
class Car implements Vehicle {
public void start() {
System.out.println("Car is starting");
}
public void stop() {
System.out.println("Car is stopping");
}
// accelerate() メソッドが未実装
}解決策:
新たに追加されたメソッドを既存のクラスで実装するか、デフォルトメソッドとして提供することで影響を最小限に抑えます。
interface Vehicle {
void start();
void stop();
default void accelerate() {
System.out.println("Default acceleration");
}
}4. インターフェースの多重実装による意図しない動作
複数のインターフェースを実装する場合、同じ名前のメソッドを複数のインターフェースから継承することがあります。この場合、意図しない動作が発生する可能性があります。
問題例:
interface Printer {
void print();
}
interface Scanner {
void print(); // 意図せず同じ名前のメソッドを定義
}
class MultiFunctionDevice implements Printer, Scanner {
public void print() {
System.out.println("Printing...");
// どのインターフェースのメソッドを呼び出しているか曖昧になる
}
}解決策:
メソッド名を明確にするか、オーバーライドされたメソッドで意図的な動作を実装して、どのインターフェースに対応するかを明示します。
class MultiFunctionDevice implements Printer, Scanner {
public void print() {
System.out.println("Multi-function printing");
}
}5. インスタンスのキャストによる実行時エラー
インターフェースの実装クラスをキャストする際、キャストが不正である場合にClassCastExceptionが発生することがあります。
問題例:
Printer printer = new MultiFunctionDevice();
Scanner scanner = (Scanner) printer; // 実行時にエラーが発生する可能性あり解決策:
キャストの前にinstanceofを使用して、オブジェクトが適切な型であることを確認します。
if (printer instanceof Scanner) {
Scanner scanner = (Scanner) printer;
scanner.print();
} else {
System.out.println("Cannot cast to Scanner");
}これらのトラブルシューティング方法を知っておくことで、インターフェースを利用した開発の際に発生しがちな問題を迅速に解決し、スムーズな開発を進めることができます。
より高度なポリモーフィズムの実装
Javaのポリモーフィズムをさらに効果的に活用するために、ジェネリクスやラムダ式を組み合わせた高度な実装方法を見ていきます。これにより、コードの柔軟性が一層向上し、複雑な要件にも対応できるようになります。
1. ジェネリクスを使った柔軟なインターフェース設計
ジェネリクスは、クラスやインターフェースを型に依存しない形で設計するための強力な機能です。これにより、異なる型に対して同じインターフェースを使用し、ポリモーフィズムを拡張できます。
例: ジェネリックなデータ処理インターフェース
interface DataProcessor<T> {
void process(T data);
}
class StringProcessor implements DataProcessor<String> {
public void process(String data) {
System.out.println("Processing string: " + data);
}
}
class IntegerProcessor implements DataProcessor<Integer> {
public void process(Integer data) {
System.out.println("Processing integer: " + data);
}
}
public class Main {
public static void main(String[] args) {
DataProcessor<String> stringProcessor = new StringProcessor();
stringProcessor.process("Hello, World!");
DataProcessor<Integer> integerProcessor = new IntegerProcessor();
integerProcessor.process(100);
}
}この例では、DataProcessorインターフェースがジェネリクスを使用しており、異なる型（StringやInteger）に対して共通の処理を提供しています。これにより、型に依存しない柔軟なコード設計が可能となります。
2. ラムダ式によるシンプルなポリモーフィズムの実装
Java 8で導入されたラムダ式は、簡潔に関数型インターフェースを実装する方法を提供します。これにより、コードがより読みやすく、保守しやすくなります。
例: ラムダ式を使ったカスタムフィルター
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 偶数フィルターをラムダ式で定義
Predicate<Integer> evenFilter = n -> n % 2 == 0;
// フィルター処理を行う
List<Integer> evenNumbers = filter(numbers, evenFilter);
System.out.println("Even numbers: " + evenNumbers);
}
public static List<Integer> filter(List<Integer> list, Predicate<Integer> filter) {
List<Integer> result = new ArrayList<>();
for (Integer number : list) {
if (filter.test(number)) {
result.add(number);
}
}
return result;
}
}この例では、Predicateインターフェースを使用して、リストから偶数のみをフィルタリングする処理をラムダ式で簡潔に実装しています。ラムダ式を用いることで、コードが短く、直感的になります。
3. デフォルトメソッドを活用したインターフェースの拡張
デフォルトメソッドは、インターフェースにメソッドの実装を提供する機能であり、既存のコードに影響を与えることなくインターフェースを拡張する手段を提供します。
例: デフォルトメソッドでインターフェースを拡張
interface Printable {
void print();
// デフォルトメソッドの追加
default void printWithPrefix(String prefix) {
System.out.println(prefix + ": " + toString());
}
}
class Document implements Printable {
private String content;
public Document(String content) {
this.content = content;
}
public void print() {
System.out.println("Document content: " + content);
}
@Override
public String toString() {
return content;
}
}
public class Main {
public static void main(String[] args) {
Printable doc = new Document("Java Programming Guide");
doc.print(); // 通常のプリントメソッド
doc.printWithPrefix("Title"); // デフォルトメソッドを利用
}
}この例では、PrintableインターフェースにデフォルトメソッドprintWithPrefix()を追加し、既存のDocumentクラスに変更を加えることなく新しい機能を提供しています。これにより、柔軟な拡張が可能になります。
4. ストリームAPIとの組み合わせ
ストリームAPIは、データ操作を効率化するための強力なツールです。インターフェースと組み合わせることで、複雑なデータ処理も簡潔に記述できます。
例: ストリームAPIを使用したデータのフィルタリングと集計
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> words = List.of("apple", "banana", "cherry", "date", "elderberry");
// ストリームAPIで文字数が5以上の単語をフィルタリングし、リストに収集
List<String> filteredWords = words.stream()
.filter(word -> word.length() >= 5)
.collect(Collectors.toList());
System.out.println("Filtered words: " + filteredWords);
}
}この例では、ストリームAPIを利用して、リスト内の単語をフィルタリングし、指定された条件に合致する単語のみを収集しています。ストリームAPIを使用することで、データ操作が直感的かつ効率的に行えます。
5. ポリモーフィズムと並行プログラミング
ポリモーフィズムを並行プログラミングと組み合わせることで、スケーラブルなアプリケーションを設計することが可能です。ExecutorServiceを使用して、さまざまなタスクを並行して実行する例を見てみましょう。
例: ExecutorServiceを使った並行タスクの実行
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
interface Task {
void execute();
}
class PrintTask implements Task {
private String message;
public PrintTask(String message) {
this.message = message;
}
public void execute() {
System.out.println("Executing task: " + message);
}
}
public class Main {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
// 複数のタスクを並行して実行
executor.submit(() -> new PrintTask("Task 1").execute());
executor.submit(() -> new PrintTask("Task 2").execute());
executor.submit(() -> new PrintTask("Task 3").execute());
executor.shutdown();
}
}この例では、ExecutorServiceを使用して複数のタスクを並行して実行しています。Taskインターフェースを使用することで、実行するタスクの種類に依存せず、柔軟に並行処理を行うことができます。
これらの高度なポリモーフィズムの実装方法を取り入れることで、Javaのコードはさらに柔軟で強力なものになります。これにより、より複雑な要件にも対応でき、保守性や拡張性を向上させることができます。
練習問題
これまで学んだインターフェースを使ったポリモーフィズムの知識を深めるために、いくつかの練習問題を用意しました。これらの問題を解くことで、インターフェースとポリモーフィズムを実際に使いこなせるようになります。
問題1: 支払い処理システムの拡張
前述の支払い処理システムに、新しい支払い方法「Cryptocurrency」を追加してください。この支払い方法は、PaymentProcessorインターフェースを実装し、任意の暗号通貨での支払いを処理するようにします。
要求事項:
CryptocurrencyProcessorクラスを作成し、PaymentProcessorインターフェースを実装してください。- 実装したクラスで
processPayment()メソッドをオーバーライドし、支払い処理のロジックを追加してください。 Mainクラスで、新しい支払い方法を使用した注文を処理してください。
問題2: 汎用データ処理クラスの作成
ジェネリクスを使用して、任意のデータ型に対して処理を行うGenericProcessor<T>クラスを作成してください。このクラスは、指定されたデータを受け取り、process()メソッドで処理を行います。
要求事項:
- ジェネリクスを使用して、データ型に依存しない
GenericProcessor<T>クラスを作成してください。 - このクラスに
process()メソッドを定義し、データを処理する機能を持たせてください。 Mainクラスで、文字列と整数のデータをそれぞれ処理するインスタンスを作成し、テストしてください。
問題3: ストリームAPIを用いたフィルタリング
与えられたリストから、長さが5文字以上の単語をフィルタリングし、それらを大文字に変換した新しいリストを作成してください。ストリームAPIを使用してこの処理を実装してください。
要求事項:
- リスト
List<String> wordsに複数の単語を格納してください。 - ストリームAPIを使用して、長さが5文字以上の単語をフィルタリングし、大文字に変換してください。
- 結果を新しいリストに収集し、
Mainクラスで結果を表示してください。
問題4: 複数のインターフェースを実装したクラスの設計
FlyableとSwimableの2つのインターフェースを持つAmphibiousVehicleクラスを設計してください。このクラスは、水上と空中の両方で移動する機能を持ちます。
要求事項:
Flyableインターフェースにはfly()メソッドを、Swimableインターフェースにはswim()メソッドを定義してください。AmphibiousVehicleクラスを作成し、これらのインターフェースを実装してください。Mainクラスで、AmphibiousVehicleオブジェクトを作成し、fly()およびswim()メソッドを呼び出して動作を確認してください。
これらの練習問題に取り組むことで、インターフェースとポリモーフィズムを実際にコードで活用する力が身に付きます。実際にコードを書いて試してみてください。
まとめ
本記事では、Javaにおけるインターフェースを使ったポリモーフィズムの実装方法について、基本から高度な応用まで幅広く解説しました。インターフェースを活用することで、柔軟で拡張性の高いコード設計が可能になり、システムの保守性が向上します。また、ジェネリクスやラムダ式、ストリームAPIとの組み合わせにより、さらに強力なポリモーフィズムを実現できることを学びました。これらの知識を活用し、より複雑なプログラムでも効率的に設計・開発を進められるようになりましょう。
コメント