Javaアノテーションの12選！初心者から上級者まで徹底ガイド

はじめに

Javaのアノテーションは、多くのJavaプログラマーにとって欠かせない機能の一つです。

アノテーションは、コードのメタデータを提供することで、コンパイル時や実行時に特定の動作をするように指示するためのものです。

このガイドでは、Javaのアノテーションの基本を徹底的に解説します。

アノテーションに関して知りたい初心者から、より高度な使い方を学びたい上級者まで、幅広くカバーしています。

●Javaアノテーションとは

Javaアノテーションは、2004年のJava 5から導入されました。

これは、Javaのソースコードにメタデータを追加するための一手段として用意されました。

メタデータとは、データに関するデータのことを指します。

アノテーションはコードの動作に直接関与しない情報を付加するためのものであり、それによってコンパイラや他のツールがその情報を利用して特定の動作をするようになります。

例えば、あるメソッドがオーバーライドされるべきメソッドであることを示すために@Overrideアノテーションが使用されることがあります。

このアノテーションが付与されたメソッドは、親クラスに同じシグネチャのメソッドが存在することをコンパイラが確認します。

もし親クラスに同じシグネチャのメソッドが存在しなければ、コンパイルエラーが発生します。

このように、アノテーションはコードの誤りを事前に検出する助けとなることが多いです。

○アノテーションの基本

アノテーションを使用する際の基本的な文法は非常にシンプルです。アノテーションは@記号の後にアノテーションの名前を記述します。

そして、その後ろに（）をつけることで、アノテーションにパラメータを渡すこともできます。

例えば、下記のコードは@Entityアノテーションをクラスに適用しています。

このコードでは、Userクラスがデータベースのエンティティであることを表しています。

@Entity
public class User {
    // このクラスの実装内容
}

このコードを実行すると、Userクラスがデータベースのエンティティとして認識され、適切な動作が期待されます。

●アノテーションの詳細な使い方

Javaのアノテーションは、コードの特定の部分にメタデータを追加するために使用されます。

これはコンパイラに特定の情報を提供したり、コードの読解性を向上させたりする目的で使用されます。

アノテーションは簡単な記述から複雑な設定まで多くの場面で用いられます。

ここでは、アノテーションの詳細な使い方を詳細に解説します。

○サンプルコード1：@Overrideアノテーションの使い方

早速ですが、@Overrideアノテーションの使い方について詳しく見ていきましょう。

public class Animal {
    public void sound(){
        System.out.println("Some generic animal sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound(){
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound(); // このコードを実行すると、"Bark"が表示される結果、コンソールに表示されます。
    }
}

このコードではDogクラスがAnimalクラスを拡張し、soundメソッドをオーバーライドしています。

@Overrideアノテーションが付与されることで、soundメソッドが正確にオーバーライドされていることをコンパイラが保証します。

このコードを実行すると、「Bark」という文字列がコンソールに表示されます。

この出力結果は、Dogクラスのsoundメソッドが呼び出されたことを表しています。

そして、アノテーションが正しく機能していることが確認できます。

○サンプルコード2：@SuppressWarningsの活用

Javaのプログラミングにおいて、警告メッセージはコードの品質を維持するのに非常に有用です。

しかし、時として特定の警告が邪魔になることがあります。

そこで@SuppressWarningsアノテーションが登場します。

このアノテーションは、特定の警告を抑制するために使用されます。

下記のコードは、このアノテーションの基本的な使用法です。

まず、アノテーションの基本形を見てみましょう。

@SuppressWarnings("警告キー")
public void メソッド名() {
    // メソッドの内容
}

このコードでは、”警告キー”という部分に抑制したい警告の種類を指定します。

この警告キーは特定の警告を特定するために使用されます。

例えば、未使用の変数の警告を抑制するためには”unused”というキーを使います。

このアノテーションを実際に使って、未使用の変数警告を抑制するコードを見てみましょう。

@SuppressWarnings("unused")
public void exampleMethod() {
    int i = 0;
}

このコードでは、未使用の変数iを宣言していますが、”unused”という警告キーを使ってその警告を抑制しています。

このコードを実行すると、警告が表示されず、特に何も起こりません。

また、複数の警告を抑制する場合は、警告キーをカンマで区切って指定します。

@SuppressWarnings({"unused", "rawtypes"})
public void anotherExampleMethod() {
    int i = 0;
    List list = new ArrayList();
}

このコードでは、未使用の変数警告とrawtypes警告を抑制しています。

未使用の変数iと非ジェネリックタイプのListを使用しているため、これらの警告が通常発生しますが、@SuppressWarningsアノテーションによって警告が抑制されます。

さらに、このアノテーションはクラスやフィールド、ローカル変数にも適用することが可能です。

これにより、特定の部分の警告のみを効果的に抑制することができます。

このアノテーションを利用することでコードがスッキリとし、必要な警告のみを確認できるようになります。

しかし、警告を抑制しすぎると、本来気づくべき問題点を見逃す恐れがありますので、注意が必要です。

○サンプルコード3：@Deprecatedの適用方法

Javaにおける@Deprecatedアノテーションは、メソッドやクラスが古くなったり、推奨されなくなったりした場合に使用します。

このアノテーションを使うことで、他の開発者に対して「このメソッドやクラスは今後のバージョンで削除される可能性があります」というメッセージを伝えることができます。

下記のサンプルコードでは、@Deprecatedアノテーションの使用方法とそれに続く新しいメソッドの例を提示しています。

public class DeprecatedExample {

