Hier erstelle ich jedoch eine Instanz, um nur "kann nicht überschrieben werden" darzustellen und von dieser Instanz aus aufzurufen, aber in erster Linie ist dies die statische Methode

 Human.getMorning();
 Developer.getMorning();

Und es ist wünschenswert, von der Klasse selbst zu verweisen, ohne die Instanz zu durchlaufen.

In der Tat, wenn Sie nur den obigen Code an IntelliJ übertragen

Wird als statische Methode bezeichnet, auf die die Klasse selbst nicht verweist.

(Besonderer Dank geht an @kawamnv)

public static void main(String [] args) Dies liegt daran, dass beim Aufrufen der Hauptmethode die Instanz noch nicht im Speicher vorhanden ist. Daher muss die Hauptmethode ausgeführt werden, auch wenn die Klasse, die sie enthält, nicht instanziiert wird.

statische Klasse (statische innere Klasse)

Es gibt drei Arten von Klassen: innere Klassen, Mitgliedsklassen, lokale Klassen und anonyme Klassen. Die statische Elementklasse ist eine der Elementklassen, und der Deklarationsspeicherort befindet sich im Klassenblock (dieselbe Position wie das Feld und die Methode). Genau genommen ist es jedoch schwierig, eine statische Elementklasse als innere Klasse zu bezeichnen, und es ist korrekter, sie als eine völlig andere Klasse zu beschreiben.

Wenn Sie die Klasse, die die innere Klasse einschließt, als äußere Klasse bezeichnen, Es hat eine relativ schwache Beziehung zur äußeren Klasse und ihren Instanzen und kann auch auf die statischen Mitglieder der äußeren Klasse zugreifen.

Wie andere statische Dinge wird es mit `externem Klassennamen.member Klassenname `verwendet.

Outer.java

class Outer { //Externe Klasse

  //Mitgliedsklasse ➀ statische Klasse
  static class StaticInner {
    private Integer in;

    public Integer getIn() {
      return in;
    }

    public void setIn(Integer in) {
      this.in = in;
    }
  }

  //Mitgliedsklasse ➁ Strenge Mitgliedsklasse
  class Inner {
    private String str;

    public String getStr() {
      return str;
    }

    public void setStr(String str) {
      this.str = str;
    }
  }
}

Aufrufe in irrelevanten Klassen und Hauptmethoden sind:

Execute.java

class Execute {
  public static void main(String[] args) {
    //statische Klasse
    Outer.StaticInner staticInner = new Outer.StaticInner();

    //Strenge Mitgliederklasse
    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();
  }
}

Wie ich im obigen Beispiel aufgenommen habe, ist eine strenge Mitgliedsklasse eng mit den einzelnen Instanzen verbunden, die von der äußeren Klasse erstellt wurden. Daher kann eine neue Klasse nicht ohne eine Instanz der äußeren Klasse erstellt werden. Da es sich nicht um eine statische Sache handelt, können auch nicht statische Mitglieder darauf zugreifen.

statischer Initialisierer

static {
  //wird bearbeitet
}

Ein statischer Initialisierer ist ein Block, der nur einmal ausgeführt wird, wenn eine Klasse geladen wird (.class-Datei wird geladen). Beschreiben Sie den Prozess, den Sie aufrufen und ausführen möchten, bevor Sie eine Klasse oder die Hauptmethode instanziieren. Natürlich können Sie nur statische Dinge beschreiben.

Gibt es eine Verwendung dafür? Ich dachte,

public final static String VALUE;

static {
  VALUE = makeValue();
} 

/**
 *Generieren Sie unter bestimmten Bedingungen dynamisch Werte
 * @Rückgabewert generierter Wert
 */
private static String makeValue() {
  // omit
}

Neulich konnte ich diese Art der Nutzung versehentlich ausprobieren. Ich denke, es war genau richtig, weil der Zweck darin bestand, "zu Beginn nur einmal vor der Instanziierung einen neuen Wert zu schaffen" und ihn wiederzuverwenden.

Konstruktor und statischer Initialisierer

class Something {

  void printA() {
    System.out.print("t");
  }

  void printB() {
    System.out.print("e");
  }

  Something () {
    System.out.print("l");
    printB();
  }

  static {
    System.out.print("i");
  }
}

class StaticTest {
  static {
    System.out.print("T");
  }

  public static void main(String [] args) {
    System.out.print("o");
    new Something().printA();
  }
}

Das Ergebnis ist Toilette </ font>. Sie können sehen, dass der statische Initialisierer früher aufgerufen wird als der Konstruktor, der schließlich von new aufgerufen wird (Instanziierung).

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target({FIELD})
@Retention(RUNTIME)
@Constraint(validatedBy = {CustomSizeValidator.class})
public @interface CustomSize {
  // omit
}

import static java.lang.System.*;
import static java.lang.Math.*;