reiner Code-Block

[fieber]

hallo miteinander,

was ich nicht verstehe ist also reiner Code-Block, z.B. wie folgt:

class A {

    int i = 3;

    {
        System.out.println("tue was...");     // [*]
    }

    A( ){
        this.i = 4;
    }
}

Wozu, od. in welcher Situation braucht man einen solchen Block ohne (Methode-) Namen?

Bei der Erzeugung einer Instanz wird er ausgeführt, aber warum lässt sich nicht einfach im Konstruktor stehen?
gibt es alternativer Weg? Ist dies von OO-Konzept von Bedeutung?

bin sehr gespannt für die Antwort.

Gruß
fiebermm

 

[messi]

Wozu, od. in welcher Situation braucht man einen solchen Block ohne (Methode-) Namen?

Für die Initialisierung von Eigenschaften. Wenn z. B. der Initialisierungswert erst durch andere Operationen ermittelt wird. Analog dazu gibt es den static-Block. Außerdem werden auch Array-Initialisierungen wie solche Blöcke behandelt.

Bei der Erzeugung einer Instanz wird er ausgeführt, aber warum lässt sich nicht einfach im Konstruktor stehen?

Kann man doch machen. Aber dann müsste der Code in jedem Konstruktor stehen.

gibt es alternativer Weg?

Man könnte eine private Initialisierungsmethode verwenden oder einen Hauptkonstruktor, der von den anderen aufgerufen wird.

 

[SlaterB]

bei nur einem Konstruktor könnte es auch genausogut da rein,
aber das ist ja von den Parametern des Konstruktors unabhängig,
wenn dann viele Konstruktoren da sind wärs doof das in jedem stehen zu haben,

ähnlich und ziemlich gleichbedeutend mit etwas mehr Schreibarbeit wäre die Auslagerung in eine Operation,
die allerdings, auch wenn sie private ist, dauerhaft eine normale Operation des Objekts darstellt,
immer aufrufbar.., in der Schnittstelle mitanzugeben.., obwohl nie mehr benötigt,
dann vielleicht doch besser den Block nehmen

edit:
den leeren Konstruktor gibts ja auch noch.., aber wenn man einen Konstruktor der Super-Klasse abhängig von den Parametern aufrufen muss kommt ein solcher Umweg vielleicht nicht in Frage

class A {


    A(ParameterListe1){
        // viel Arbeit0 unabhängig von Konstruktor-Parametern
        // viel Arbeit1
    }

    A(ParameterListe2){
        // viel Arbeit0 unabhängig von Konstruktor-Parametern
        // viel Arbeit2
    }

    A(ParameterListe3){
        // viel Arbeit0 unabhängig von Konstruktor-Parametern
        // viel Arbeit3
    }
}

class A {

    {
        // viel Arbeit0 unabhängig von Konstruktor-Parametern
    }

    A(ParameterListe1){

        // viel Arbeit1
    }

    A(ParameterListe2){

        // viel Arbeit2
    }

    A(ParameterListe3){

        // viel Arbeit3
    }
}

class A {

    A(ParameterListe1){
        initObject();
        // viel Arbeit1
    }

    A(ParameterListe2){
        initObject();
        // viel Arbeit2
    }

    A(ParameterListe3){
        initObject();
        // viel Arbeit3
    }

    private void initObject() {
        // viel Arbeit0 unabhängig von Konstruktor-Parametern
    }

}

 

[fieber]

solchen Block kommt (zumind. meiner Erfahrung nach) sehr häufig bei anonymer Klassen vor, und nicht so ganz bei anderer Klassen. Ist es nicht ein bißchen komisch, da ich finde, dass eure Erklärung sehr überzeugend ist, und von daher sollte es sehr nützlich sein? Oder kann es dran liegen, dass die Code dadurch nicht verständlich sein könnte

Bei anonymer Klassen ist ja klar, da sie keinen Konstruktor besitzen dürfen.

Vielen Dank für die schnelle Antwort, hat mir sehr geholfen ^___^

LG

 

[Campino]

Man braucht den aucgh, wenn man übers JNI dlls einbindet, die System.loadLibary()-Befehle stehen meist in einem solchen Block

 

[Illuvatar]

Ich glaub hier refden alle über verschiedene Sachen ???:L

Also einmal gibt es anonyme Klassen. Die sehen so aus:

Object x = new Object([params]){
  //implement methods
};

Dann gibt es solche Blöcke in Methoden. Das ist nur dazu da, das zu strukturieren, und afaik kann man den gc besser steuern, da am ende des blockes Variablen aus dem Block schon gelöscht werden können.

public Object method()
{
  doSomething();
  {
    doSomethingElse();
  }
  return resultOfDoingSomething();
}

Das ganze funktioniert auch im Initializer:

public class Test
{
  public int j;
  public int g = 3;
  public int i;
  {
    i = 5;
    j = g *= 13;
    k++; //geht natürlich net
    System.out.println("test");
  }
  public int k = 9;
}

Und was Campino meinte, da wo man das loadLibrary normal macht, ist ein sog. "static initializer". Das ist das gleiche, nur mit static davor, und passiert demnach beim laden der Klasse und net beim Erzeugen des Objekts.

public class Bla
{
  static{
    System.loadLibrary ("xyz.dll");
  }
  private native void destroyMySystem();
}

 

[SlaterB]

naja zumindest bei den anonymen Klassen wurde doch deutlich gesagt dass da nicht die Klasse an sich gemeint ist
sondern wirklich ein Block darin als Konstruktor-Ersatz

kann natürlich sein dass das dort gar keinen Sinn macht, hab kein Beispiel zur Hand