    /**
     * このメソッドは古くなったメソッドです。新しいメソッドを使用してください。
     * @deprecated
     */
    @Deprecated
    public static void oldMethod() {
        System.out.println("古いメソッド");
    }

    /**
     * このメソッドは新しいメソッドで、古いメソッドの代わりに使用します。
     */
    public static void newMethod() {
        System.out.println("新しいメソッド");
    }

    public static void main(String[] args) {
        oldMethod();  // 警告: [deprecation] oldMethod() in DeprecatedExample has been deprecated
        newMethod();
    }
}

このコードでは、oldMethodというメソッドに@Deprecatedアノテーションを適用しています。

このメソッドを呼び出すとコンパイラは警告を出力します。

この警告は、メソッドが古くなったことを表し、新しいメソッドの使用を奨励するためです。

また、@DeprecatedアノテーションにはJavadocの@deprecatedタグも併用され、それによって開発者は古いメソッドに関する情報を得ることができます。

newMethodという新しいメソッドも作成され、これがoldMethodの代わりに使用されることを意図しています。

mainメソッド内で古いメソッドを呼び出すと、警告が表示されることを示しています。

このコードを実行すると、次の出力が得られます。

古いメソッド
新しいメソッド

古いメソッドがまだ機能すること、そして新しいメソッドも正常に動作することが確認できます。

ただし、将来的には古いメソッドが削除される可能性がありますので、新しいメソッドの使用が推奨されます。

○サンプルコード4：@FunctionalInterfaceの特徴

Javaの世界におけるアノテーションはコードに追加情報を付与し、それに基づいてコンパイラやJVMが特定の動作を行うための一種の指示やマークアップとなります。

その中でも、”@FunctionalInterface” アノテーションは特に関数型インターフェイスを表すためのマークとして使われます。

ここでは、このアノテーションの特徴とサンプルコードを通じてその利用方法を詳細に解説します。

まず、@FunctionalInterfaceアノテーションの基本的な特徴から把握していきましょう。

このアノテーションは、インターフェイスが正確に1つの抽象メソッドを持つことを表します。

そして、このインターフェイスはラムダ式で使用できるようになります。

ここで、重要なポイントは「1つの抽象メソッド」という条件であり、それを満たさない場合コンパイルエラーが発生します。

次に具体的なコード例を見ていきましょう。

@FunctionalInterface
interface Greeting {
    void sayHello(String name);

