[Java] Anmerkung

Anmerkung

• Typen wie Klassenschnittstellen und Markierungen, die Mitgliedern zugewiesen werden können
• ** Sie können Ihrem Code zufällige Informationen hinzufügen, die nicht direkt mit der ursprünglichen Logik der App zusammenhängen. **
• Beschrieben am Anfang der Zieldeklaration

@Override

• Anmerkungen der Standardbibliothek
• Deklarieren Sie, dass die Zielmethode ** die Basisklassenmethode überschreibt **
• Der Compiler warnt Sie, auch wenn Sie ihn aufgrund eines Fehlers im Argument nicht überschreiben können.

public class Person {
  private String firstName;
  private String lastName;

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return String.format("Name ist,%s %s.",
        this.lastName, this.firstName);
  }

  public String getLastName() {
    return this.lastName;
  }

  public String getFirstName() {
    return this.firstName;
  }
}

@WebServlet

• Was ist ein Servlet? ** Eine Art Basistechnologie zum Ausführen von Java-Apps in einer Serverumgebung **
• Grundlegende Konfigurationsinformationen des Servlets
• ** urlPatterns **: URL zum Aufrufen des Servlets
• ** initParams **: Parameterinformationen im Servlet verfügbar

Annotationspunkt

• ** Anmerkungen können verschachtelt werden **
• ** Wenn es ein Element gibt, kann {...} des Arrays weggelassen werden **
  • urlPatterns = "/init-param"
• ** Attributnamenwerte können weggelassen werden **
  • @WebServlet (values="init-param")
  • @WebServlet ("init-param")
• ** Kann weggelassen werden, wenn kein Attribut vorhanden ist **
• Markierungsanmerkung (@Override usw.)

Standardanmerkung

• @Override: Gibt an, dass Sie eine Methode in der Basisklasse überschreiben
• @Deprecated: Erklärt, dass Klassen, Mitglieder usw. veraltet sind
• @SuppressWarnings: Unterdrückt Compiler-Warnungen
• @SafeVarargs: Deklariert die Typensicherheit für Argumente variabler Länge
• @FunctionalInterface: Gibt an, dass die Schnittstelle als funktionale Schnittstelle definiert werden soll

@Deprecated

• Klasse, Methode usw. deklarieren ** veraltet **
• Integer-Konstruktor ist in Java 9 und höher veraltet (Since =" 9 ")
• Auch in der Dokumentation beschrieben
• Kompilierungsdurchläufe, aber Warnung wird angezeigt

Integer.java

/**
 *Unterlassung
 * @deprecated
 * It is rarely appropriate to use this constructor. The static factory
 * {@link #valueOf(int)} is generally a better choice, as it is
 * likely to yield significantly better space and time performance.
 */

@Deprecated(since="9")
public Integer(int value) {
    this.value = value;
}

@SuppressWarnings

• ** Spezifische Bereichs- / Typ-Compiler-Warnungen ausblenden **
• Verhindert die Überwachung anderer Warnungen, die bestätigt werden sollten
• Hinweis darauf, dass Sie absichtlich den zu warnenden Code verwenden

public class AnnotationBasic {

  public static Integer process() {
   @SuppressWarnings("deprecation")
    var i = new Integer(108);
   return i;
  }

  public static void main(String[] args) {
    System.out.println(process());
  }
}

@SafeVarargs

• ** Deklariert die Typensicherheit für Argumente variabler Länge und es wird keine Warnung angezeigt **
• Warnung wird angezeigt, wenn der generische Typ als Argument mit variabler Länge festgelegt ist
• Erklärung, dass dem Entwickler bekannt ist, dass es typsicher ist

Selbstgemachte Anmerkung

• Anmerkungen können im Gegensatz zu Modifikatoren selbst erstellt werden
• ** Die Anmerkung wird durch die Anweisung @interface definiert **
• ** Deklarieren Sie Attribute, die in Anmerkungen verwendet werden können, unter @interface **
• Geben Sie im folgenden @ClassInfo das Versionsattribut mit dem Versionsattribut und dem Wertattribut an.
• @ ClassInfo (version =" 2.1 ", description =" annotation test ") * @ClassInfo(version="2.1")
• ** Beschreiben Sie die Meta-Annotation, die Informationen zur Annotationskonfiguration deklariert. **
• @Documented: Reflektiert Annotationsinformationen in Javadoc
• @Target: Entscheiden Sie, auf welches Element die Anmerkung angewendet werden soll
• @Inherited: Anmerkungen werden von abgeleiteten Klassen geerbt
• @Retention: Wie lange sollen die Anmerkungsinformationen aufbewahrt werden?

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

//Deklaration der Konfigurationsinformationen
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
//@Anmerkungsdefinition mit Schnittstellenbefehl
public @interface ClassInfo {
  //Deklarieren Sie Attribute, die in Anmerkungen verwendet werden können
  String value() default "";
  String version() default "";
  String description() default "";
}

Verwenden Sie Anmerkungen zur Reflexion

• ** Reflexion **: Abrufen und Bearbeiten von Typinformationen während der Codeausführung
• Im Folgenden werden die durch die ** Class.forName-Methode ** angegebenen Typinformationen von der Class-Klasse erfasst.
• Marker-Annotation: Ich interessiere mich für das Vorhandensein der Annotation selbst, nicht für die Informationen (Attribute), die in der Annotation enthalten sind **
• ** isAnnotationPresent-Methode ** zum Überprüfen auf Anmerkungen

