Apr 30

Was ist der Output des folgenden Codes:

class Angestellter{

int d = 10;

Angestellter (int b) {

int c =10;

d =7;

}

public static void main (String [] args) {

Angestellter a = new Angestellter(5);

System.out.println(d);

}

}

Antwort/ answer
Apr 29

Für den Fall, dass ein Objekt in einen primitiven (und vielleicht nicht den gleichen) Datentyp (zurück-)gewandelt werden soll, gibt es Funktionen, die dies ermöglichen. Vorneweg erste Beispiele:

Integer a = new Integer (15);
byte b = a.byteValue();
short c = a.shortValue();
double d = a.doubleValue();

Double e = new Double (3.53);
int f = e.intValue();
// Achtung: f=3, alles hinter dem Komma wird abgeschnitten, nicht gerundet

Es kann also von jedem beliebigen Objekt aus in jeden beliebigen primitiven Datentypen umgewandelt werden

Tagged with:
Apr 27

Die meisten Wrapperklassen bieten auch die valueOf() – Funktion an, die es erlaubt, z.B. hexadezimale Werte in eine Dezimalzahl umzurechnen und zuzuweisen.

während die Zuweisung bei primitiven Datentypen noch z.B. mit int a=0X000ff; geschieht, wird bei Wrapperobjekten Integer b = Integer.valueOf(“ff”,16); benutzt. Nochmal zur Beachtung, dass bei Zuweisung von Hex-Werten zu primitiven Datentypen 0×000 vorangestellt wird.

Noch ein paar weitere Beispiele für mögliche Notationen:

Integer c = Integer.valueOf( 12 ); // 12
String d = String.valueOf( Math.PI ); // 3.141592653589793
String e = String.valueOf( 3> 5); // false
String f = String.valueOf( new Date() ); // Die Apr 10 18:40:38 CEST 2006
Integer g = Integer.valueOf(“11111111″,2); // 255

Tagged with:
Apr 25

Da es ja in der Regel (mit der Ausnahme char) immer zwei Möglichkeiten (primitiver Datentyp oder String) des Konstruktoraufrufes gibt; kann dieser als Folge dessen auch auf 2 verschiedene Weisen aufgerufen werden:

Integer a = new Integer (23); // Aufruf des Konstruktors mit int-Wert
Integer b = new Integer (“23″); // Aufruf des Konstruktors mit String-Wert

Tagged with:
Apr 23

Um mal langsam anzufangen, erst einmal die Übersicht der verschiedenen Wrapperklassen der jeweiligen Datentypen, bzw. void und der für den Konstruktor benötigten Argumente:

Primitiver Datentyp Wrapper Klasse Argumente für den Konstruktor
boolean Boolean boolean oder String
byte Byte byte oder String
char Character char
double Double double oder String
float Float float, double oder String
int Integer int oder String
long Long long oder String
short Short short oder String
void Void void

Void wird im weiteren Verlauf nicht weiter beachtet, da dies nicht Bestandteil des SCJP ist.

Tagged with:
Apr 22

Was ist der Output des folgenden Codes:

class Angestellter{

int d = 10;

void changeData() {

int d =7;

}

public static void main (String [] args) {

Angestellter a = new Angestellter();

System.out.println(a.d);

a.changeData();

System.out.println(a.d);

}

}

Antwort/ answer
Apr 21

Als erstes stellt sich – wie immer – die Frage, was Wrapper genau sind.
Wrapper (englisch; Hülle) nehmen primitive Datentypen in einem Objekt auf. Es gibt zusätzlich eine Wrapperklasse für void, der ja kein primitiver Datentyp ist.

Vorteile von Wrappern sind:

  • primitive Datentypen können in komplexen Datenstrukturen (Containern) aufgenommen werden
  • Der primitive Datentyp wird durch die Wrapper-Klasse gekapselt
  • Nutzung von Funktionen zum Zugriff auf den Wert sowie Umwandlungsfunktionen
Tagged with:
Apr 20

Was ist der Output von folgendem Code:

class Angestellter{

int d = 10;

Angestellter (int b){

int c =10;

d = 7;

}

public static void main (String [] args){

Angestellter a = new Angestellter();

System.out.println(a.d);

}

}

Antwort/ answer
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.

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