    // void sayGoodbye(String name); この行を追加するとコンパイルエラーが発生します
}

このコードでは、Greetingというインターフェイスに@FunctionalInterfaceアノテーションを付けています。

そして、sayHelloという1つの抽象メソッドを定義しています。

この構造がアノテーションの条件を満たしているので、このインターフェイスはラムダ式で使用できます。

このインターフェイスを利用して実際のコードを書いてみましょう。

public class Main {
    public static void main(String[] args) {
        Greeting greeting = name -> System.out.println("Hello, " + name);
        greeting.sayHello("World");
    }
}

このコードを実行すると、コンソールに「Hello, World」と表示されるのが見られます。

この場合、ラムダ式name -> System.out.println("Hello, " + name)はGreetingインターフェイスのsayHelloメソッドを実装しています。

さらにこのアノテーションの使い方を探求してみると、@FunctionalInterfaceアノテーションが付与されたインターフェイスは他のインターフェイスを継承することも可能です。

ただし、抽象メソッドが1つである条件を維持する必要があります。

@FunctionalInterface
interface Salutation extends Greeting {
    // ここで新しい抽象メソッドを追加するとコンパイルエラーが発生します
}

このコードではSalutationインターフェイスがGreetingインターフェイスを継承していますが、新しい抽象メソッドを追加していないため、コンパイルエラーは発生しません。

●アノテーションの応用例

Javaアノテーションは、コードにメタデータを追加することで、その動作を定義したり、コンパイラへのヒントを提供したりする機能があります。

応用段階に入ると、更に多くの動作をカスタマイズし、効率的なコードを作成することが可能となります。

次の部分では、アノテーションの応用例として独自のアノテーションの作成方法について詳しく説明します。

また、サンプルコードも提供し、それに関連した詳細な説明と実行結果についても触れます。

○サンプルコード5：独自アノテーションの作成方法

独自アノテーションを作成することは、Javaプログラムにおける高度なテクニックの一つです。

これは、特定のルールやパターンを強制するための独自のチェックを作成できるため、コードの品質を向上させることができます。

下記のサンプルコードでは、新しいアノテーション「@Info」を作成し、それを使用する方法を表します。

// このコードでは、独自のアノテーションを定義しています
public @interface Info {
    String author();
    String date();
}

// このコードは、@Infoアノテーションを使用しています
public class SampleClass {

    @Info(author = "Yamada", date = "2023-09-01")
    public void sampleMethod() {
        // メソッドの実装
    }
}

このコードでは「Info」という名前のアノテーションを作成しています。

属性として「author」および「date」を持っており、クラスやメソッドに付与できるよう設計されています。

このアノテーションをクラスやメソッドに適用すると、メタデータとしてその情報を保持することができます。

ここでは、「SampleClass」クラスの「sampleMethod」メソッドに「@Info」アノテーションを付与し、それに「author」と「date」の属性値を指定しています。

このコードを実行すると、特に明示的な動作は発生しませんが、アノテーションの情報はメタデータとしてクラスやメソッドに保持されます。

このメタデータは、後でリフレクションを使用して読み取ることができます。

また、特定のツールやライブラリを使用してアノテーション情報を解析し、それに基づいたさまざまな動作を行うことが可能です。

このような特性を利用することで、コードの可読性を向上させるとともに、特定のパターンや規約を強化することができます。

○サンプルコード6：アノテーションを活用したテストケースの作成

Javaアノテーションはコードの動作を指定したり、コードの解析を行う際に非常に便利なツールです。

初心者から上級者まで幅広いプログラマーが利用できるこのテクニックを活用しましょう。

今回は、アノテーションを活用したテストケースの作成方法について解説します。

アノテーションの活用はプログラミングの高度な段階とされており、特にテストケースの作成時にその力を発揮します。

ここでは、JUnitを利用したテストケース作成におけるアノテーションの活用方法を具体的なサンプルコードとともに説明します。

さらに、サンプルコードには日本語で詳細な説明を加えることで、理解を深める手助けとします。

まずはサンプルコードを見ていきましょう。

import org.junit.jupiter.api.Test;

public class SampleTest {

    @Test
    public void testAddition() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result, "2 + 3 should equal 5");
    }
}

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

このコードでは、JUnitの@Testアノテーションを使って、Calculatorクラスのaddメソッドをテストするテストケースを作成しています。

@Testアノテーションは、その後に続くメソッドがテストメソッドであることをJUnitに通知します。

次にコードの詳細な説明を行います。

