Javaプログラミングにおいて、ローカルクラス（メソッド内クラス）は、特定のメソッド内でのみ使用できるクラスとして知られています。これは、他のクラスに影響を与えることなく、そのメソッドのロジックをより整理しやすくするための強力な手法です。ローカルクラスは、他のメソッドやフィールドに直接アクセスできるため、スコープを限定した状態でクラスを定義できるという利点を持っています。本記事では、Javaのローカルクラスの基本から応用までを詳細に解説し、どのように効果的に活用できるかを説明します。
ローカルクラスの基本概念
Javaにおけるローカルクラスとは、メソッドの内部で定義されるクラスのことです。これは特定のメソッド内でのみ使用可能で、そのメソッド外では参照できません。通常のクラスとは異なり、ローカルクラスはメソッドのロジックを整理し、メソッド内の特定の処理をクラスに分離するために使われます。
ローカルクラスの特徴
- スコープが限定的：メソッド内でのみアクセス可能なため、カプセル化が強化されます。
- 外部変数へのアクセス：メソッドのローカル変数（ただし、
finalまたは事実上finalなものに限る）や、クラスのフィールドにアクセス可能です。 - 静的メンバーを持たない：ローカルクラスは静的なフィールドやメソッドを持てません。
ローカルクラスを利用することで、特定のタスクやロジックをクラスとしてまとめることができ、可読性と保守性の向上に役立ちます。
ローカルクラスの使い所
ローカルクラスは、そのスコープがメソッド内に限定されているため、特定のシナリオで非常に役立ちます。ここでは、ローカルクラスが活躍する場面をいくつか紹介します。
一時的なロジックのカプセル化
ローカルクラスは、メソッド内で発生する複雑なロジックをカプセル化するために使用されます。例えば、短期間だけ必要となるデータ処理やアルゴリズムをクラスにまとめて、メソッド内のコードの可読性を保ちながら、処理を整理することができます。
イベント処理やコールバック
GUIプログラムやマルチスレッド環境で、イベント処理やコールバック関数を実装する際に、ローカルクラスは便利です。特定のメソッド内でだけ使用されるイベントハンドラをローカルクラスとして定義することで、コードの分離と整理が容易になります。
スコープを限定したクラスの利用
他のクラスや外部から不要なアクセスを防ぎたい場合に、ローカルクラスを使用して、そのメソッド内でのみ利用可能なクラスを作成できます。これにより、意図しない外部からのアクセスや改変を防ぎ、コードのセキュリティや安定性を向上させることができます。
このように、ローカルクラスは特定のタスクやロジックを局所的に処理するための強力なツールとして活用されます。
メソッド内でのローカルクラスの利用方法
ローカルクラスは、Javaのメソッド内で定義され、そのメソッド内でのみアクセス可能です。基本的な構文は通常のクラス定義と似ていますが、クラスの定義場所が異なる点が特徴です。以下では、メソッド内でローカルクラスを定義し、利用する方法について説明します。
ローカルクラスの構文
ローカルクラスの基本的な構文は、次のようになります：
public class OuterClass {
public void someMethod() {
// ローカルクラスの定義
class LocalClass {
void display() {
System.out.println("This is a local class.");
}
}
// ローカルクラスのインスタンス生成とメソッド呼び出し
LocalClass local = new LocalClass();
local.display();
}
}このコードでは、someMethod()内でLocalClassというローカルクラスが定義されています。このローカルクラスは、そのメソッドの中でのみ使われるため、外部からアクセスすることはできません。
ローカルクラスの使用例
ローカルクラスを使う典型的な例として、特定のメソッドで複数の処理をまとめて実行するケースが挙げられます。ローカルクラスを使うことで、関連する処理を1つのクラスにカプセル化し、メソッド内の構造を整理できます。
例えば、メソッド内でデータを加工する複雑なアルゴリズムが必要な場合、そのロジックをローカルクラスにまとめて定義することで、メソッドの可読性が向上します。また、メソッドのローカル変数にもアクセスできるため、クラス外で定義するよりも柔軟に扱うことができます。
ローカルクラスは、このように局所的な機能やロジックを一時的にカプセル化する際に非常に有効な手段です。
ローカルクラスと匿名クラスとの違い
Javaには、ローカルクラスと匿名クラスという2つの似た機能がありますが、それぞれ異なる目的や使用状況があります。両者を理解することで、適切な場面で効果的に使い分けることができます。
ローカルクラスとは
ローカルクラスは、前述の通り、メソッド内で定義される名前付きのクラスです。これは、そのメソッド内でしか利用できないため、スコープが非常に限定されており、外部からの干渉を防ぐことができます。名前を持っているため、複数の場所でインスタンス化したり、後で参照することができます。
public class Example {
public void performAction() {
class LocalClass {
void execute() {
System.out.println("Local class executed");
}
}
LocalClass local = new LocalClass();
local.execute();
}
}匿名クラスとは
匿名クラスは、名前を持たず、一度だけインスタンス化されるクラスのことを指します。通常、インターフェースや抽象クラスのインスタンスを直接作成する際に用いられ、特定の動作を一時的に定義する場合に使われます。匿名クラスは、コードが簡潔になる一方で、再利用性が低く、複雑なロジックを扱うのには不向きです。
public class Example {
public void performAction() {
Runnable runnable = new Runnable() {
public void run() {
System.out.println("Anonymous class executed");
}
};
runnable.run();
}
}ローカルクラスと匿名クラスの主な違い
- 名前の有無：
- ローカルクラスは名前付きクラスであり、メソッド内で複数回使用することが可能です。
- 匿名クラスは名前を持たず、インスタンス化時に一度限りの定義となります。
- 再利用性：
- ローカルクラスは、メソッド内で複数回インスタンス化することができます。
- 匿名クラスは、その場でしか使えず、一度きりの利用が一般的です。
- 構文の違い：
- ローカルクラスは通常のクラス定義のような形式を取りますが、匿名クラスはインターフェースや抽象クラスを直接実装するため、より短いコードで記述されます。
- 可読性と用途：
- ローカルクラスは複雑なロジックや複数のメソッドを持たせるのに適しています。
- 匿名クラスは、インターフェースの実装や一時的な処理に適しており、シンプルな動作に向いています。
このように、ローカルクラスと匿名クラスにはそれぞれメリットとデメリットがあり、状況に応じて使い分けることが重要です。
具体的なコード例
ローカルクラスの理解を深めるために、具体的なコード例を紹介します。この例では、メソッド内でローカルクラスを定義し、そのクラスを使用して特定の計算を行う場面を示します。
ローカルクラスを使った例：配列内の偶数の合計を計算
この例では、配列内の偶数のみを合計する処理をローカルクラスを使って行います。ローカルクラスを使うことで、処理の一部を分離してロジックを整理しやすくします。
public class LocalClassExample {
public void calculateSumOfEvens(int[] numbers) {
// ローカルクラスの定義
class EvenSumCalculator {
private int sum = 0;
public void calculate() {
for (int num : numbers) {
if (num % 2 == 0) {
sum += num;
}
}
}
public int getSum() {
return sum;
}
}
// ローカルクラスのインスタンス生成
EvenSumCalculator calculator = new EvenSumCalculator();
calculator.calculate();
// 結果を表示
System.out.println("Sum of even numbers: " + calculator.getSum());
}
public static void main(String[] args) {
LocalClassExample example = new LocalClassExample();
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
example.calculateSumOfEvens(numbers);
}
}コードの解説
- ローカルクラス
EvenSumCalculator：メソッドcalculateSumOfEvens内で定義されており、配列内の偶数の合計を計算する役割を持っています。このクラスは、メソッド外では使われないため、ロジックをメソッド内に閉じ込めています。 calculateメソッド：配列numbersの各要素をループし、偶数の場合に合計をsumに加算します。getSumメソッド：計算結果である合計を返すメソッドです。
ローカルクラスの利点
この例では、ローカルクラスを使って、特定の処理をクラスにまとめています。これにより、メソッドの可読性が向上し、処理の構造がより明確になります。また、ローカルクラスがメソッド内のローカル変数 numbers にアクセスできるため、外部からデータを受け渡す手間を省くことができます。
ローカルクラスを使うことで、コードが冗長にならず、メソッド内での処理を整理するのに役立ちます。
ローカルクラスのスコープとライフサイクル
ローカルクラスは、その定義される場所と有効範囲がメソッド内に限定されています。これは、他のクラスやメソッドから直接アクセスできないため、非常に限定的な役割を果たす一方で、メソッド内のロジックを整理するために適しています。ここでは、ローカルクラスのスコープとライフサイクルについて詳しく解説します。
スコープの定義
ローカルクラスは、定義されたメソッドの内部でのみアクセス可能です。これは、ローカル変数と同じスコープ規則に従います。つまり、以下のような制限があります：
- メソッドの外部ではアクセス不可：ローカルクラスは、そのメソッドの外部からは見えません。他のメソッドやクラスから直接インスタンス化することはできません。
- メソッド内でのみ有効：ローカルクラスは、メソッドが実行される間にのみ存在し、メソッドの終了とともにそのクラスのライフサイクルも終了します。
例：
public class OuterClass {
public void someMethod() {
class LocalClass {
void display() {
System.out.println("Inside the local class");
}
}
LocalClass local = new LocalClass();
local.display(); // メソッド内でのみアクセス可能
}
public void anotherMethod() {
// このメソッドではLocalClassはアクセス不可
}
}この例では、someMethod 内で定義された LocalClass は、そのメソッド内でしかアクセスできません。他のメソッド anotherMethod からは使用できないため、クラスのスコープが限定されています。
ローカルクラスのライフサイクル
ローカルクラスのライフサイクルは、その定義されているメソッドと密接に関連しています。具体的には、次のような動作をします：
- メソッドの呼び出し時にクラスが有効になる：メソッドが呼び出されると、ローカルクラスが初めて有効になります。この時点でインスタンスを作成できます。
- メソッドの終了時にクラスが無効になる：メソッドが終了すると、ローカルクラスのインスタンスも含めてクラス自体が無効になります。これにより、メモリの消費が抑えられ、スコープ外での誤用を防ぎます。
ローカル変数とローカルクラスの関係
ローカルクラスは、そのメソッド内の変数やパラメータにアクセスできますが、アクセスできる変数は特定の条件を満たしている必要があります。それは、ローカル変数が final または「事実上final」であることです。これにより、ローカルクラスが定義されたメソッドの外部で、変数の予期せぬ変更を防ぎます。
public void someMethod() {
final int number = 10; // この変数はローカルクラスからアクセス可能
class LocalClass {
void printNumber() {
System.out.println("Number: " + number);
}
}
LocalClass local = new LocalClass();
local.printNumber();
}ここでは、number というローカル変数がローカルクラス内で使用されています。この変数は final として宣言されているため、ローカルクラスから問題なくアクセスできます。
ローカルクラスの使用時の注意点
ローカルクラスは便利ですが、ライフサイクルがメソッドに依存するため、次の点に注意が必要です：
- メソッド内で定義されるため、他のメソッドやクラスから再利用することができません。
- 複雑なロジックを含む場合、メソッドが長くなりすぎることがあります。適切に分割することが重要です。
ローカルクラスのスコープとライフサイクルを理解することで、その使いどころを正しく判断でき、より効果的なコード設計が可能になります。
ローカルクラスの制約事項
ローカルクラスは便利な機能ですが、使用する際にはいくつかの制約があります。これらの制約を理解しておくことで、意図しないバグや問題を避け、より効果的にローカルクラスを活用できるようになります。
静的メンバーの定義ができない
ローカルクラスでは、静的メンバー（フィールドやメソッド）を持つことができません。これは、ローカルクラスがメソッド内で動的に生成され、そのライフサイクルがメソッドに依存しているためです。静的な要素はクラス全体で共有されるべきですが、ローカルクラスは短命で、スコープも狭いため、この制約が設けられています。
public class Example {
public void someMethod() {
class LocalClass {
// 静的フィールドやメソッドは定義できない
// static int counter; // コンパイルエラー
}
}
}メソッド内のローカル変数への制限付きアクセス
ローカルクラスは、メソッド内のローカル変数にアクセスできますが、アクセスできるのは final もしくは「事実上final」な変数に限られます。これは、ローカルクラスがメソッド終了後もその変数を参照する可能性があるため、変数が変更されないことを保証する必要があるからです。
public void someMethod() {
int number = 10;
class LocalClass {
void display() {
// ローカル変数にアクセスできない（finalでないため）
// System.out.println(number); // コンパイルエラー
}
}
}上記のように、number が final もしくは事実上 final でない場合、ローカルクラスからその変数にアクセスできません。事実上 final とは、その変数が再代入されないことを意味します。
ローカルクラスの可視性がメソッド内に限定される
ローカルクラスは、そのメソッド内でのみ有効であり、メソッド外からは直接アクセスできません。これは、ローカルクラスの可視性が非常に限定されているためです。したがって、ローカルクラスを他のクラスやメソッドから再利用することはできません。再利用が必要な場合は、通常の内部クラスやトップレベルのクラスとして定義する必要があります。
public class Example {
public void methodOne() {
class LocalClass {
void display() {
System.out.println("Method one");
}
}
}
public void methodTwo() {
// LocalClassへのアクセスは不可能
// LocalClass local = new LocalClass(); // コンパイルエラー
}
}例外の取り扱い
ローカルクラスは、ローカルクラス内での例外処理にも制約があります。特に、メソッド内で定義されたローカルクラスで例外をスローする場合、その例外はメソッド全体に影響を与えます。また、ローカルクラス内での例外処理のために、親メソッドのスロー宣言に追記する必要がある場合もあります。
オーバーヘッドとパフォーマンス
ローカルクラスの使用自体は通常のクラスと比べて大きなパフォーマンス差はありませんが、複雑な処理を持つローカルクラスを頻繁に生成する場合、オーバーヘッドが発生する可能性があります。特に、大量のインスタンス生成が必要な場合には、パフォーマンスに影響を与えることがあります。必要に応じて、処理が重い場合は通常のクラスに分離することが推奨されます。
ローカルクラスの使用における注意点
- ローカルクラスは、スコープが非常に狭いため、再利用ができないという制約があります。そのため、コードの整理には便利ですが、汎用的な処理を行うクラスには不向きです。
- メソッド内のローカル変数へのアクセスには
final修飾子が必要な場合があるため、意図しないエラーを防ぐために変数の扱いに注意が必要です。
これらの制約事項を理解することで、ローカルクラスの使いどころを把握し、最適な場面で効果的に使用することができます。
ローカルクラスの応用例
ローカルクラスは、単なる簡単な処理をカプセル化するためのツールだけでなく、特定の状況や要件に応じた柔軟な機能を提供できます。ここでは、より実践的な場面でのローカルクラスの応用例をいくつか紹介します。
ローカルクラスを用いたカスタムソート
JavaのComparatorインターフェースを用いたソート処理で、特定の条件に基づいて一時的にカスタムな比較ロジックを実装する際に、ローカルクラスが非常に役立ちます。ローカルクラス内にソートロジックを定義することで、コードの見通しが良くなり、再利用が不要な処理を適切に管理できます。
import java.util.Arrays;
import java.util.Comparator;
public class LocalClassExample {
public void sortStringsByLength(String[] strings) {
// ローカルクラスを使用してカスタムコンパレータを作成
class LengthComparator implements Comparator<String> {
public int compare(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
}
// ソート処理
Arrays.sort(strings, new LengthComparator());
// 結果の表示
System.out.println("Sorted by length: " + Arrays.toString(strings));
}
public static void main(String[] args) {
String[] words = {"apple", "banana", "pear", "kiwi"};
new LocalClassExample().sortStringsByLength(words);
}
}この例では、文字列の配列をその長さに基づいてソートするためのカスタムコンパレータをローカルクラスとして定義しています。このクラスは、sortStringsByLength メソッド内でのみ使用され、外部での再利用を必要としない一時的なソートロジックを効率的にカプセル化しています。
GUIプログラミングでのイベントリスナー
ローカルクラスは、GUIアプリケーションでのイベントリスナーとしても役立ちます。特定のイベント（ボタンクリックやキーボード操作など）に対してローカルクラスでリスナーを定義し、その場限りの動作を記述することができます。匿名クラスでも可能ですが、ローカルクラスを使うことでより複雑な処理を柔軟に記述できます。
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class LocalClassEventExample {
public void createGUI() {
JFrame frame = new JFrame("Local Class Example");
JButton button = new JButton("Click Me");
// ローカルクラスとしてイベントリスナーを定義
class ButtonClickListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.out.println("Button was clicked!");
}
}
// ボタンにリスナーを登録
button.addActionListener(new ButtonClickListener());
// フレームの設定
frame.add(button);
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
public static void main(String[] args) {
new LocalClassEventExample().createGUI();
}
}この例では、ButtonClickListener というローカルクラスを使って、ボタンクリックイベントの処理を行っています。この方法を使うと、リスナーが複雑な処理を行う際にも可読性を保ちながら、メソッド内にリスナーを閉じ込めることができます。
ローカルクラスを使ったスレッド処理
並行処理のためにスレッドを作成する際、ローカルクラスを使って一時的なスレッドクラスを定義することができます。これにより、特定のタスクに関するスレッドロジックをメソッド内でカプセル化し、メソッドの終了後にスレッドが終了することを保証できます。
public class LocalClassThreadExample {
public void startTask() {
// ローカルクラスとしてスレッド定義
class TaskThread extends Thread {
public void run() {
System.out.println("Task is running...");
try {
Thread.sleep(2000); // 2秒間の処理
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task completed.");
}
}
// スレッドの実行
TaskThread task = new TaskThread();
task.start();
}
public static void main(String[] args) {
new LocalClassThreadExample().startTask();
}
}この例では、TaskThread というローカルクラスを使って、並行処理のための一時的なスレッドを定義しています。このようにして、スレッド処理をメソッド内に限定し、外部からの不要なアクセスや影響を防ぎつつ、柔軟な処理が可能になります。
ローカルクラスの応用まとめ
ローカルクラスは、カスタムソート、GUIイベントリスナー、スレッド処理など、特定の文脈で一時的にクラスが必要な場合に有効です。再利用の必要がないロジックを適切にメソッド内にカプセル化することで、コードの可読性や保守性を向上させることができます。
他のJava機能との連携
ローカルクラスは、他のJavaの機能と組み合わせて使用することで、さらに強力で柔軟なプログラムを構築することができます。特に、ラムダ式やインターフェースなどと連携することで、コードの効率や表現力が大幅に向上します。ここでは、ローカルクラスが他のJava機能とどのように連携できるかについて解説します。
ラムダ式との連携
Java 8で導入されたラムダ式は、匿名クラスの簡潔な代替として利用されます。匿名クラスを使う代わりに、ラムダ式で一時的な処理を簡潔に記述できますが、複雑なロジックにはローカルクラスを使い、シンプルな処理にはラムダ式を使うといった使い分けが可能です。
public class LambdaAndLocalClassExample {
public void execute() {
// ローカルクラスで複雑なロジックをカプセル化
class ComplexLogic {
public void runComplexLogic() {
System.out.println("Running complex logic...");
}
}
ComplexLogic logic = new ComplexLogic();
logic.runComplexLogic();
// 簡単な処理にはラムダ式を使用
Runnable simpleTask = () -> System.out.println("Running simple task...");
simpleTask.run();
}
public static void main(String[] args) {
new LambdaAndLocalClassExample().execute();
}
}この例では、ComplexLogic というローカルクラスを使って複雑なロジックをカプセル化し、簡単な処理にはラムダ式を用いています。このように、状況に応じてローカルクラスとラムダ式を組み合わせることで、効率的に処理を分割できます。
インターフェースとの連携
ローカルクラスは、インターフェースを実装するためにも使われます。インターフェースを実装するロジックをローカルクラスに閉じ込めることで、特定のメソッド内でのみ利用される一時的な実装を提供できます。
public class InterfaceWithLocalClassExample {
interface Greeting {
void greet();
}
public void showGreeting() {
// ローカルクラスでインターフェースを実装
class EnglishGreeting implements Greeting {
public void greet() {
System.out.println("Hello!");
}
}
// インターフェースを使ってメソッド呼び出し
Greeting greeting = new EnglishGreeting();
greeting.greet();
}
public static void main(String[] args) {
new InterfaceWithLocalClassExample().showGreeting();
}
}この例では、Greeting というインターフェースをローカルクラス EnglishGreeting が実装しています。このようにして、特定のメソッド内でしか使わないインターフェースの実装をローカルクラスにまとめることで、外部のコードと分離しつつ、必要な機能を提供できます。
Javaの標準ライブラリとの連携
ローカルクラスは、Java標準ライブラリのクラスやメソッドとも効果的に組み合わせて使用できます。例えば、コレクションフレームワークの処理やストリームAPIでのカスタムロジックをローカルクラスにまとめることで、処理の柔軟性が向上します。
import java.util.Arrays;
import java.util.List;
public class LocalClassWithStreamsExample {
public void filterAndPrintEvens() {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ローカルクラスを使って偶数をチェックするロジックをカプセル化
class EvenChecker {
public boolean isEven(int number) {
return number % 2 == 0;
}
}
EvenChecker checker = new EvenChecker();
// ストリームAPIと連携して偶数をフィルタリング
numbers.stream()
.filter(checker::isEven)
.forEach(System.out::println);
}
public static void main(String[] args) {
new LocalClassWithStreamsExample().filterAndPrintEvens();
}
}この例では、EvenChecker というローカルクラスを使って偶数を判定し、そのロジックをストリームAPIと組み合わせて活用しています。このように、ローカルクラスを使って複雑なロジックを分離し、標準ライブラリと連携することで、コードの可読性とメンテナンス性を向上させることができます。
例外処理との連携
ローカルクラスは、メソッド内で発生する例外をカプセル化し、効率的に処理する際にも役立ちます。例えば、ローカルクラス内で特定の例外を処理し、その結果をメソッド内に反映させることができます。
public class LocalClassWithExceptionHandling {
public void performTask() {
class TaskPerformer {
public void execute() throws Exception {
// 例外をスローする可能性のある処理
if (Math.random() > 0.5) {
throw new Exception("Random failure!");
}
System.out.println("Task executed successfully.");
}
}
TaskPerformer performer = new TaskPerformer();
try {
performer.execute();
} catch (Exception e) {
System.out.println("Task failed: " + e.getMessage());
}
}
public static void main(String[] args) {
new LocalClassWithExceptionHandling().performTask();
}
}この例では、ローカルクラス TaskPerformer を使って、例外を発生させる可能性のある処理をカプセル化しています。これにより、例外の発生に応じて適切な処理を行い、メソッド全体の可読性を向上させています。
ローカルクラスと他の機能との連携まとめ
ローカルクラスは、Javaの他の機能と組み合わせることで、より柔軟かつ効率的にプログラムを構築できます。ラムダ式やインターフェース、ストリームAPIなどと連携させることで、ローカルクラスの可能性を最大限に活用することができます。これにより、特定の処理を整理し、メソッド内にカプセル化することで、可読性や保守性が向上します。
ローカルクラスを使った演習問題
ローカルクラスの理解を深めるために、実際にコーディングで試せる演習問題を用意しました。これに取り組むことで、ローカルクラスの使用方法や利点を実践的に学ぶことができます。ぜひチャレンジしてみてください。
演習1：合計計算クラスの作成
次の仕様に基づいて、ローカルクラスを使用して数値の合計を計算するメソッドを作成してください。
仕様：
- メソッドは、整数の配列を受け取り、その中から特定の条件（例えば、偶数、奇数、または5の倍数など）に一致する数値の合計を返す。
- 合計計算のロジックをローカルクラスにカプセル化する。
ヒント：
ローカルクラスを使って、条件に一致する数値をフィルタリングし、合計を計算する部分を実装してください。
public class LocalClassExercise {
public int calculateFilteredSum(int[] numbers) {
// ローカルクラスを定義して合計を計算するロジックをカプセル化
class SumCalculator {
private int sum = 0;
public void calculate(int condition) {
for (int number : numbers) {
// 例えば、偶数のみ合計するロジック
if (number % condition == 0) {
sum += number;
}
}
}
public int getSum() {
return sum;
}
}
// 偶数（2の倍数）の合計を計算
SumCalculator calculator = new SumCalculator();
calculator.calculate(2);
return calculator.getSum();
}
public static void main(String[] args) {
LocalClassExercise exercise = new LocalClassExercise();
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int result = exercise.calculateFilteredSum(numbers);
System.out.println("Filtered sum: " + result);
}
}演習2：文字列フィルタリングクラスの作成
次の仕様に基づいて、ローカルクラスを使用して文字列のリストから特定の条件（例えば、文字数が5文字以上など）に一致する文字列をフィルタリングするメソッドを作成してください。
仕様：
- メソッドは、文字列のリストを受け取り、特定の条件に一致する文字列だけをフィルタリングして表示します。
- フィルタリングのロジックをローカルクラスにまとめる。
ヒント：
ローカルクラスで条件をカプセル化し、そのクラスを使って文字列リストをフィルタリングします。
import java.util.ArrayList;
import java.util.List;
public class StringFilterExercise {
public List<String> filterStrings(List<String> strings, int minLength) {
// ローカルクラスを定義してフィルタリングロジックをカプセル化
class StringFilter {
private List<String> filteredStrings = new ArrayList<>();
public void filter() {
for (String str : strings) {
if (str.length() >= minLength) {
filteredStrings.add(str);
}
}
}
public List<String> getFilteredStrings() {
return filteredStrings;
}
}
// フィルタリングを実行
StringFilter filter = new StringFilter();
filter.filter();
return filter.getFilteredStrings();
}
public static void main(String[] args) {
StringFilterExercise exercise = new StringFilterExercise();
List<String> words = List.of("apple", "banana", "pear", "kiwi", "strawberry");
List<String> filteredWords = exercise.filterStrings(words, 5);
System.out.println("Filtered words: " + filteredWords);
}
}演習3：カスタム例外処理クラスの作成
次の仕様に基づいて、ローカルクラスを使用して例外処理を行うメソッドを作成してください。
仕様：
- メソッドは、特定の数値を受け取り、その数値が負の場合にカスタム例外をスローする。
- カスタム例外の処理ロジックをローカルクラスにまとめる。
ヒント：
ローカルクラスを使って、特定の条件下で例外をスローするロジックをカプセル化します。
public class CustomExceptionExercise {
public void checkNumber(int number) throws Exception {
// ローカルクラスを定義してカスタム例外処理を行う
class NegativeNumberException extends Exception {
public NegativeNumberException(String message) {
super(message);
}
}
// 数値が負の場合に例外をスロー
if (number < 0) {
throw new NegativeNumberException("Negative numbers are not allowed.");
} else {
System.out.println("Number is valid: " + number);
}
}
public static void main(String[] args) {
CustomExceptionExercise exercise = new CustomExceptionExercise();
try {
exercise.checkNumber(-5); // 負の数値を渡して例外を発生させる
} catch (Exception e) {
System.out.println("Exception caught: " + e.getMessage());
}
}
}まとめ
これらの演習問題を通じて、ローカルクラスの基本的な使い方から、より応用的な状況での活用方法までを学ぶことができます。特に、ローカルクラスを使ったカプセル化や、条件付きロジックの整理方法を実践的に体験してください。
まとめ
本記事では、Javaのローカルクラス（メソッド内クラス）について、その基本概念から応用例までを詳細に解説しました。ローカルクラスは、メソッド内でのみ使用可能で、特定のタスクやロジックを整理するための強力なツールです。スコープの制限や再利用性が低い一方で、カプセル化や可読性の向上、他のJava機能との連携で非常に有用な場面があります。この記事で学んだ内容を活かして、実際のコードにローカルクラスを効果的に組み込んでみてください。
コメント