JAVA-B3 Reflection API Overview Annotations Basics Marker-Annotationen Annotationen mit Werten Multiple Annotations Type-Annotationen Deklaration Predefined Annotations @Deprecated @Override @SuppressWarnings @FunctionalInterface Meta-Annotationen @Retention @Documented @Target @Inherited @Repeatable Pluggable-Type-System Annotations Repeating-Annotations (Java 8) @Repeatable @Repeatable @ExampleAuthor Annotations FAQ Annotation Example: AOP AOP Aspect Oriented Programming mit Custom Annotations AopRechnerInterface AopRechnerImpl AopRechnerInterface AopCheckHatZugangInterceptor AopCheckHatZugangAnnotation AopZugangssystem

Predefined Interfaces Iterable RandomAccess Serializable Cloneable INDEX

Predefined

Annotationen | Predefined

Eine Reihe von Annotationen sind bereits Teil des JDK und werden deshalb auch für die Markierung von Packages, Klassen, Methoden und Feldern verwendet. Auch Annotationen selbst werden wiederum mit Annotationen ergänzt.

Wir gehen auf die üblichen Annotationen wie @Deprecated, @Override, @SuppressWarnings, @SafeVarargs, @FunctionalInterface sowie auch auf Meta-Annotationen @Retention, @Documented, @Target, @Inherited und @Repeatable (Java 8) ein.

Annotationen in Java

Annotationen | Annotationen in Java

Einige Annotationen sind Kernbestandteil von Java und werden auch in der Entwicklung von Java-Packages, Klassen, Methoden, Feldern und dergleichen von ORACLE und anderen Entwicklern konsequent selbst verwendet.

@Deprecated, @Override, @SuppressWarnings, @SafeVarargs, @FunctionalInterace

Wir gehen auf diese Annotationen kurz ein.

@Deprecated

Annotationen | @Deprecated

Die @Deprecated Annotation markiert ein Element als «deprecated». Dieses bedeutet, dass Entwickler dieses Element nicht mehr nutzen sollte, weil es in einer der kommenden Versionen von Java selbst oder vom Entwickler eines Programms zukünftig geändert oder entfernt wird.

Der Compiler erzeugt für jeder Klasse, Methode oder jedes Feld eine Warnung, wenn denn diese mit dieser Annotation markiert wurde.



 // Javadoc Kommentar
 /**
 * @deprecated
 * Kurzer Erläuterung wieso und weshalb
 */
 @Deprecated
 static void deprecatedMethod() { }
}

Man sollte zusätzlich immer noch im Dokumentationscode darüber ebenso für Javadoc Syntax @deprecated angeben.

Annotationen beginnen immer mit einem großen Buchstaben,# weil es sich um Interfaces und damit quasi einen Typ handelt.

Die Syntax von JavaDoc weicht von Java ab. Dort werden solche «Tags» mit kleinem Buchstaben begonnen wie @deprecated oder auch @code, @author und dergleichen.

@Override

Annotationen | @Override

informs the compiler that the element is meant to override an element declared in a superclass. Overriding methods will be discussed in Interfaces and Inheritance.

Die @Override annotation bedeutet, dass ein Element, welches einer Superklasse deklariert wurde, nun überschrieben werden soll, dh. für ein Objekt der Klasse mit der überschriebenen Methode gilt diese auch dann, wenn das Objekt in einer Variable des Typs der Superklasse gespeichert wird.

Mehr Informationen hierzu sind im Themenblock «Interfaces» und «Vererbung» zu finden.



package com.stuelken.java.b3.annotations.predefined;

/**
 * Basisklasse mit {@link #machEtwas()} Methode welche von {@link Subklasse} mit
 * {@link Subklasse#machEtwas()} überschrieben wird.
 * 
 * @author t2m
 */
class Basisklasse {

	/**
	 * Parameterloser Konstruktor
	 */
	public Basisklasse() {
	}

	/**
	 * Die zu überschreibende Methode
	 */
	public void machEtwas() {
		System.out.println("// Ich mache etwas.");
	}
}

/**
 * Subklasse welche die {@link #machEtwas()} Methode der {@link Basisklasse} überschreiben wird.
 * 
 * {@index "Example Annotations @Override" }
 * 
 * @author t2m
 */
class Subklasse extends Basisklasse {

	/**
	 * Konstruktor
	 */
	Subklasse() {
		super();
	}

	@Override
	public void machEtwas() {
		System.out.println("// Ich mache doch nichts.");
	}

}

/**
 * Klasse welche das eigentliche mit Hauptprogramm beinhaltet.
 * 
 * @author t2m
 */
public class Programm {

	/**
	 * Unbenötigter Konstruktor
	 */
	Programm() {

	}

	/**
	 * Erzeugen eines Objekts der Basis- und Subklasse sowie speichern einer Subklasse-Instanz in einer
	 * Basisklasse Variable mit anschließender Ausgabe.
	 * 
	 * @param args Keine Argumente
	 */
	public static void main(String[] args) {
		Basisklasse base = new Basisklasse();
		Subklasse sub = new Subklasse();

		base.machEtwas();
		sub.machEtwas();

		Basisklasse anders = (Basisklasse) new Subklasse();
		anders.machEtwas();

		anders = new Subklasse();
		anders.machEtwas();

	}

}

//Ich mache etwas.
//Ich mache doch nichts.
//Ich mache doch nichts.
//Ich mache doch nichts.

@SuppressWarnings

Annotationen | @SuppressWarnings

Die @SuppressWarnings informiert den Compiler darüber, dass er bitte Warnungen für dieses Element unterdrücken möge.