ここではCalculatorクラスのaddメソッドをテストするシンプルなテストケースを見ています。

このテストケースは@Testアノテーションを使用して定義されており、testAdditionメソッド内でCalculatorオブジェクトを作成し、addメソッドを呼び出してその結果を検証しています。

assertEqualsメソッドを使うことで、addメソッドが期待した結果を返すかどうかをテストしています。

このコードを実行すると、テストが成功すると期待されます。

なぜなら、2と3を加えると5になり、これはassertEqualsメソッドで指定した期待値と一致するからです。

このようなテストケースは、コードが正しく機能していることを確認する上で非常に重要な役割を果たします。

○サンプルコード7：アノテーションとリフレクションの連携

Javaのアノテーションとリフレクションを連携させることで、コードの動的な挙動を制御できる強力なツールを手に入れることができます。

ここでは、アノテーションとリフレクションがどのように連携するか、そしてそれがどのようにコードの効率と機能を向上させるかを解説します。

まず初めに、カスタムアノテーションを作成します。

下記のコードは、特定のメソッドに関連付けることができる単純なアノテーションです。

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface CustomAnnotation {
    String value();
}

このコードでは、@Retentionアノテーションを使ってRUNTIMEポリシーを設定しています。

これにより、アノテーション情報はランタイム時に保持され、リフレクションAPIで利用可能になります。

次に、カスタムアノテーションを使用してメソッドに注釈を付けるクラスを作成します。

public class AnnotationExample {

    @CustomAnnotation(value = "Hello, World!")
    public void greet() {
        System.out.println("Greeting...");
    }
}

このコードを実行すると、greetメソッドにCustomAnnotationが適用され、「Hello, World!」という値を付与します。

