Okt 30

Wir haben jetzt gelernt, dass die Compilierung bei Vermischung von (non-)generic Collections funktioniert, auch bei eigentlich nicht-erlaubten Datentypen.

Die nächste Frage ist jetzt: Läuft es denn auch einwandfrei?

Die Antwort ist ja.

Java hat sich um die alte Funktionalität beibehalten zu können, was tolles ausgedacht: Jegliche generischen Möglichkeiten werden bei Compilierung überprüft. Falls der Compiler irgendwelche Probleme sieht, gibt er eine Warnung raus. Zur Laufzeit wird eine generic collection wie eine non-generic collection behandelt; die JVM sieht keinen Unterschied.

Um die Sache auf den Punkt zu bringen: Alles, was in diesem Zusammenhang (mit Warnung)  compiliert werden kann wird auch laufen.

Tagged with:
Okt 27

Das das Vermischen von (nicht-)generischen Collections kein Problem darstellt, solange es um den gleichen Objekt-Typ handelt, haben wir ja schon erläutert.

Wie sieht es denn aus, wenn beim Vermischen verschiedene Objekt-Typen “im Spiel” sind?

Nehmen wir uns unser letztes Beispiel nochmal vor und ändern die Methode

void hinzufügen (List a){

a.add(5);

}

ab auf

void hinzufügen (List a){

a.add(“5″);

}

Es wird also statt dem beim generic collection erlaubten Integer-Objekt ein String hinzugefügt. Nach allem, was wir bisher gelernt haben, dürfte dies doch nicht klappen, oder?

In diesem Falle macht der Compiler eine Ausnahme; die Compilierung und der Durchlauf des Codes funktionieren Einwandfrei, es wird lediglich eine Warnung ausgegeben.

Warum ist das so? Da Generics erst mit java5 gekommen sind, muss der in den Vorversionen geschriebene Code integriert werden; also wurde die Vermischung möglich gemacht und mit einer Warnung versehen, damit der Programmierer selbst entscheiden kann, ob und wie er seinen Code abändern will.

Tagged with:
Okt 24

Fangen wir mal relativ einfach an; dass die Vermischung von generischen und nicht-generischen collections kein Problem ist, solange die Datentypen gleich sind, ist relativ logisch; hier noch ein Beispiel:

class Angestellter{

public static void main (String … args){

List <Integer> a= new ArrayList <Integer>();


a.add(1);

a.add(2);

a.add(3);


Einfügen e = new Einfügen();

e.hinzufügen(a);

for (int x= 0; x

System.out.print(a.get(x)+” “);

}

}

class Einfügen {

void hinzufügen (List a){

a.add(5);

}

}

Obwohl die Methode hinzufügen nicht wissen kann, dass sie auf einer generischen collection arbeitet, fügt sie problemlos den Wert hinzu. Es wird nur eine Warnung herausgegeben, da sich (non-)generics vermischen.
Soweit logisch, da es sich um den Typ der generischen List handelt.

Tagged with:
Okt 21

um die Verwirrung etwas größer werden zu lassen, wollen wir uns heute mal ein besonderes Exemplar von Generics anschauen:

List <Object> a = new ArrayList <Object> ();

Diese List ist fast gleich

List a = new ArrayList();

Bei beiden kann man beliebige Objekte hinzufügen, aber Achtung; wir haben trotzdem eine generische und eine nicht-generische collection.

Mehr dazu später, für den Moment ist es einfach nur wichtig, in jedem Falle (non-)generics auseinanderhalten zu können

Tagged with:
Okt 19

Zu erst sollten wir klären, was (non-) generic überhaupt bedeutet. Ich nehme mal als Beispiel ArrayList.
Vor Java5 konnte man ArrayList nur folgendermaßen deklarieren:

ArrayList a = new ArrayList(); bzw die polymorphonische Variante:

List a = new ArrayList();

In diese List kann einfach alles eingetragen werden, was ein Objekt ist; also z.B. String, Integer, Instanzen, Date usw.
Eine Vergleichbarkeit ist relativ schwierig, oft sogar unmöglich. Wenn z.B. ein String-Rückgabewert zwingend erforderlich war, musste dieser z.B. mit

String b = (String) a.get(0);

gecasted werden und da ein cast auch seine Grenzen hat, kann dies immer noch zur Laufzeit fehlschlagen.

Um sicherzustellen, dass wie in unserem Beispiel nur ein bestimmter Objekt-Typ in eine Collection rein und auch nur dieser Objekt-Typ wieder ausgegeben werden darf, wurden die Generics eingeführt:

ArrayList <String> a = new ArrayList <String>(); bzw die polymorphonische Variante:

List <String> a = new ArrayList<String>();

Als Resultat dessen, ergibt

a.add(new Date());

bei generics einen Compiler-Fehler, bei non-generics nicht.

Tagged with:
Okt 18

Wie ist der Output des folgenden Codes?

public class Angestellter  {

Angestellter(int … PersNr){ System.out.println(“Angestellter angelegt”); }

static public void main(String[] Args){

Angestellter a = new Angestellter();

}

}

Antwort/ answer
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:
Okt 16

Wie wir ja schon besprochen haben, kann der PriorityQueue auch andere “Prioritäten” anstatt der natürlichen Ordnung mitgeteilt werden.

Hierfür wird (genau wie bei den anderen Collections) Comparable oder Comaparator genutzt:

class ObjSort implements Comparator <Integer>{

public int compare(Integer a,Integer b)

return (b.compareTo(a));

}

Dies wird dann bei der Implementation der PriorityQueue vermerkt:

PriorityQueue <Integer> a = new PriorityQueue <Integer>(100, new ObjSort());

Wenn wir folgende Werte zuweisen

a.offer(3);
a.offer(7);
a.offer(1);
a.offer(5);
a.offer(9);

ist die Ausgabe von :
int b=a.size();

for (int i =0; i<b; i++)
System.out.println(a.peek() +” ” +a.size());
// Ausgabe des obersten Elements ohne Löschung

9 5
9 5
9 5
9 5
9 5

und die Ausgabe von
for (int i =0; i<b; i++)
System.out.println(a.poll() +” ” +a.size());
// Ausgabe und Löschung des obersten Elements
9 4
7 3
5 2
3 1
1 0


Tagged with:
Okt 13

Auch zu PriorityQueue habe ich schon einige Anwendungsbeispiele genannt:

a.offer(“Hello”); // Hinzufügen eines Elementes unter Beachtung der natürlichen Ordnung
a.remove(); // Löschung des obersten Elementes
a.size(); // Ausgabe der Queue-Größe

Auch dies ist für das SCJP noch nicht genug; also hier weitere Informationen anhand eines Beispiels:

PriorityQueue <Integer> a = new PriorityQueue <Integer>();

a.add(3);
a.add(7);
a.add(1);
a.add(5);
a.add(9);
// Hinzufügen von Elementen wie bei offer()

int b=a.size(); // Zuweisung einer Hilfsvariablen für Size, da diese bei poll() verringert

for (int i =0; i<b; i++)
System.out.println(a.peek() +” ” +a.size());
// Ausgabe des obersten Elements ohne Löschung:

1 5
1 5
1 5
1 5
1 5

for (int i =0; i<b; i++)
System.out.println(a.poll() +” ” +a.size());
// Ausgabe und Löschung des obersten Elements:

1 4
3 3
5 2
7 1
9 0

Tagged with:
Okt 10

Heute wollen wir uns mal anschauen, was passiert, wenn ein anderer als der “Überprüfungswert” einer Instanz (und damit auch die Instanz selbst) geändert wird:
class Angestellter{

Angestellter(int PersNr, String Abteilung) {

this.PersNr=PersNr;

this.Abteilung=Abteilung;

}

public int PersNr;

public String Abteilung;

public static void main(String[] args) {

Map <Angestellter, Integer> x = new HashMap <Angestellter, Integer>();


Angestellter a = new Angestellter (1, “Abteilung A”);

Angestellter b = new Angestellter (2, “Abteilung B”);

Angestellter c = new Angestellter (3, “Abteilung C”);


x.put(a,a. PersNr);

x.put(b, b.PersNr);

x.put(c, c.PersNr);


a.Abteilung=”neu”;


System.out.println(x.get(a));

System.out.println(x.get(b));

System.out.println(x.get(c));

}

public int hashCode(){

return PersNr*10;

}

public boolean equals(Angestellter c){

if (c.PersNr==this.PersNr){

return true;

}

else{

return false;

}

}

}

Hier ist das Ergebnis von System.out.println(x.get(a)); immer noch 1, da hashCode() und equals(Obj) einen anderen Wert zur Überprüfung/ Rückgabe implementiert haben.

Das einzigste, was uns also wirklich kümmert, ist der Vergleichswert. Ändert sich dieser, wird der Rückgabewert (abhängig von der Implementation von hashCode und equals) zu null. Ändern sich andere Variablen im Nachhinein, kümmert das den Compiler nicht.

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