Mehr Informationen hierzu sind im Themenblock «Interfaces» und «Vererbung» zu finden.



 // use a deprecated method and tell 
 // compiler not to generate a warning
 @SuppressWarnings("deprecation")
 void useDeprecatedMethod() {
 // deprecation warning
 // - suppressed
 objectOne.deprecatedMethod();
 }

Die Warnungen des Compilers gehören zu einer von zwei Kategorien, und zwar entweder "unchecked" und/oder "deprecation". Man kann also auch beide Typen von Warnungen unterdrücken, wenn man möchte.



@SuppressWarnings({"unchecked", "deprecation"})

https://docs.oracle.com/javase/8/docs/api/java/lang/SuppressWarnings.html

@SafeVarargs

Annotationen | @SafeVarargs

Die @SafeVarargs Annotation unterdrückt

Bei der Verwendung von Variablen Argumenten, VarArgs, kann der letzte Parameter einer Parameterliste für eine Methode mehrere Werte haben.

Im Beispiel wird eine Compiler-Warnung unterdrückt, weil wir hier versuchen, auf eine Liste mit einem Index zuzugreifen, was in Java so gar nicht geht ( in C# .NET durchaus, wenn man Indexer programmiert).



 @SafeVarargs // Not actually safe!
 static void m(List<String>... stringLists) {
 Object[] array = stringLists;
 List<Integer> tmpList = Arrays.asList(42);
 array[0] = tmpList; // Semantically invalid, but compiles without warnings
 String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
 }

https://docs.oracle.com/javase/8/docs/api/java/lang/SafeVarargs.html

@FunctionalInterface

Annotationen | @FunctionalInterface

Die @FunctionalInterface Annotation eingeführt mit JAVA 8, kennzeichnet ein Interface dahingehend, dass es also Funktionales Interfaces gem. Java Spezifikation verwendet werden soll.

Auf die Deklaration von solchen Funktionalen Interfaces gehen wir in einem eigenen Themenbereich ausgiebig ein. , da diese für Methodenreferenzen und Lambda-Expressions benötigt werden.

Meta Annotations

Annotationen | Meta Annotations

Ein Teil der Annotationen in Java sind sogenannte Meta-Annotationen: Man annotiert mit diesen wiederum Annotationen.

@Retention

Annotationen | @Retention

Die @Retention wie die Annotation gespeichert werden wird.

RetentionPolicy.SOURCE: Die markierte Annotation wird nur auf dem Level des Quellcodes und damit dem SOURCE-Level berücksichtigt und in dieser Konsequenz vom Compiler ignoriert.

Mit Hilfe dieses Ansatzes können andere Tools den Quellcode vor dem eigentlichen Kompilieren noch ergänzen. Für Frameworks ist das ein praktischer Aspekt.

RetentionPolicy.CLASS: Die mit dieser Wert markierte Annotation wird vom Compiler beim Kompilieren berücksichtigt, bei der eigentlichen Ausführung in der Java Virtual Machine, VM, ignoriert.

RetentionPolicy.RUNTIME: Die mit diesem Wert markierte Annotation kann zur Laufzeit in der Java Virtual Machine JVM ausgewertet werden.

@Documented

Annotationen | @Documented

@Documented weist darauf hin, dass die zugehörige Annotation über JavaDoc dokumentiert werden soll.

Das ist dahingehend von Bedeutung, weil JavaDoc normalerweise keine Annotationen dokumentiert. Mehr Infos hierzu siehe JavaDoc, Doclet API, Taglet API, Doctree API und dergleichen.

https://docs.oracle.com/javase/8/docs/technotes/guides/javadoc/index.html

@Target

Annotationen | @Target

@Target dient dazu, eine Animation auf bestimmte Java Elemente beschränken zu können, so dass diese Annotation tatsächlich nur für die Typen genutzt werden kann, welche angegeben werden.




ElementType.ANNOTATION_TYPE Anwendbar auf Annotationen
ElementType.CONSTRUCTOR Anwendbar auf Konstruktoren von Klassen
ElementType.FIELD Anwendbar auf Felder und Properties
ElementType.LOCAL_VARIABLE Anwendbar auf lokale Variablen
ElementType.METHOD Anwendbar auf Methoden
ElementType.PACKAGE Anwendbar auf Package-Deklarationen
ElementType.PARAMETER Anwendbar auf Parameter von Methoden
ElementType.TYPE Anwendbar auf jedes Element einer Klasse

@Inherited

Annotationen | @Inherited

Wenn eine Annotation mit @Inherited markiert wurde, kann der zugehörige Wert von der Superklasse geerbt werden. Das ist normalerweise nicht der Fall.

Wenn der Wert Annotation abgefragt wird und die Klasse für diesen Typ gar keine Annotation hat, so wird der Vererbung folgend versucht, die Annotation von der Superklasse zu bekommen.

Dieses gilt nur für Klassendeklarationen, nicht für Felder oder Methoden.

@Repeatable

Annotationen | @Repeatable

Mit @Repeatable (ab Java 8) markierte Annotationen können mehrfach für den selben Typ verwendet werden.

Mit diesem Ansatz ist es beispielweise möglich, eine eigene @Author-Annotation zu definieren, um auf diesem Wege dann auch zwei oder drei Autoren als Zusatzinformationen einer Klasse zuweisen zu können.

Das gilt mitunter z. B.a ach für @Schedule(..) oder @Alert(role="Administrator") und @Alert("role-Manager"), falls es mehrere wiederkehrende Zeitpunkte anzugeben sind oder aber auch mehr als eine Person wegen Ihrer Funktion zu benachrichtigen ist.

Mehr Informationen hierzu siehe Repeating-Annotations.

JAVA Vordefinierte Annotationen / Predefined Annotations