Okt 18

Was ist der Output des folgenden Codes?

public class Angestellter  {

{ System.out.println(“instance – Angestellter”); }
static { System.out.println(“static Angestellter”); }
Angestellter(){ System.out.println(“Konstruktor – Angestellter”); }
static public void main(String[] Args){

System.out.println(“main – Angestellter start”);
Buchhalter_Azubi ba=new Buchhalter_Azubi();
System.out.println(“main – Angestellter ende”);

}

}
class Buchhalter extends Angestellter {

{ System.out.println(“instance – Buchhalter”); }
static { System.out.println(“static Buchhalter”); }
Buchhalter(){ System.out.println(“Konstruktor – Buchhalter”); }

}
class Buchhalter_Azubi extends Buchhalter {

{ System.out.println(“instance – Buchhalter_Azubi”); }
static { System.out.println(“static Buchhalter_Azubi”); }
Buchhalter_Azubi (){ System.out.println(“Konstruktor – Buchhalter-Azubi”); }

}

Antwort/ answer
Tagged with:
Mai 10

Wie ist der Output des folgenden Codes:

class Angestellter
{

static { System.out.println(“Statischer Initialisierungsblock Angestellter”);}

{ System.out.println(“Instanz-Initialisierungsblock Angestellter”);}

Angestellter()

{

System.out.println(“Konstruktor Angestellter”);

}

public static void main (String [] args)

{

Angestellter a = new Angestellter();

}

}

class Buchhalter extends Angestellter
{

static { System.out.println(“Statischer Initialisierungsblock Buchhalter”);}

{ System.out.println(“Instanz-Initialisierungsblock Buchhalter”);}

Buchhalter ()

{

System.out.println(“Konstruktor Buchhalter”);

}

}

Antwort/ answer
Statischer Initialisierungsblock Angestellter
Instanz-Initialisierungsblock Angestellter
Konstruktor Angestellter

/spoiler]

Tagged with:
Mai 04

Wie ist der Output des folgenden Codes:

class Angestellter
{

static { System.out.println(“Statischer Initialisierungsblock Angestellter”);}

{ System.out.println(“Instanz-Initialisierungsblock Angestellter”);}

Angestellter()

{

System.out.println(“Konstruktor Angestellter”);

}

}

class Buchhalter extends Angestellter
{

static { System.out.println(“Statischer Initialisierungsblock Buchhalter”);}

{ System.out.println(“Instanz-Initialisierungsblock Buchhalter”);}

Buchhalter ()

{

System.out.println(“Konstruktor Buchhalter”);

}

public static void main (String [] args)

{

Buchhalter b = new Buchhalter();

}

}

Antwort/ answer
Tagged with:
Apr 19

Es gibt 2 Arten von Initialisierungsblöcken:
1) statische Initialisierungsblöcke
Diese werden geladen, wenn die Klasse das erste Mal geladen wurde
Egal wie häufig Instanzen creiert werden, sie werden insgesamt nur 1 Mal aufgerufen.

2)Instanz-Initialisierungsblöcke
Diese werden geladen, wenn eine Instanz-Initialisiert wird. Somit können diese mehrmals (aber pro Instanz nur 1x) aufgerufen werden.

class Angestellter
{

static {System.out.println(“Statischer Initialisierungsblock”);}

{ System.out.println(“Instanz-Initialisierungsblock”);}

Angestellter()

{

System.out.println(“Konstruktor”);

}

public static void main (String [] args)

{

Angestellter a= new Angestellter();

}

}

Die Ausgabereihenfolge ist demnach:
Statischer Initialisierungsblock
Instanz-Initialisierungsblock
Konstruktor

Apr 18

Zuerst ein Beispiel:

class Angestellter
{

{ int a=10;}

public static void main (String [] args)

{

}

}

Die Variable a ist – genauso wie beim Konstruktor – nur innerhalb ihres eigenen Blockes sichtbar/ nutzbar und kann danach nicht mehr benutzt werden.

Anders verhält es sich, wenn die Variable vorher deklariert wurde.
class Angestellter
{

int a=12;

{a=10;} //a wird der Wert 10 zugewiesen;

void getValue()

{

System.out.println(a);

}

public static void main (String [] args)

{

Angestellter a= new Angestellter();

a.getValue(); // Wert 10 wird ausgegeben

}

}

Da die Variable nicht im Initialisierungsblock sondern vorher initialisiert wurde ist diese auch außerhalb dieses Blockes gültig.

Apr 13

