Quels sont les détails de l’utilisation des blocs de code Java ?

1. Introduction de base

Le bloc de code est également appelé bloc d'initialisation, qui est un membre de la classe (une partie de la classe). Il est similaire à une méthode. L'instruction logique est encapsulée dans le corps de la méthode et enveloppée dans {. };

mais avec la méthode Different, il n'y a pas de nom de méthode, pas de retour, pas de paramètres, seulement le corps de la méthode, et il n'est pas nécessaire de l'appeler explicitement via un objet ou une classe.

Syntaxe de base

(modificateur) ​​(facultatif) {code} ;

Remarque :

1 Les modificateurs sont facultatifs, vous ne pouvez écrire que des blocs de code statiques

2. types : ceux modifiés avec static sont appelés blocs de code statiques, et ceux sans modification statique sont appelés blocs de code ordinaires.

3. Dispensable

Avantages

1. Équivalent à une autre forme de constructeur, qui peut être utilisée pour l'initialisation

2 S'il y a des instructions répétées dans plusieurs constructeurs, elles peuvent être extraites d'un bloc de code.

Démarrage rapide

package com.demo.codeblock_;
public class codeblock01 {
    public static void main(String[] args) {
        movie m01=new movie("环太平洋");
        movie m02=new movie("荒野大飞",66);
        movie m03=new movie("无暇赴死",55,"老K");
    }
}
class movie{
    private String name;
    private double price;
    private String director;
    {
        System.out.println("电影屏幕打开。。。");
        System.out.println("广告开始。。。");
        System.out.println("电影开始。。。");
    }
    //三个构造器重载
    public movie(String name) {
//        System.out.println("电影屏幕打开。。。");
//        System.out.println("广告开始。。。");
//        System.out.println("电影开始。。。");
        System.out.println("构造器movie(String name)被调用。。。");
        this.name = name;
    }
    public movie(String name, double price) {
        //        System.out.println("电影屏幕打开。。。");
//        System.out.println("广告开始。。。");
//        System.out.println("电影开始。。。");
        System.out.println("构造器movie(String name， double price)被调用。。。");
        this.name = name;
        this.price = price;
    }
    public movie(String name, double price, String director) {
        //        System.out.println("电影屏幕打开。。。");
//        System.out.println("广告开始。。。");
//        System.out.println("电影开始。。。");
        System.out.println("构造器movie(String name, double price, String director)被调用。。。");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

2. Détails du bloc de code

Notes et discussion détaillée sur l'utilisation des blocs de code

1) Le bloc de code statique est également appelé bloc de code statique, sa fonction est d'initialiser la classe, et il suit la classe Executed lors du chargement, et ne sera exécuté qu'une seule fois. S'il s'agit d'un bloc de code ordinaire, il sera exécuté à chaque création d'un objet.

2) Quand la classe est-elle chargée [Important !]

①Lors de la création d'une instance d'objet (nouveau)

②Création d'une instance d'objet de sous-classe, la classe parent sera également chargée

③Lors de l'utilisation de membres statiques de la classe (propriétés statiques , méthode statique)

Démonstration de cas : la classe A étend le bloc statique de la classe B

3) Les blocs de code ordinaires seront implicitement appelés lors de la création d'une instance d'objet. Une fois créé, il sera appelé une fois. Si vous utilisez uniquement des membres statiques de la classe, le bloc de code ordinaire ne sera pas exécuté.

package com.demo.codeblock_;
public class codeblock02 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1.创建对象时new
        //AA aa=new AA();
        //2.创建子类对象实例，父类也会被加载，而且，父类先被加载，子类后被加载
        AA aa01=new AA();
        //3.使用类的静态成员时
        System.out.println(cat.n);
        DD d1=new DD();
        DD d2=new DD();
    }
}
class DD{
    static {
        System.out.println("DD的静态代码被执行1次");
    }
}
class animal{
    static {
        System.out.println("animal的静态代码被执行");
    }
}
class cat extends animal{
    public static int n=888;
    //静态代码块
    static {
        System.out.println("cat的静态代码块被执行");
    }
}
class BB {
    static {
        System.out.println("BB的静态代码被执行");
    }
}
class AA extends BB{
    static {
        System.out.println("AA的静态代码被执行");
    }
}

Séquence d'appel de classe

