Mrz 31

Als erstes mal wieder ein Beispiel:

int i = 5;
for (int x =1; x<10; x++)
{

int y = 1;

i =i+x;

}

Alle Variablen, die innerhalb der Schleife deklariert werden, sind nur innerhalb der Schleife gültig. In unserem Beispiel kann auf x und y nicht mehr zugegriffen werden. Da aber i vorher deklariert worden ist, kann auch weiter auf diese Werte zugegriffen werden.

Mrz 29

Tja… wer beim vorherigen Posting gedacht hat; “Referenzvariablen sind ja einfach”, den möchte ich ein bisschen abschrecken:

Heute geht es um die Tücken der Referenzvariable String:

class Angestellter
{

public static void main (String [] args)

{

String x=”Test1″; // Initialisierung einer Referenzvariable vom Typ String mit “Test1″

System.out.println(x); //Ausgabe: Test1

String y = x; // x und y zeigen auf das selbe String-Objekt

System.out.println(y); // y hat den selben Wert wie x;  die Ausgabe ist daher: “Test1″

y=”Test2″; // y bekommt die Zeichenfolge “Test2″ zugewiesen

System.out.println(“y ist ” + y + “  x ist ” +x); // Die Ausgabe der Werte ist nun verschieden “y ist Test2 x ist Test1″

}

}

Warum ist es so? Wir haben doch gerade erst gelernt, dass bei Referenzvariablen, die auf das selbe Objekt zeigen, auch die Ausgabe gleich ist?

Dies stimmt auch … nur zeigen nach der Änderung von y nicht mehr beide Referenzvariablen auf das selbe Objekt.

Bei Strings wird nämlich als einzigster Referenzvariable ein neues Objekt bei einer erneuten/ geänderten Zuweisung angelegt.

Mrz 27

Referenzvariablen stellen die eigentliche Referenz auf das im Speicher liegende Objekt dar. Über die Refernzvariable können die sichtbaren attribute und Funktionen eines jeden Objektes aufgerufen werden. Die Referenzvariable ist also der Bezeichner eines konkreten Objektes und verweist auch darauf. Sehr häufig kommen diese Referenzvariablen bei Objekten vor:

class Angestellter
{

int x=1;

public static void main (String [] args)

{

Angestellter a = new Angestellter();

Angestellter b = new Angestellter();

b=a; // beide Referenzen zeigen auf das selbe Objekt

System.out.println(“a.x ist ” + a.x + ” b.x ist ” +b.x);

b.x=12;

System.out.println(“\na.x ist ” + a.x + ” b.x ist ” +b.x); // Da beide Referenzvariablen auf das gleiche Objekt zeigen, ist auch die Ausgabe gleich; beiden haben nun den Wert 12

}

}

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 23

Lokale Variablen sind von der Initialisierung bis zum Programmende gültig.

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

}

}

Mrz 21

Der Einfachheit halber mal wieder ein Beispiel:

class Angestellter
{

Angestellter ()

{

int i = 10;

}

}

Variable i ist nur im Konstruktor gültig, mit erfolgreich angelegtem Konstruktor, bzw. Verlassen des Konstruktors erlischt auch die Gültigkeit der Variable.

Mrz 19

Arrays bekommen immer einen Default-Wert, egal wo und wie sie initialisiert werden.

Es ist wichtig, bei den Aufgaben im SCJP daran zu denken, dass lokal initalisierte primitive Variablen ohne Zuweisung zu einem Fehler führen, lokal initialisierte Arrays ohne Zuweisung aber default-Werte bekommen und deswegen zu keinem Fehler führen.

Mrz 17

Variablen, die auf dem Klassen-Level initialisiert werden, bekommen einen Default-Wert:

byte, short, int, long -> 0
float, double -> 0,0
boolean -> false
char -> ‘\u0000′

Nochmal ein kurzes Beispiel zur Verdeutlichung:

class Angestellter
{

static int a; // statische Variable

int b; // Instanzvariable

public static void main (String [] args)

{

int d; // lokale Variable

System.out.println (a); // Wert 0 wird ausgegeben

Angestellter c = new Angestellter ();

System.out.println (c.b); // Wert 0 wird ausgegeben

System.out.println(d); // Komiler-Fehler, da nicht vorinitialisiert

}

}

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