Javaは、オブジェクト指向プログラミングの世界で広く使われている言語であり、その強力な機能である「継承」と「ポリモーフィズム」は、柔軟かつ再利用可能なコードを設計する上で不可欠な要素です。これらの概念を効果的に活用することで、複雑なソフトウェアシステムをシンプルで管理しやすい構造にすることができます。しかし、これらの機能を正しく理解し、適切に適用するためには、基礎から応用までをしっかりと学ぶ必要があります。本記事では、Javaの継承とポリモーフィズムを用いたオブジェクト指向設計の基本から応用までを丁寧に解説し、あなたのプログラミングスキルを次のレベルへ引き上げる手助けをします。
オブジェクト指向設計の基本概念
オブジェクト指向設計（OOD）は、ソフトウェア開発における重要なアプローチで、データとそれに関連する処理を「オブジェクト」としてモデル化します。このアプローチにより、システム全体が小さな再利用可能な部品で構成され、保守性や拡張性が向上します。
カプセル化
カプセル化とは、データとそれに関連するメソッドを一つのオブジェクト内に隠蔽するプロセスです。これにより、内部の実装が外部から見えなくなり、データの不正な操作を防ぎます。
継承
継承は、既存のクラス（親クラス）の特性を、新しいクラス（子クラス）が引き継ぐ仕組みです。これにより、コードの再利用が可能になり、クラス間の関係性が明確になります。
ポリモーフィズム
ポリモーフィズムは、異なるクラスのオブジェクトが同じインターフェースを共有し、同じメソッド呼び出しに対して異なる動作をする能力を指します。これにより、柔軟なコードの設計が可能になります。
オブジェクト指向設計の基本概念を理解することは、Javaプログラミングの基盤を築くために重要です。次のセクションでは、これらの基本概念のうち「継承」についてさらに詳しく探っていきます。
継承とは何か
継承は、オブジェクト指向プログラミングにおける主要な概念の一つであり、既存のクラス（親クラス）の特性や機能を、新しいクラス（子クラス）に引き継ぐ仕組みです。これにより、コードの再利用が促進され、システム全体の構造を簡潔に保つことができます。
継承の基本的な仕組み
Javaにおいて、子クラスは「extends」キーワードを使用して親クラスを継承します。子クラスは親クラスのフィールドやメソッドをそのまま利用でき、必要に応じて独自のメソッドを追加したり、親クラスのメソッドをオーバーライドして機能を拡張することも可能です。
継承のメリット
継承を利用することで、以下のようなメリットが得られます:
- コードの再利用: 一度定義したクラスの機能を何度も再利用でき、重複コードを削減できます。
- 拡張性: 既存のクラスに新しい機能を追加する際、既存コードに手を加えることなく新しいクラスを作成できます。
- 構造の明確化: クラス間の関係性が明確になり、コードの可読性と管理性が向上します。
継承のデメリット
しかし、継承にはデメリットも存在します:
- 過度の依存: 親クラスの変更が子クラスに影響を与えるため、設計が複雑化することがあります。
- 設計の硬直化: 継承階層が深くなると、クラス間の結合度が高くなり、柔軟な設計が難しくなることがあります。
継承は強力なツールですが、適切に設計しないと逆効果になることもあります。次のセクションでは、ポリモーフィズムの概念について詳しく説明します。
ポリモーフィズムの理解
ポリモーフィズムは、オブジェクト指向プログラミングの中で最も強力な特徴の一つであり、異なるクラスのオブジェクトが同じインターフェースやメソッドを共有し、異なる実装を持つことを可能にします。これにより、コードの柔軟性と拡張性が大幅に向上します。
ポリモーフィズムの基本原理
ポリモーフィズムは、Javaでは「動的バインディング」や「遅延バインディング」として実現されます。これにより、プログラムの実行時にメソッド呼び出しが解決され、オブジェクトの実際のクラスに基づいて適切なメソッドが選択されます。つまり、同じメソッド呼び出しが異なるオブジェクトによって異なる振る舞いを示すことができます。
ポリモーフィズムの種類
ポリモーフィズムには、主に以下の2種類があります:
- コンパイル時ポリモーフィズム（静的ポリモーフィズム）: メソッドオーバーロードや演算子オーバーロードによって実現されます。同じメソッド名を持つ複数のメソッドが、異なる引数リストを持つことで異なる振る舞いをします。
- 実行時ポリモーフィズム（動的ポリモーフィズム）: 継承とメソッドオーバーライドを用いて実現されます。親クラスの参照型で子クラスのインスタンスを扱うことで、実行時に実際のインスタンスに基づいてメソッドが選択されます。
Javaでのポリモーフィズムの実装
Javaにおけるポリモーフィズムの典型的な例として、以下のコードを考えてみましょう。
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.sound(); // Output: Dog barks
myCat.sound(); // Output: Cat meows
}
}この例では、Animalクラスのインスタンスとして扱われているDogとCatのオブジェクトが、それぞれ異なるsound()メソッドを呼び出しています。これがポリモーフィズムの力であり、同じメソッド呼び出しが異なるオブジェクトに対して異なる動作を実行することができます。
ポリモーフィズムを効果的に使うことで、コードの柔軟性を高め、変更に強い設計が可能になります。次のセクションでは、このポリモーフィズムと継承を組み合わせた設計の利点について詳しく解説します。
継承とポリモーフィズムの相乗効果
継承とポリモーフィズムを組み合わせることで、オブジェクト指向設計において非常に強力で柔軟なアプローチを実現することができます。これらの概念を一緒に使うことで、コードの再利用性を高め、拡張性のある設計が可能になります。
コードの再利用性の向上
継承を使用すると、基本的な機能を親クラスに定義し、それを子クラスに継承させることで、同じコードを何度も書く必要がなくなります。ポリモーフィズムを組み合わせることで、同じ親クラスのインターフェースを通じて異なる子クラスのオブジェクトを扱うことができ、共通の処理を一元化しつつ、各子クラスでの個別の振る舞いを実現できます。
拡張性のある設計
システムの要件が変更されたり、新しい機能が追加された場合でも、既存のコードに影響を与えずに新しい子クラスを作成することで対応できます。ポリモーフィズムにより、既存のコードを変更することなく、新しい機能を既存の構造に統合できるため、拡張性が向上します。
例: 図形の描画システム
例えば、図形を描画するシステムを考えてみましょう。このシステムでは、Shapeという親クラスを持ち、CircleやRectangleといった子クラスを継承させます。Shapeクラスには、draw()メソッドが定義されており、子クラスはこのメソッドをオーバーライドして、それぞれ異なる図形を描画します。
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle extends Shape {
@Override
void draw() {
System.out.println("Drawing a Rectangle");
}
}
public class Main {
public static void main(String[] args) {
Shape myCircle = new Circle();
Shape myRectangle = new Rectangle();
myCircle.draw(); // Output: Drawing a Circle
myRectangle.draw(); // Output: Drawing a Rectangle
}
}この例では、Shapeクラスを基にどのような形のオブジェクトでも扱うことができ、新しい形を追加したい場合は、単にShapeを継承した新しいクラスを作成するだけで済みます。
メンテナンス性の向上
継承とポリモーフィズムを活用することで、システム全体の構造が整理され、各クラスの役割が明確になります。これにより、コードのメンテナンスが容易になり、バグの修正や新機能の追加が効率的に行えます。
このように、継承とポリモーフィズムを組み合わせることで、柔軟で拡張性のあるシステムを設計することができ、長期的に見て保守性の高いコードを実現することが可能です。次のセクションでは、Javaにおける具体的な実装例をさらに詳しく見ていきます。
Javaでの実装例
継承とポリモーフィズムの概念を理解した上で、それらをどのようにJavaで実装するかを具体的な例を通じて解説します。このセクションでは、継承とポリモーフィズムを効果的に活用したコード例を見ながら、その設計がどのようにシステムの柔軟性と拡張性を高めるかを探っていきます。
動物クラスの継承とポリモーフィズムの実装例
まず、基本的な動物クラスを作成し、それを継承する犬と猫のクラスを作成します。それぞれのクラスで共通のメソッドをオーバーライドし、ポリモーフィズムを実現します。
class Animal {
void makeSound() {
System.out.println("Some generic animal sound");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Bark");
}
}
class Cat extends Animal {
@Override
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(); // Output: Bark
myCat.makeSound(); // Output: Meow
}
}この例では、Animalクラスが基本クラスとして定義され、DogとCatクラスがそれを継承しています。makeSound()メソッドはAnimalクラスで定義され、DogとCatクラスでそれぞれオーバーライドされています。これにより、Animal型の変数myDogやmyCatが、それぞれのオブジェクトの実際のクラスに基づいて適切なmakeSound()メソッドを呼び出すことができます。これがポリモーフィズムの典型的な例です。
さらに複雑なシナリオ: 図形の描画システム
次に、もう少し複雑な例として、図形を描画するシステムを構築します。このシステムでは、Shapeという抽象クラスを定義し、それを継承する具体的な図形クラス（例えばCircleやRectangle）を作成します。各図形クラスは、Shapeクラスで定義されたdraw()メソッドをオーバーライドし、それぞれの図形を描画する実装を提供します。
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle extends Shape {
@Override
void draw() {
System.out.println("Drawing a Rectangle");
}
}
public class DrawingApp {
public static void main(String[] args) {
Shape[] shapes = {new Circle(), new Rectangle()};
for (Shape shape : shapes) {
shape.draw();
}
}
}このコードでは、Shapeクラスを抽象クラスとして定義し、draw()メソッドを抽象メソッドとして宣言しています。CircleとRectangleクラスはこの抽象クラスを継承し、draw()メソッドをそれぞれの形に応じてオーバーライドしています。DrawingAppクラスのmainメソッドでは、異なる図形オブジェクトを配列に格納し、それぞれのdraw()メソッドを呼び出しています。このように、ポリモーフィズムを活用することで、コードの柔軟性を保ちながら、新しい図形クラスを簡単に追加できるようになります。
この実装例から、Javaにおける継承とポリモーフィズムを使った設計の強力さを理解していただけたと思います。次のセクションでは、これらの概念がどのように設計パターンで応用されているかを見ていきましょう。
設計パターンでの応用例
継承とポリモーフィズムは、数多くの設計パターンで重要な役割を果たしています。これらのパターンを理解し活用することで、再利用可能で保守性の高いソフトウェアを設計することができます。このセクションでは、特に代表的な設計パターンである「ファクトリーパターン」と「ストラテジーパターン」に注目し、それぞれがどのように継承とポリモーフィズムを活用しているかを解説します。
ファクトリーパターン
ファクトリーパターンは、オブジェクトの生成を専門とする設計パターンです。このパターンでは、オブジェクトの生成ロジックをクライアントコードから分離し、専用のファクトリーメソッドやクラスに委譲します。これにより、クライアントコードは具体的なクラスに依存せず、抽象的なインターフェースに対してプログラムできます。
ファクトリーパターンの例
次の例では、動物オブジェクトを生成するファクトリーパターンを示します。このパターンでは、Animalという抽象クラスを基に、DogやCatなどの具体的なクラスを生成します。
abstract class Animal {
abstract void makeSound();
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Bark");
}
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println("Meow");
}
}
class AnimalFactory {
public static Animal createAnimal(String type) {
if (type.equalsIgnoreCase("Dog")) {
return new Dog();
} else if (type.equalsIgnoreCase("Cat")) {
return new Cat();
} else {
return null;
}
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = AnimalFactory.createAnimal("Dog");
if (myAnimal != null) {
myAnimal.makeSound(); // Output: Bark
}
}
}この例では、AnimalFactoryクラスが具体的なAnimalオブジェクトの生成を管理しており、クライアントコードはAnimalFactoryを通じてオブジェクトを生成します。これにより、クライアントコードはDogやCatの具体的なクラスに依存することなく、ポリモーフィズムを活用して動作します。
ストラテジーパターン
ストラテジーパターンは、特定のアルゴリズムをカプセル化し、それを動的に選択できるようにする設計パターンです。このパターンでは、同じインターフェースを実装した複数のアルゴリズムクラスが存在し、クライアントコードは実行時にどのアルゴリズムを使用するかを選択できます。
ストラテジーパターンの例
次の例では、異なる課税戦略を実装したストラテジーパターンを示します。
interface TaxStrategy {
double calculateTax(double income);
}
class ProgressiveTax implements TaxStrategy {
@Override
public double calculateTax(double income) {
return income * 0.20;
}
}
class FlatTax implements TaxStrategy {
@Override
public double calculateTax(double income) {
return income * 0.15;
}
}
class TaxCalculator {
private TaxStrategy strategy;
public TaxCalculator(TaxStrategy strategy) {
this.strategy = strategy;
}
public double calculate(double income) {
return strategy.calculateTax(income);
}
}
public class Main {
public static void main(String[] args) {
TaxCalculator calculator = new TaxCalculator(new ProgressiveTax());
System.out.println(calculator.calculate(10000)); // Output: 2000.0
calculator = new TaxCalculator(new FlatTax());
System.out.println(calculator.calculate(10000)); // Output: 1500.0
}
}この例では、TaxStrategyインターフェースを実装した複数の課税アルゴリズムが存在し、TaxCalculatorクラスは使用する戦略を実行時に選択します。これにより、アルゴリズムの変更が容易になり、柔軟な設計が実現します。
継承とポリモーフィズムは、これらの設計パターンの基盤を形成しており、コードの柔軟性と再利用性を高めます。次のセクションでは、これらの技術を用いて効果的なオブジェクト指向設計を実現するためのコツを紹介します。
効果的なオブジェクト指向設計のコツ
継承とポリモーフィズムを活用して効果的なオブジェクト指向設計を行うためには、いくつかの重要なポイントを押さえておく必要があります。このセクションでは、これらの設計を成功させるためのベストプラクティスやコツを紹介します。
単一責任の原則（SRP）を守る
単一責任の原則は、各クラスが一つの責任のみを持つべきという考え方です。これにより、クラスが小さく、理解しやすくなり、保守性が向上します。継承を利用する際には、親クラスが多くの責任を持ちすぎないように注意し、責任を分割してサブクラスに分配することが重要です。
オープン・クローズドの原則（OCP）を意識する
オープン・クローズドの原則とは、クラスやモジュールは拡張にはオープンであり、修正にはクローズドであるべきという原則です。これを実現するためには、ポリモーフィズムを活用して、新しい機能を追加する際に既存のコードを変更せずに済むように設計することが求められます。例えば、インターフェースや抽象クラスを利用して、拡張可能な構造を構築します。
過度な継承を避ける
継承は強力なツールですが、過度に使用するとコードが複雑になり、保守が難しくなります。特に、継承階層が深くなりすぎると、クラス間の結合度が高まり、変更に対して脆弱になります。そのため、必要以上に継承を使用せず、コンポジション（オブジェクトの組み合わせ）を利用することも検討すべきです。
コンポジションの利用
コンポジションとは、オブジェクトが他のオブジェクトを含むことで機能を実現する方法です。例えば、CarクラスがEngineオブジェクトを持つことで、車にエンジンの機能を持たせることができます。これにより、柔軟で再利用可能な設計が可能になります。
class Engine {
void start() {
System.out.println("Engine starts");
}
}
class Car {
private Engine engine;
public Car(Engine engine) {
this.engine = engine;
}
void start() {
engine.start();
System.out.println("Car starts");
}
}
public class Main {
public static void main(String[] args) {
Engine engine = new Engine();
Car car = new Car(engine);
car.start();
}
}この例では、CarクラスがEngineオブジェクトを使用して機能を実現しており、エンジンの詳細な実装に依存しない設計が可能です。
テスト駆動開発（TDD）を活用する
テスト駆動開発は、テストを書くことを先行させる開発手法です。これにより、設計の初期段階からクラスのインターフェースや振る舞いが明確になり、継承やポリモーフィズムを利用したコードが期待通りに機能するかを確認できます。これにより、バグの早期発見と修正が可能になり、設計の品質が向上します。
効果的なオブジェクト指向設計を行うためには、これらのベストプラクティスを理解し、実践することが重要です。次のセクションでは、継承とポリモーフィズムを使用する際によく陥りがちな間違いと、それを避けるための対策について解説します。
よくある間違いとその対策
継承とポリモーフィズムは強力なツールですが、誤った使い方をするとコードの品質を損なうリスクがあります。このセクションでは、これらの概念を使用する際によく見られる間違いと、それらを回避するための対策を紹介します。
1. 過剰な継承
継承を使いすぎると、クラス階層が深くなりすぎて複雑になり、コードの理解やメンテナンスが難しくなります。特に、親クラスに多くの機能を詰め込みすぎると、サブクラス間の結合度が高まり、親クラスを変更するとサブクラスに予期しない影響が及ぶことがあります。
対策: コンポジションの活用
この問題を避けるためには、継承よりもコンポジション（オブジェクトの組み合わせ）を優先する設計が有効です。必要な機能を別のオブジェクトとして切り出し、それを持つ形でクラスを設計することで、柔軟性と再利用性を高めることができます。
2. インターフェースの乱用
インターフェースを使いすぎると、クラスが実装すべきメソッドが増えすぎてしまい、コードの管理が難しくなります。また、無駄に多くのインターフェースを実装することで、クラスの目的が曖昧になることがあります。
対策: インターフェースの設計をシンプルに保つ
インターフェースは、クラスの責務を明確にするために使うべきです。一つのインターフェースは一つの目的を持つように設計し、必要なメソッドだけを含むようにしましょう。また、インターフェースが増えすぎないように注意し、必要最低限のインターフェースに留めるようにします。
3. ポリモーフィズムの誤用
ポリモーフィズムを無理に使おうとすると、コードが複雑化し、かえってバグが増えることがあります。特に、クラス階層の設計が不適切な場合、ポリモーフィズムを適用しても期待通りに動作しないことがあります。
対策: 継承階層を慎重に設計する
ポリモーフィズムを適用する際は、クラス階層が論理的であることを確認し、各クラスが適切な責務を持つように設計しましょう。また、設計を進める前にユースケースを明確にし、そのニーズに基づいてクラス階層を決定することが重要です。
4. 基底クラスに依存しすぎる
サブクラスが基底クラスに強く依存すると、基底クラスの変更がサブクラスに予期せぬ影響を与え、コードが脆弱になります。特に、基底クラスに多くの機能が集中すると、変更のたびに全てのサブクラスを見直す必要が生じます。
対策: 抽象クラスの慎重な設計
基底クラスが必要以上に複雑にならないように設計し、サブクラスが本当に必要とする共通の機能だけを含めるようにしましょう。また、可能な場合は抽象クラスよりもインターフェースを使用して、サブクラスの柔軟性を保つように心がけます。
これらの対策を実践することで、継承とポリモーフィズムを適切に活用し、堅牢でメンテナンスしやすいコードを設計することができます。次のセクションでは、これまで学んだ知識を実践的に確認できる演習問題を提供します。
演習問題
ここでは、これまでに学んだJavaの継承とポリモーフィズムの概念を実際に応用し、理解を深めるための演習問題を提供します。これらの問題に取り組むことで、オブジェクト指向設計の原則を実際のコードでどのように適用するかを確認できます。
問題1: 動物クラスの拡張
以下のAnimalクラスを基に、新しいBirdクラスを作成してください。BirdクラスはAnimalクラスを継承し、fly()メソッドを追加します。また、AnimalクラスのmakeSound()メソッドをオーバーライドし、鳥が鳴く音を出力するようにしてください。
class Animal {
void makeSound() {
System.out.println("Some generic animal sound");
}
}期待される出力
Birdクラスのインスタンスを作成し、makeSound()とfly()メソッドを呼び出したときに、鳥が鳴く音と「Bird is flying」というメッセージが表示されるようにします。
問題2: 図形クラスの拡張とポリモーフィズム
次に、以下のShapeクラスを継承して、新しいTriangleクラスを作成してください。TriangleクラスはShapeクラスのdraw()メソッドをオーバーライドし、三角形を描画するメッセージを出力します。また、CircleとRectangleクラスのインスタンスとともに、Triangleクラスのインスタンスを作成し、ポリモーフィズムを使用してそれらのdraw()メソッドを順に呼び出してください。
abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle extends Shape {
@Override
void draw() {
System.out.println("Drawing a Rectangle");
}
}期待される出力
Circle, Rectangle, Triangleクラスのインスタンスをリストに格納し、リストをループして各図形のdraw()メソッドを呼び出します。すべての図形がそれぞれの形に応じたメッセージを出力することを確認してください。
問題3: ストラテジーパターンの実装
以下のコードを基に、異なる種類の割引戦略を実装するストラテジーパターンを作成してください。DiscountStrategyインターフェースを定義し、PercentageDiscountとFixedAmountDiscountという2つの具体的な戦略クラスを作成します。これらのクラスは、それぞれ購入金額に応じた割引額を計算します。次に、ShoppingCartクラスでこれらの戦略を使用して、総額に対して適用される割引額を計算します。
interface DiscountStrategy {
double applyDiscount(double amount);
}
class PercentageDiscount implements DiscountStrategy {
private double percentage;
public PercentageDiscount(double percentage) {
this.percentage = percentage;
}
@Override
public double applyDiscount(double amount) {
return amount * (percentage / 100);
}
}
class FixedAmountDiscount implements DiscountStrategy {
private double discount;
public FixedAmountDiscount(double discount) {
this.discount = discount;
}
@Override
public double applyDiscount(double amount) {
return discount;
}
}
class ShoppingCart {
private DiscountStrategy strategy;
public ShoppingCart(DiscountStrategy strategy) {
this.strategy = strategy;
}
public double calculateTotal(double amount) {
return amount - strategy.applyDiscount(amount);
}
}
public class Main {
public static void main(String[] args) {
ShoppingCart cart1 = new ShoppingCart(new PercentageDiscount(10));
System.out.println("Total after discount: " + cart1.calculateTotal(100)); // Output: 90.0
ShoppingCart cart2 = new ShoppingCart(new FixedAmountDiscount(15));
System.out.println("Total after discount: " + cart2.calculateTotal(100)); // Output: 85.0
}
}問題4: クラス設計の改善
次のコードは、継承とポリモーフィズムの原則に従っていない非効率な設計の例です。このコードを改善し、Vehicleクラスを継承したCarとBikeの2つのクラスを作成し、start()メソッドをポリモーフィズムを使って再実装してください。
class Car {
void start() {
System.out.println("Car is starting");
}
}
class Bike {
void start() {
System.out.println("Bike is starting");
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car();
Bike myBike = new Bike();
myCar.start();
myBike.start();
}
}改善後の期待されるコード
Vehicleという親クラスを作成し、CarとBikeクラスがこれを継承します。start()メソッドをVehicleクラスで定義し、CarとBikeクラスでオーバーライドします。Vehicle型のリストを作成し、すべての乗り物を同じメソッドでスタートさせることができるようにします。
これらの演習問題に取り組むことで、継承とポリモーフィズムの概念を実際のコードで確認し、理解を深めることができます。次のセクションでは、この記事のまとめを行います。
まとめ
本記事では、Javaにおける継承とポリモーフィズムの基本概念から、それらを活用したオブジェクト指向設計の応用までを詳しく解説しました。継承を使うことでコードの再利用性を高め、ポリモーフィズムを活用することで柔軟で拡張性のある設計を実現できます。さらに、設計パターンを通じて、これらの概念が実際のシステム設計でどのように応用されているかを理解することができました。
効果的なオブジェクト指向設計を行うためには、これらの技術を適切に使用し、過度な継承やポリモーフィズムの誤用を避けることが重要です。演習問題に取り組むことで、実際のプログラムでこれらの概念を実践し、より深い理解を得ることができるでしょう。
継承とポリモーフィズムを上手に使いこなして、より強力でメンテナンスしやすいJavaプログラムを設計してください。
コメント