Java-Verbesserungskapitel (11) ----- Codeblock

Während des Programmierprozesses können wir auf Programme der folgenden Form stoßen:

public class Test {
    {
        ////
    }
}

 Diese Form eines Programmsegments nennen wir einen Codeblock. Der sogenannte Codeblock verwendet geschweifte Klammern ({}), um mehrere Codezeilen zusammenzufassen und einen unabhängigen Datenkörper zu bilden um einen bestimmten Algorithmus zu implementieren. Im Allgemeinen kann ein Codeblock nicht alleine ausgeführt werden, sondern muss über einen laufenden Körper verfügen. Es gibt vier Haupttypen von Codeblöcken in Java:

1. Gewöhnliche Codeblöcke

Gewöhnliche Codeblöcke sind Das von uns am häufigsten verwendete und gebräuchlichste ist das in {} nach dem Methodennamen eingeschlossene Codesegment. Ein gewöhnlicher Codeblock kann nicht alleine existieren, er muss dem Methodennamen folgen. Es muss auch über den Methodennamen aufgerufen werden.

public class Test {
    public void test(){
        System.out.println("普通代码块");
    }
}

2. Statischer Codeblock

Wenn wir an statisch denken, denken wir an statisch. Ein statischer Codeblock ist ein in {} eingeschlossenes, mit statischen Eigenschaften modifiziertes Codesegment.

public class Test {
    static{
        System.out.println("静态代码块");
    }
}

3. Synchroner Codeblock

Verwenden Sie das synchronisierte Schlüsselwort, um das Codefragment zu ändern, und verwenden Sie „{}“, um es einzuschließen. Dies bedeutet, dass nur ein Thread gleichzeitig in den Methodenblock eintreten kann, bei dem es sich um einen Multithread handelt Schutzmechanismus.

4. Konstruieren Sie den Codeblock

Definieren Sie Code direkt ohne Modifikatoren, Präfixe und Suffixe in der Klasse Blöcke sind Blöcke aus konstruiertem Code. Wir verstehen, dass eine Klasse mindestens einen Konstruktor haben muss, der aufgerufen wird, wenn ein Objekt erstellt wird. Der Konstruktionscodeblock wird ebenso wie die Konstruktorfunktion aufgerufen, wenn ein Objekt generiert wird. Wann wird also der Konstruktionscode aufgerufen? Wie nennt man es? Schauen Sie sich den folgenden Code an:

public class Test {
    /**
     * 构造代码
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
}

Das Obige Definiert eine sehr einfache Klasse. Diese Klasse enthält einen parameterlosen Konstruktor und einen Konstruktionscodeblock. Gleichzeitig muss der Codeblock, wie oben erwähnt, über einen Träger verfügen kann es tragen, also wie wird der Compiler mit dem erstellten Codeblock umgehen? Der Compiler fügt die Codeblöcke in ihrer Reihenfolge (wenn mehrere Codeblöcke vorhanden sind) vor allen Konstruktoren ein und stellt so sicher, dass alle erstellten Codeblöcke ausgeführt werden, egal welcher Konstruktor aufgerufen wird. Der obige Code entspricht der folgenden Form:

public class Test {
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行构造代码块...");
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id  id
     */
    public Test(String id){
        System.out.println("执行构造代码块...");
        System.out.println("执行有参构造函数...");
    }

}

       运行结果

public static void main(String[] args) {
        new Test();
        System.out.println("----------------");
        new Test("1");
    }
------------
Output:
执行构造代码块...
执行无参构造函数...
----------------
执行构造代码块...
执行有参构造函数...

                                                 Es Aus den obigen Ausführungsergebnissen ist ersichtlich, dass bei einem neuen Objekt immer zuerst der Konstruktionscode und dann die Konstruktorfunktion ausgeführt wird. Zu beachten ist jedoch, dass der Konstruktionscode nicht vor dem Konstruktor ausgeführt wird wird abhängig vom Konstruktor ausgeführt. Gerade weil der konstruierte Codeblock diese Eigenschaften aufweist, wird er häufig in den folgenden Szenarien verwendet: >

  Wenn in einer Klasse mehrere Konstruktoren vorhanden sind, müssen diese Konstruktoren vorhanden sein Wenn wir Instanzvariablen direkt im Konstruktor initialisieren, kommt es definitiv zu viel doppeltem Code, der umständlich und schlecht lesbar ist. Hier können wir die konstruierten Codeblöcke voll ausnutzen, um dies zu erreichen. Dies macht sich die Tatsache zunutze, dass der Compiler jedem Konstruktor einen Block Konstruktionscode hinzufügt.  

2. Initialisieren Sie die Instanzumgebung

       一个对象必须在适当的场景下才能存在，如果没有适当的场景，则就需要在创建对象时创建此场景。我们可以利用构造代码块来创建此场景，尤其是该场景的创建过程较为复杂。构造代码会在构造函数之前执行。

       上面两个常用场景都充分利用构造代码块的特性，能够很好的解决在实例化对象时构造函数比较难解决的问题，利用构造代码不仅可以减少代码量，同时也是程序的可读性增强了。特别是当一个对象的创建过程比较复杂，需要实现一些复杂逻辑，这个时候如果在构造函数中实现逻辑，这是不推荐的，因为我们提倡构造函数要尽可能的简单易懂，所以我们可以使用构造代码封装这些逻辑实现部分。

       五、 静态代码块、构造代码块、构造函数执行顺序

       从词面上我们就可以看出他们的区别。静态代码块，静态，其作用级别为类，构造代码块、构造函数，构造，其作用级别为对象。

       1、 静态代码块，它是随着类的加载而被执行，只要类被加载了就会执行，而且只会加载一次，主要用于给类进行初始化。

       2、 构造代码块，每创建一个对象时就会执行一次，且优先于构造函数，主要用于初始化不同对象共性的初始化内容和初始化实例环境。

       3、 构造函数，每创建一个对象时就会执行一次。同时构造函数是给特定对象进行初始化，而构造代码是给所有对象进行初始化，作用区域不同。

       通过上面的分析，他们三者的执行顺序应该为：静态代码块 > 构造代码块 > 构造函数。

public class Test {
    /**
     * 静态代码块
     */
    static{
        System.out.println("执行静态代码块...");
    }
    
    /**
     * 构造代码块
     */
    {
        System.out.println("执行构造代码块...");
    }
    
    /**
     * 无参构造函数
     */
    public Test(){
        System.out.println("执行无参构造函数...");
    }
    
    /**
     * 有参构造函数
     * @param id
     */
    public Test(String id){
        System.out.println("执行有参构造函数...");
    }
    
    public static void main(String[] args) {
        System.out.println("----------------------");
        new Test();
        System.out.println("----------------------");
        new Test("1");
    }
}
-----------
Output:
执行静态代码块...
----------------------
执行构造代码块...
执行无参构造函数...
----------------------
执行构造代码块...
执行有参构造函数...

以上就是java提高篇（十一）-----代码块的内容，更多相关内容请关注PHP中文网（www.php.cn）！