Apr 17

Mehrdimensionale Arrays können einander problemlos zugewiesen werden, solange beide die gleichen Dimensionen haben.

class Angestellter
{

public static void main (String [] args)

{

int [ ] [ ]x= new int [1] [2];

int [ ][ ] y = {{1,3,5, 2,4,6}};

int [ ] z;

int [ ] a = {1,3,5} ;

int [ ] b = new int [2];

y=x;

x=z;// Compiler-Fehler; Type mismatch

}

}

Apr 15

Arrays können sehr einfach einander mit dem Gleichheitszeichen zugewiesen werden:

class Angestellter

{

public static void main (String [] args)

{

int [ ] x;

int [ ] y = {1,3,4};

char [ ] z;

x=y;

z=y; // Compilerfehler; Type mismatch

Angestellter [ ] a;

Buchhalter [ ] b;

a=b;

b=a; // Compilerfehler; Type mismatch

}

}

class Buchhalter extends Angestellter

{


}

Es ist lediglich zu beachten, dass nur Arrays gleichen Typs einander zugewiesen werden können

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 12

Was ist der Output bei folgendem Code:

class Test

public static void main (String [] args)

{

int i = 5;

for (int x =1; x<10; x++)

{

int y = 1;

}

System.out.println(y);

}

}

Antwort/ answer

Apr 11

In einem Array können nicht komplett verschiedene Objekte, aber Objekte von Sub-Klassen der im Array referenzierten Klasse sein:
class Angestellter
{

public static void main (String [] args)

{

Angestellter [ ] a = new Angestellter [3]; // Reservierung von Speicherplatz für 3 Objekte vom Typ Array

a[0]= new Angestellter();

a[1]= new Buchhalter(); // legal, da Unterklasse von Angestellter

a[2]= new Boss(); // illegal, Compiler-Fehler “Type mismatch”

}

}

class Buchhalter extends Angestellter {…}

class Boss {…}

Tagged with:
Apr 10

Welche Methoden werden können bei … eingesetzt einwandfrei compiliert werden?

class Angestellter
{

void doSomething(String args) {}

}

class Buchhalter extends Angestellter
{

}

Mögliche Funktionen:
void doSomething(int x) {}
String doSomething (String args){}
private void doSomething (String args) {}
protected void doSomething (String args) throws IndexOutOfBoundsException {}

Antwort/ answer
Apr 09

Was schon bei primitiven Werten, erfährt mit Arrays eine erhöhte Schwierigkeit.

Grundsätzlich darf in einem Array nur ein Typ vertreten sein, z.B.

int [] d = new int [4];

d[0] = 1; // legal

d [1] = 1.4; // illegal, da double-Wert

Es können aber auch andere Werte vertreten sein, z.B.

d [2] = ’1′; // Achtung! legal, aber dezimaler asci-Wert wird angezeigt, in diesem Falle 4

short e = 12;

d[3] = e; // legal, da der Wertebereich bei short  kleiner als der von int ist.

Tagged with:
Apr 07

wie immer beim SCJP gibt es auch bei Arrays einige Tücken, die man sich merken und in der Prüfung erkennen sollte:

int [ ] y = {1,x,11};
y[4] = 1;

Da ja implizit 3 Elemente für das Array definiert werden, gibt es hier einen Fehler, aber aufgepasst: es gibt keinen Compiler- sondern einen Laufzeitfehler (java.lang.ArrayIndexOutOfBoundsException)
Der gleiche Effekt tritt auf bei
y[-1]=1;

bei anonymen Arrays ist die übliche Definition:
int [ ] b = new int [ ] {1,10,11} ;
da ja die Anzahl der Werte bei anonymen Arrays nicht definiert wird, kommt es bei einer versuchten Definition zum CompilerFehler
int [3] b = new int [ ] {1,10,11} ;

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.

Apr 03

Bei primitiven Werten wird immer der Wert, nicht die Referenz an die Methode übergeben. Dies hat zur Folge, dass die Methode den eigentlichen Wert nicht ändern kann.

class Angestellter
{

void changeValue(int b)

{

b=12; // Wert wird nur für in der SSchleife gültige Variable b auf 12 gesetzt

System.out.println(b); // Ausgabe: 12

}

public static void main (String [] args)

{

Angestellter a = new Angestellter();

int b = 10;

System.out.println(b); // Ausgabe:10

a.changeValue(b); // Wert wird übergeben

System.out.println(b); // Ausgabe:10

}

}

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