Was sind die Details zur Verwendung von Java-Codeblöcken?

1. Grundlegende Einführung

Der Codeblock ist ein Mitglied der Klasse (Teil der Klasse). Die logische Anweisung ist im Methodenkörper gekapselt und mit { versehen. };

aber bei der Methode Different gibt es keinen Methodennamen, keine Rückgabe, keine Parameter, nur den Methodenkörper, und es besteht keine Notwendigkeit, ihn explizit über ein Objekt oder eine Klasse aufzurufen.

Grundlegende Syntax

(optional) {Code};Hinweis:

1. Modifikatoren sind optional, Sie können nur statische schreiben

2. Codeblöcke können in zwei unterteilt werden Typen: Mit Static modifizierte Typen werden als statische Codeblöcke bezeichnet, und solche ohne statische Modifikation werden als gewöhnliche Codeblöcke bezeichnet.

3. Entbehrliche

Vorteile

1. Entspricht einer anderen Form von Konstruktoren, die zur Initialisierung verwendet werden können

2. Wenn es wiederholte Anweisungen in mehreren Konstruktoren gibt, können diese als Codeblock extrahiert werden.

Schnellstart

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. Details zum Codeblock

Hinweise und ausführliche Diskussion zur Verwendung von Codeblöcken

1) Statischer Codeblock wird auch als statischer Codeblock bezeichnet. Seine Funktion besteht darin, die Klasse zu initialisieren Es folgt der beim Laden ausgeführten Klasse und wird nur einmal ausgeführt. Wenn es sich um einen gewöhnlichen Codeblock handelt, wird er jedes Mal ausgeführt, wenn ein Objekt erstellt wird.

2) Wann wird die Klasse geladen? [Wichtig!] , statische Methode)

Falldemonstration: Klasse A erweitert den statischen Block der Klasse B

3) Gewöhnliche Codeblöcke werden beim Erstellen einer Objektinstanz implizit aufgerufen. Nach der Erstellung wird es einmal aufgerufen. Wenn Sie nur statische Mitglieder der Klasse verwenden, wird der normale Codeblock nicht ausgeführt.

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的静态代码被执行");
    }
}

Klassenaufrufsequenz

Beim Erstellen eines Objekts in einer Klassenaufrufsequenz: (Wichtige Punkte, Schwierigkeiten)

①Aufruf statischer Codeblöcke und statischer Eigenschaftsinitialisierung (Hinweis: Statische Codeblöcke und statische Eigenschaftsinitialisierungsaufrufe haben die gleiche Priorität. Wenn mehrere statische Codeblöcke und mehrere statische Variableninitialisierungen vorhanden sind, werden sie in der Reihenfolge aufgerufen, in der sie definiert sind Aufrufe Die Priorität ist dieselbe. Wenn mehrere gewöhnliche Codeblöcke und mehrere außergewöhnliche Attributinitialisierungen vorhanden sind, werden diese in der Reihenfolge ihrer Definition aufgerufen.

③Rufen Sie den Konstruktor auf.

Beispiel

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

Details zu Codeblock 2

Die Vorderseite des Konstruktors impliziert tatsächlich super( und ruft gewöhnliche Codeblöcke auf. Schreiben Sie eine neue Klasse, um statisch verwandte Codeblöcke und die Attributinitialisierung beim Laden der Klasse zu demonstrieren. , die Ausführung ist abgeschlossen

, also wird sie vor dem Konstruktor und dem gewöhnlichen Codeblock ausgeführt

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

Instanz

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的构造器被调用");
    }
}

Codeblockdetails 2

Werfen wir einen Blick darauf, wann ein Unterklassenobjekt erstellt wird (Vererbungsbeziehung) , sie Statischer Codeblock, statische Attributinitialisierung, gewöhnlicher Codeblock, gewöhnliche Attributinitialisierung, die Aufrufreihenfolge des Konstruktors ist wie folgt:

1 Der statische Codeblock und die statischen Attribute der übergeordneten Klasse (die Priorität ist gleich, hot in der Reihenfolge der Definition

2 .Statische Codeblöcke und statische Attribute der Unterklasse (gleiche Priorität, ausgeführt in der Reihenfolge der Definition)

3. Gewöhnliche Codeblöcke und gewöhnliche Attributinitialisierung der übergeordneten Klasse (gleiche Priorität, ausgeführt). in der Reihenfolge der Definition)

4. Die Konstruktionsmethode der Unterklasse

5. Gewöhnliche Codeblöcke von Unterklassen und gewöhnliche Attributinitialisierung (die Priorität ist gleich, sie werden in der Reihenfolge der Definition ausgeführt)

6 Methode von Unterklassen

7. Statische Codeblöcke können nur statische Mitglieder direkt aufrufen (statische Eigenschaften und statische Methoden), gewöhnliche Codeblöcke können jedes Mitglied

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
    }
}

aufrufen.

Das obige ist der detaillierte Inhalt vonWas sind die Details zur Verwendung von Java-Codeblöcken?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!