Cependant, ici, je crée une instance juste pour représenter `ne peut pas être remplacé 'et j'appelle à partir de cette instance, mais en premier lieu, la méthode statique est

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

Et, il est souhaitable de faire référence à partir de la classe elle-même sans passer par l'instance.

En fait, si vous transférez simplement le code ci-dessus vers IntelliJ

Noté comme une méthode statiquenon référencée par laclasse elle-même.

(Un merci spécial à @kawamnv)

public static void main(String [] args) En effet, lorsque la méthode main est appelée, l'instance n'existe pas encore en mémoire, donc la méthode main doit être exécutée même si la classe qui la contient n'est pas instanciée.

classe statique (classe interne statique)

Il existe trois types de classes, classes internes, classes membres, classes locales et classes anonymes. La classe membre statique est l'une des classes membres et l'emplacement de la déclaration est dans le bloc de classe (la même position que le champ et la méthode). Cependant, à proprement parler, la classe membre statique est difficile à appeler une classe interne, et il est plus correct de la décrire comme une classe complètement différente.

Si vous appelez la classe qui entoure la classe interne la classe externe, Il a une relation relativement faible avec la classe externe et ses instances, et peut accéder aux membres statiques de la classe externe.

Comme d'autres choses statiques, il est utilisé avec ```external class name.member class name` ``.

Outer.java

class Outer { //Classe externe

  //Classe de membre ➀ classe statique
  static class StaticInner {
    private Integer in;

    public Integer getIn() {
      return in;
    }

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

  //Classe de membre ➁ Classe de membre stricte
  class Inner {
    private String str;

    public String getStr() {
      return str;
    }

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

Les appels dans les classes et les méthodes principales non pertinentes sont:

Execute.java

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

    //Classe de membre stricte
    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();
  }
}

Comme je l'ai inclus dans l'exemple ci-dessus, une classe membre stricte a des liens étroits avec les instances individuelles créées par la classe externe, donc new ne peut pas être fait sans une instance de la classe externe. Comme ce n'est pas une chose statique, les membres non statiques sont également autorisés à accéder.

initialiseur statique

static {
  //En traitement
}

Un initialiseur statique est un bloc qui n'est exécuté qu'une seule fois lorsqu'une classe est chargée (le fichier .class est chargé). Décrivez le processus que vous souhaitez appeler et exécuter avant d'instancier une classe ou avant la méthode main. Bien sûr, vous ne pouvez décrire que des choses statiques.

Y a-t-il une utilité pour cela? J'ai pensé,

public final static String VALUE;

static {
  VALUE = makeValue();
} 

/**
 *Générer dynamiquement des valeurs sous certaines conditions
 * @valeur de retour valeur générée
 */
private static String makeValue() {
  // omit
}

L'autre jour, j'ai pu essayer ce genre d'utilisation par accident. Je pense que c'était juste parce que le but était de "créer une nouvelle valeur une seule fois au début, avant l'instanciation" et de la réutiliser.

Constructeur et initialiseur statique

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();
  }
}

Le résultat est Toilet </ font>. Vous pouvez voir que l'initialiseur statique est appelé plus tôt que le constructeur qui est finalement appelé par new (instanciation).

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.*;