package mypackage;

//ClassInfo-Anmerkungsspezifikation
@ClassInfo(version = "2.1", description = "Annotation Operationstest")
// @ClassInfo("2.1")
public class AnnotationClient {
  public static void main(String[] args) throws ClassNotFoundException {
    //Holen Sie sich untergeordnete Mitglieder über das Klassenobjekt
    var clazz = Class.forName("mypackage.AnnotationClient");
    //Abrufen von Anmerkungen, die der Klasse mit der Methode getAnnotation zugewiesen wurden
    var info = (ClassInfo)
 clazz.getAnnotation(ClassInfo.class);
    System.out.println("Ausführung:" +
        (info.value().equals("") ? info.version() : info.value()));
    System.out.println("Erläuterung:" + info.description());
  }
}

Reflexionsmethode

Objekterstellung

• Instanzgenerierung über Konstruktor
• Generieren Sie einen Konstruktor zum Aufrufen mit der ** getConstructor-Methode ** der Class-Klasse
• ** Erstellen Sie ein Objekt, indem Sie es mit der newInstance-Methode aufrufen **
• ** Array.newInstance-Methode ** zum Generieren eines Arrays
• ** Methode festlegen ** zum Festlegen von Array-Elementen

import java.io.File;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;

public class ReflectInstance {

  public static void main(String[] args) {
    try {
      //Dateiklasse abrufen
      var clazz = File.class;

      //Dateiobjekt über Konstruktor erstellen
      var c = clazz.getConstructor(String.class);
      var fl = c.newInstance("./data/data.txt");
      System.out.println(fl);

      //Array-Generierung der Größe 2
      var list = (File[]) Array.newInstance(File.class, 2);
      Array.set(list, 0, fl);
      System.out.println(Arrays.toString(list));
    } catch (InstantiationException | IllegalAccessException |
        IllegalArgumentException | InvocationTargetException
        | NoSuchMethodException | SecurityException e) {
      e.printStackTrace();
    }
  }
}

Holen Sie sich alle Methoden

• ** Öffentliche Methodenaufzählung der Dateiklasse mit der Methode getMethods **
• Gibt eine öffentliche Methode als Array von Methodenobjekten zurück
• Wenn Sie etwas anderes als public verwenden möchten, rufen Sie alle Methoden mit der Methode ** getDeclaredMethods ** ab

import java.io.File;

public class ReflectMethods {

  public static void main(String[] args) {
    //Dateiklasse abrufen
    var str = File.class;
    //Listen Sie die öffentlichen Methoden unter der File-Klasse mit getName auf
    for (var m : str.getMethods()) {
      System.out.println(m.getName());
    }
  }
}

Methodenausführung

• ** Über Methodenobjekt ausführen **
• ** GetMethod-Methode ** zum Abrufen einer einzelnen Methode und ** Aufrufen der Methode ** zum Ausführen

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectInvoke {

  public static void main(String[] args) {
    try {
      //Dateiklasse abrufen
      var clazz = File.class;
      //Dateiobjekterstellung
      var f1 = clazz.getConstructor(String.class).newInstance("./data/data.txt");
      var f2 = clazz.getConstructor(String.class).newInstance("./data/sample.txt");
      //Ruft die Methode renameTo ab und führt sie aus
      Method m = clazz.getMethod("renameTo", File.class);
      System.out.println(m.invoke(f1, f2));
    } catch (NoSuchMethodException | SecurityException |
        InstantiationException | IllegalAccessException
        | IllegalArgumentException | InvocationTargetException e) {
      e.printStackTrace();
    }
  }
}

Felderfassung, Einstellung

• öffentliches Feld wird durch ** getField-Methode ** erhalten
• Andere Felder können mit der Methode ** getDeclaredFiled ** abgerufen werden
• Argument gibt den Namen des Feldes an, das Sie erhalten möchten
• Nachdem Sie das Field-Objekt erhalten haben, rufen Sie den Feldwert mit der Methode ** get / set ** ab.
• Auf private Felder kann nicht so zugegriffen werden, wie sie sind. Erlauben Sie daher explizit den Zugriff mit der ** setAccessible-Methode **
• Hinweis: Die Reflexion ist ** langsam **

//Feld Nachname der Personenklasse abrufen

import java.lang.reflect.InvocationTargetException;
import example.Person;

public class ReflectField {

  public static void main(String[] args) {
    try {
      var clazz = Person.class;
      var con = clazz.getConstructor(String.class, String.class);
      var p = con.newInstance("Taro", "Yamada");
      //Feldakquisition
      var last = clazz.getDeclaredField("lastName");
      //Ermöglichen Sie explizit den Zugriff auf private Felder
      last.setAccessible(true);
      //get/Feldwert mit set-Methode abrufen/Aufbau
      last.set(p, "Suzuki");
      System.out.println(last.get(p)); //Suzuki
    } catch (NoSuchMethodException | SecurityException |
        InstantiationException | IllegalAccessException
        | IllegalArgumentException | InvocationTargetException |
        NoSuchFieldException e) {
      e.printStackTrace();
    }
  }
}

package example;
public class Person {
  private String firstName;
  private String lastName;
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  @Override
  public String toString() {
    return String.format("Name ist,%s %s.",
        this.lastName, this.firstName);
  }
  public String getLastName() {
    return this.lastName;
  }
  public String getFirstName() {
    return this.firstName;
  }
}