次に、リフレクションを使用してアノテーション情報を取得し、その情報を使用して何らかの動作を行うコードを作成します。

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            Method method = AnnotationExample.class.getMethod("greet");
            CustomAnnotation annotation = method.getAnnotation(CustomAnnotation.class);

            if(annotation != null) {
                System.out.println(annotation.value());
            } else {
                System.out.println("No annotation found.");
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

このコードでは、AnnotationExampleクラスのgreetメソッドを取得し、getAnnotationメソッドを使用してCustomAnnotationアノテーションのインスタンスを取得しています。

そして、アノテーションのvalueメソッドを呼び出して値を取得し、コンソールに出力します。

実行結果として、コンソールには「Hello, World!」と表示されます。

これは、リフレクションを使用してアノテーションから値を取得し、その値を出力したためです。

○サンプルコード8：条件に応じたアノテーションの活用

Javaプログラミングにおいて、条件に応じたアノテーションの利用は、コードの可読性や再利用性を向上させる上で非常に重要な要素となります。

今回は、条件に応じたアノテーションの活用に焦点を当て、その詳細な解説を行いながら実用的なサンプルコードを提供していきます。

ここでは、アノテーションの基本的な構造を把握した上で、具体的な使用例を紹介し、その効果的な活用方法を解説していきます。

まず初めに、条件に応じたアノテーションとはどのようなものかを理解しましょう。

条件に応じたアノテーションとは、特定の条件下で特定の動作を行うようプログラムに指示するマーカーとして機能するアノテーションを指します。

これにより、コードの動作を柔軟に制御することが可能となります。

下記のサンプルコードは、条件に応じたアノテーションの一例を表しています。

このコードでは、条件を満たす場合に特定のメソッドを実行するようアノテーションを定義しています。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Conditional {
    String condition();
}

public class ConditionalExecutor {
    @Conditional(condition = "ENVIRONMENT=development")
    public void executeInDevelopment() {
        System.out.println("This method is executed in development environment");
    }

    @Conditional(condition = "ENVIRONMENT=production")
    public void executeInProduction() {
        System.out.println("This method is executed in production environment");
    }

    public static void main(String[] args) {
        ConditionalExecutor executor = new ConditionalExecutor();
        for (java.lang.reflect.Method method : executor.getClass().getMethods()) {
            Conditional conditional = method.getAnnotation(Conditional.class);
            if (conditional != null && "ENVIRONMENT=development".equals(System.getenv(conditional.condition()))) {
                try {
                    method.invoke(executor);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

このコードでは、@Retention(RetentionPolicy.RUNTIME) と @Target(ElementType.METHOD) を使用してアノテーション Conditional を定義しています。

また、ConditionalExecutor クラス内には、@Conditional アノテーションを用いて条件に基づいたメソッドの実行を指示するメソッドが定義されています。

このコードを実行すると、システム環境変数 ENVIRONMENT の値に基づいて、適切なメソッドが実行されるようになります。

つまり、ENVIRONMENT 変数が development の場合は executeInDevelopment メソッドが、production の場合は executeInProduction メソッドが実行されるのです。

●アノテーションの詳細な注意点

Javaのアノテーションは非常に便利なツールであり、多くのJavaプログラマーが頻繁に使用しています。

しかし、アノテーションを正しく、効果的に使用するためには、いくつかの重要な注意点を知っておく必要があります。

○サンプルコード9：アノテーションの継承とその落とし穴

Javaのアノテーションには継承の概念が存在しないため、アノテーション自体を継承することはできません。

しかし、クラスやインターフェースにアノテーションを付与した場合、その子クラスや実装クラスでもそのアノテーションが引き継がれるかどうかは、アノテーションの定義によって異なります。

// これは一般的なアノテーションの定義です。
public @interface SampleAnnotation {
    String value() default "";
}

// このアノテーションをクラスに付与します。
@SampleAnnotation(value="SuperClass")
public class SuperClass {}

// 子クラスを作成します。
public class SubClass extends SuperClass {}

このコードでは、SampleAnnotationというアノテーションをSuperClassに付与しています。

しかし、SubClassはこのアノテーションを明示的に継承しているわけではありません。

そのため、SubClassにSampleAnnotationが存在するかどうかを調べると、結果は存在しないこととなります。

アノテーションの継承に関連するこの落とし穴を理解しておかないと、予期しない動作やエラーに遭遇するリスクがあります。

このコードの実行結果、SuperClassにはSampleAnnotationが付与されていますが、SubClassには付与されていないため、SubClassに対してSampleAnnotationを検索または取得しようとすると失敗します。

○サンプルコード10：アノテーションのリテンションポリシー

Javaのアノテーションは、メタデータをコードに埋め込む強力なツールとして知られています。

アノテーションの中でも非常に重要な概念が「リテンションポリシー」となります。

ここでは、Javaで使用されるリテンションポリシーに関するサンプルコードを超絶詳細に解説いたします。

リテンションポリシーは、アノテーションがどの段階まで保持されるかを定義します。

Javaには主に3種類のリテンションポリシーがあります：SOURCE、CLASS、そしてRUNTIMEです。

それぞれのポリシーに対するサンプルコードとその実行結果を紹介します。

まず最初にSOURCEリテンションポリシーについて説明します。

このポリシーはアノテーションがソースコードにのみ存在し、コンパイル時には破棄されることを意味します。

下記のコードは、SOURCEリテンションポリシーを表しています。

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.SOURCE)
public @interface SourceAnnotation {
}

このコードでは、SourceAnnotationという新しいアノテーションを作成し、リテンションポリシーをSOURCEとして設定しています。

このコードを実行すると、このアノテーションはコンパイル時に破棄され、バイトコードレベルでは利用できません。

次に、CLASSリテンションポリシーです。

このポリシーはアノテーションがコンパイル時に保持され、ランタイムには破棄されることを意味します。

下記のコードは、CLASSリテンションポリシーを表すものです。

@Retention(RetentionPolicy.CLASS)
public @interface ClassAnnotation {
}

このコードではClassAnnotationというアノテーションを定義しており、それがコンパイル時に保持されるが、ランタイムには利用できなくなることを示しています。

最後に、RUNTIMEリテンションポリシーです。

このポリシーはアノテーションがランタイム時にも保持され、リフレクションを使って情報を取得することができます。

下記のコードは、RUNTIMEリテンションポリシーの使用例を表しています。

@Retention(RetentionPolicy.RUNTIME)
public @interface RuntimeAnnotation {
}

このコードを実行すると、RuntimeAnnotationアノテーションはランタイム時にも保持されるため、プログラム実行中にこのアノテーションの情報を取得することが可能です。

●アノテーションの詳細なカスタマイズ

Javaプログラミング言語の重要な特性の一つであるアノテーションは、コードにメタデータを追加して、その振る舞いや特性を調整する手段として利用されます。

アノテーションの詳細なカスタマイズは、プログラムの柔軟性と再利用性を高めることができます。

では、アノテーションのカスタマイズについて詳細に解説していきましょう。

○サンプルコード11：アノテーションのデフォルト値の設定方法

まずはアノテーションのデフォルト値の設定方法について説明します。

デフォルト値はアノテーションが特定のパラメータに対してデフォルトの値を持つことを可能にします。

この特性はアノテーションの柔軟性をさらに高め、特定の条件下で異なる動作をさせることができます。

Javaでデフォルト値を持つアノテーションを作成するには、「default」キーワードを使用します。

下記のサンプルコードは、デフォルト値を持つアノテーションを作成しています。

このコードでは、”CustomAnnotation”という名前のアノテーションを定義しており、”description”と”name”という二つのパラメータがあります。

また、”description”パラメータにはデフォルト値として”Default Description”が設定されています。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomAnnotation {
    String description() default "Default Description";
    String name();
}

このコードを実行すると、「CustomAnnotation」アノテーションは「description」パラメータにデフォルト値”Default Description”を持つこととなります。

また、”name”パラメータはデフォルト値が設定されていないため、アノテーションを利用する際に必ずこのパラメータに値を設定する必要があります。

このアノテーションを利用したメソッドは、次のように記述することができます。

public class AnnotationExample {

    @CustomAnnotation(name = "Test Method")
    public void testMethod() {
        // メソッドの実装
    }
}

このコードを実行すると、”testMethod”というメソッドが”CustomAnnotation”アノテーションを持ち、”name”パラメータに”Test Method”という値を持つことになります。

そして、「description」パラメータはデフォルト値”Default Description”が適用されるため、明示的な設定がなくてもこの値が利用されることになります。

○サンプルコード12：複数の値を持つアノテーションの設計

Javaのアノテーションはメタデータをコードに追加するためのツールとして非常に有効です。

それでは、複数の値を持つアノテーションを設計する方法について詳細に解説します。

ここでは、あるアノテーションが複数のパラメータを受け取れるように設計する方法とその解説を提供します。

まず最初に、複数の値を持つアノテーションを作成するための基本的なステップを見ていきましょう。

下記のコードは、@MultipleValuesという名前のアノテーションを作成し、それにvalue1とvalue2という名前の2つのパラメータを割り当てています。

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface MultipleValues {
    String value1();
    int value2();
}

このコードでは、@Retentionアノテーションを用いてアノテーションのリテンションポリシーをRUNTIMEに設定しています。

そして、@interfaceキーワードを用いて新しいアノテーションMultipleValuesを定義し、2つのメソッドvalue1とvalue2を定義しています。

これらのメソッドはアノテーションの要素となり、アノテーションを使用する際に値を指定できます。

次に、このアノテーションを使うためのクラスを作成します。

下記のコードは、MultipleValuesアノテーションを適用し、そのパラメータに値を割り当てているクラスの例です。

public class TestClass {
    @MultipleValues(value1 = "Hello", value2 = 123)
    public void testMethod() {
        // メソッドの実装
    }
}

このコードを実行すると、TestClassクラスのtestMethodメソッドに@MultipleValuesアノテーションが適用され、その要素に指定された値が割り当てられます。

具体的にはvalue1には”Hello”という文字列が、value2には123という数値が割り当てられます。

まとめ

Javaアノテーションの世界は深く、その使い方やカスタマイズ方法は非常に幅広く、プログラマーのスキルレベルにかかわらず、初心者から上級者まで多くの人が利益を得ることができるテーマです。

この記事では、Javaアノテーションの基本的な概念から高度な使い方までを徹底的に解説しました。

読者の皆さんがJavaアノテーションをマスターして、より効率的かつ効果的なコードを作成できるよう願っています。

今後とも、このような有益な情報を提供できるよう努めてまいりますので、どうぞよろしくお願い申し上げます。