ja, man kann tatsächlich Arrays vom Typ Interfaces intitialisieren.
Gehen wir mal wieder anhand eines Beispieles diese Sache an:

interface Job { … }

class Angestellter implements Job
{

public static void main (String [] args)

{

Job [] jobs = new Job [3];

jobs [0] = new Angestellter();

jobs [1] = new Buchhalter ();

jobs [2] = new Boss ();

s [3] = new Arbeiter (); //Compiler-Fehler, Arbeiter hat nicht interface Job implementiert

}

}

class Buchhalter extends Angestellter implements Job { …  }

class Boss implements Job { …  }

class Arbeiter { …  }

Apr 05

üblicherweise werden Arrays auf folgende Weisen initialisiert:

a) Angestellter [ ] a = new Angestellter [5]; //Achtung! noch ist kein einzigster Angestellter intialisiert, es wurde nur Platz für 5 Angestellte geschaffen!
a [0] = new Angestellter (); //Nun ist ein Angestellter initialisiert
a [2] = new Buchhalter (); //Nun ist ein weiterer Angestellter initialisiert(wir gehen davon aus, dass Buchhalter wie bei den vorherigen Beispielen eine Unterklasse von Angestellter ist)
b) Buchhalter [ ]b;
b = new Buchhalter [5]
;
c) int a = 10;
int [ ] b = {1,a,11};
// es wird ein Array mit der Größe von 3 int-Werten angelegt.
d) int [ ] b = new int [ ] {1,10,11} ;// Arrays dieser Art werden auch anonyme Arrays genannt, da bei der Initialisierung nicht festgelegt wird, wieviele Werte das Array aufnehmen darf

Häufig wird im SCJP abgefragt, ob auf ein Array zugegriffen, bzw es erweitert werden kann. Hierfür ist es sehr wichtig, zu wissen, dass nur anonyme Arrays vergrößert werden können.  Ist die Größe einmal festgelegt, können nicht so einfach eine erhöhte Anzahl von Elementen hinzugefügt werden.

Mrz 25

Unititialisierte lokale Objekte führen ebenfalls zu einem Compiler-Fehler, im Gegensatz zu unititialisierten Instanz-Objekten:

class Angestellter
{

public String Abteilung; // Instanz-Objekt

public static void main (String [] args)

{

Angestellter a = new Angestellter ();

System.out.println(a.Abteilung); // es kann problemlos auf das Object “String” zugegriffen werden

String x; // lokales Objekt
System.out.println(x); // Compiler-Fehler

}

}

Mrz 24

lokalen Variablen wird kein Default-Wert übergeben.
Grundsätzlich führt dies zu einem Compiler-Fehler beim versuchten Zugriff (nicht bei der Deklaration), aber aufgepasst; unter bestimmten Umständen kann der Compiler nicht im Voraus erkennen, ob es zu einem Fehler kommt und gibt eine Fehlermeldung aus.

class Angestellter
{

public static void main (String [] args)

{

int a;

int b;

int c=0;

System.out.println(a); // CompilerFehler, da nicht initialisiert

if (c==0)

{

b=7;

}

a=b; // CompilerFehler, da dieser nicht erkennt, dass die Schleife in jedem Fall durchlaufen wird

}

}

Mrz 21

Hier mal wieder ein Beispiel zu Beginn:
class Angestellter
{

public String Abteilung;

public static void main (String [] args)

{

Angestellter a = new Angestellter ();

System.out.println(a.Abteilung); // es kann problemlos auf das Object “String” zugegriffen werden

}

}

Objekte werden – solange sie Instanzvariablen sind – ebenfalls mit 0 vorinitalisiert.
Dies kann aber trotzdem einige Tücken beinhalten, wenn versucht wird, auf dieses Objekt während der Laufzeit zuzugreifen. Hier gibt es zwar keinen Kompiler-Fehler, sondern einen Fehler zur Laufzeit.

Lokale Objekte werden nicht vorinitalisiert und führen zu einem Compilerfehler.

class Angestellter
{

public String Abteilung;

public static void main (String [] args)

{

Angestellter a = new Angestellter ();

System.out.println (a.Abteilung); // “Null” wird ausgegeben

String s = a.Abteilung; // ok

System.out.println(s.toUpperCase()); // Fehler zur Laufzeit, aber kein CompilerFehler

String x;

System.out.println (x); // CompilerFehler

}

}

preload preload preload
http://www.wikio.de Blog Top Liste - by TopBlogs.de Blogverzeichnis - Blog Verzeichnis bloggerei.de Bloggeramt.de Software
Webbhotell Top Blogs