Lors de la création d'un objet, dans une séquence d'appel de classe : (Points clés, difficultés)

①Appel de blocs de code statiques et d'initialisation de propriétés statiques (Remarque : les blocs de code statiques et les appels d'initialisation de propriétés statiques ont la même priorité. S'il y a plusieurs blocs de code statiques et plusieurs initialisations de variables statiques, ils seront appelés dans l'ordre dans lequel ils sont définis)

② Appelez des blocs de code ordinaires et des appels d'initialisation d'attributs ordinaires (Remarque : blocs de code ordinaires et initialisations d'attributs ordinaires appels La priorité est la même.S'il y a plusieurs blocs de code ordinaires et plusieurs initialisations d'attributs extraordinaires, ils seront appelés dans l'ordre de définition)

③Appelez le constructeur.

Exemple

package com.demo.codeblock_;
public class codeblock03 {
    public static void main(String[] args) {
        A a=new A();
    }
}
class A{
    public A(){
        System.out.println("A的无参构造被调用");
    }
    int n2=getn2();
    {//普通代码块
        System.out.println("A的普通代码块被调用");
    }
    int getn2(){
        System.out.println("getn2被调用");
        return 99;
    }
    private static int n=getn();
    static {
        System.out.println("A的静态代码被调用");
    }
    public static int getn(){
        System.out.println("getn被调用");
        return 100;
    }
}

Détails du bloc de code 2

Le devant du constructeur implique en fait super( et appelle des blocs de code ordinaires. Écrivez une nouvelle classe pour démontrer les blocs de code liés statiquement et l'initialisation des attributs lorsque la classe est chargée. , l'exécution est terminée

, elle est donc exécutée avant le constructeur et le bloc de code ordinaire

class A {
public AO{
super0:
//调用普通代码块
_System.out.println("ok");
}
}

Instance

package com.demo.codeblock_;
public class codeblock04 {
    public static void main(String[] args) {
        B b=new B();
    }
}
class AA{
    {
        System.out.println("AA的普通代码块");
    }
    public AA(){
        //1.super()
        //2.调用本类的普通代码块
        System.out.println("AA的构造器被调用");
    }
}
class B extends AA{
    {
        System.out.println("B的普通代码块");
    }
    public B(){
        //1.super()
        //2.调用本类的普通代码块
        System.out.println("B的构造器被调用");
    }
}

Détails du bloc de code 2

Jetons un coup d'œil lors de la création d'un objet de sous-classe (relation d'héritage) , ils Bloc de code statique, initialisation d'attribut statique, bloc de code ordinaire, initialisation d'attribut ordinaire, l'ordre d'appel du constructeur est le suivant :

1. Le bloc de code statique et les attributs statiques de la classe parent (la priorité est la même, chaud dans l'ordre de définition

2 .Blocs de code statiques et attributs statiques de la sous-classe (même priorité, exécutés dans l'ordre de définition)

3. Blocs de code ordinaires et initialisation des attributs ordinaires de la classe parent (même priorité, exécutés) dans l'ordre de définition)

4. Classe parent La méthode de construction de la sous-classe

5. Blocs de code ordinaires des sous-classes et initialisation des attributs ordinaires (la priorité est la même, exécutée dans l'ordre de définition)

6. méthode des sous-classes

7. Les blocs de code statiques ne peuvent appeler directement que des membres statiques (propriétés statiques et méthodes statiques), les blocs de code ordinaires peuvent appeler n'importe quel membre

Instance

package com.demo.codeblock_;
public class codeblock05 {
    public static void main(String[] args) {
        //老师说明
        //(1) 进行类的加载
        //1.1 先加载 父类 A02 1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        //new B02();//对象
        new C02();
    }
}
class A02 { //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一个静态代码块..");//(2)
    }
    {
        System.out.println("A02的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }
    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }
    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02的构造器");//(7)
    }
}
class C02 {
    private int n1 = 100;
    private static  int n2 = 200;
    private void m1() {
    }
    private static void m2() {
    }
    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}
class B02 extends A02 { //
    private static int n3 = getVal03();
    static {
        System.out.println("B02的一个静态代码块..");//(4)
    }
    public int n5 = getVal04();
    {
        System.out.println("B02的第一个普通代码块..");//(9)
    }
    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }
    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");//(10)
        // TODO Auto-generated constructor stub
    }
}

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!