Output korrekt trotz falschem Lösungsweg !?

Um ehrlich zu sein, die englischsprachige Doku fiel mir am Anfang auch schwer, allzumal ich in Sprachen - auch Englisch - noch nie ernsthaft stark war. Ganz im Gegenteil.

Heute würde ich aber sagen, daß es trotzdem viel mit Gewöhnung zu tun hat. Du wirst es dir übrigens weitaus leichter machen, wenn du selber auf Englisch programmierst. Also keine class Fahrzeug{}, sondern eine class Vehicle deklarierst. Es wird aber nach und nach einfacher.
 
White_Fox hat gesagt.:
Um ehrlich zu sein, die englischsprachige Doku fiel mir am Anfang auch schwer, allzumal ich in Sprachen - auch Englisch - noch nie ernsthaft stark war. Ganz im Gegenteil.

Heute würde ich aber sagen, daß es trotzdem viel mit Gewöhnung zu tun hat. Du wirst es dir übrigens weitaus leichter machen, wenn du selber auf Englisch programmierst. Also keine class Fahrzeug{}, sondern eine class Vehicle deklarierst. Es wird aber nach und nach einfacher.
Zum Vergrößern anklicken....
Danke dir !!
Das mit dem englischen habe ich mir eh angewöhnt. Wenn ich die Übungen aus dem Buch abtippe, nutze ich die Zeit und änder die Var auch auf Englisch ab. Schleicht sich schonmal ein Fehler ein, was gut ist, denn dann kann man direkt Fehler suchen und beheben xD
 
Könnt ihr mal auf den Code schauen, bzw. meine Kommentare?
Es handelt sich um eine Codeschnipsel Übung.
Ich muss gestehen, ich musste mir die Lösung anschauen (60% spicken / 40% Eigenleistung)

Danach wollte ich den Code analysieren und schauen ob ich es einigermaßen verständlich und vorallem richtig erklären kann bzw. verstanden habe.

Bitte keine Verbesserungsvorschläge für den Code ansich. Dieser ist Teil des Buches und wird wenn nötig/möglich im weiteren verlauf noch verbessert. 🙂
Danke Euch

[CODE lang="java" highlight="34,44"]import java.util.*;


public class ArrayListMagnet {
public static void main(String[] args) {
ArrayList<String> a = new ArrayList<String>(); // Erstelle eine neue Instanz der Klasse ArrayList

// Füge der ArrayList 4 Objekte hinzu
a.add(0, "null");
a.add(1, "eins");
a.add(2, "zwei");
a.add(3, "drei");

printAL(a);

// Wenn ArrayList "a" das Objekt "drei" beinhaltet, füge der Liste ein neues Objekt "vier" hinzu
if (a.contains("drei")) {
a.add("vier");
}
// Entferne das Objekt aus Index 2 --> Objekt "drei" und "vier" rücken nach, also Index 2 = "drei , Index 3 = "vier"
a.remove(2);
printAL(a);

// Wenn das Objekt "vier" auf einem anderem Index als 4 liegt, erstelle Index 4 mit dem Objekt "4.2"
if (a.indexOf("vier") != 4) {
a.add(4, "4.2");
}
printAL(a);

// Wenn die ArrayList das Objekt "zwei" enthält, füge "2.2" --> Ist das nicht sinnfrei? wir haben Objekt zwei oben gelöscht?
if (a.contains("zwei")) {
a.add("2.2");
}
printAL(a);
}

public static void printAL(ArrayList<String> al) {

/* Ich denke, "printAL" ist eine Methode, die Objekte des Types ArrayList erwartet und
wir übergeben ihr die ArrayList "a"
*/

// Nehme den Inhalt der ArrayList und gebe ihn in der Konsole aus (so ganz check ich ncoh nicht was hier abläuft)
for (String element : al) {
System.out.print(element + " ");
}
System.out.println(" ");

}

}

[/CODE]

Richtige Verständnisprobleme habe ich bei Zeile 34 und 44.
Was genau passiert in der Methode printAL
 
Mhhhh, ein klassischer Fall von Trunkenheit beim Programmieren, würde ich sagen. Es sind auch zu viele, nicht aussagekräftige Kommentare vorhanden. /* Entferne das Objekt aus Index 2 */ a.remove(2); genau das steht in der nachfolgenden Codezeile.

Aber um deine Frage zu behandeln:
Zeile 34 ist ein Methodenaufruf, wobei die ArrayList a als Argument übergeben wird.
Zeile 44 ist eine for-each-Schleife in der Methode printAL, die alle Elemente der ArrayList ausgibt.
 
Hildi0 hat gesagt.:
Mhhhh, ein klassischer Fall von Trunkenheit beim Programmieren, würde ich sagen. Es sind auch zu viele, nicht aussagekräftige Kommentare vorhanden. /* Entferne das Objekt aus Index 2 */ a.remove(2); genau das steht in der nachfolgenden Codezeile.

Aber um deine Frage zu behandeln:
Zeile 34 ist ein Methodenaufruf, wobei die ArrayList a als Argument übergeben wird.
Zeile 44 ist eine for-each-Schleife in der Methode printAL, die alle Elemente der ArrayList ausgibt.
Zum Vergrößern anklicken....
Ein klassischer Fall von "aus dem Zusammenhang gerissen würde ich sagen" 🙂 Hier in dem Post geht es schon länger darum, das ich komplett von Null angefangen habe Java zu lernen. Ich nutze die Kommentarfunktion um den Leuten hier irgendwie zu zeigen, wie ich das verstehe und meistens schauen die sich das an und erklären mir das oder sagen passt so 🙂

Trotzdem Danke ;-)
 
Hildi0 hat gesagt.:
Mhhhh, ein klassischer Fall von Trunkenheit beim Programmieren, würde ich sagen. Es sind auch zu viele, nicht aussagekräftige Kommentare vorhanden. /* Entferne das Objekt aus Index 2 */ a.remove(2); genau das steht in der nachfolgenden Codezeile.
Zum Vergrößern anklicken....
Früher zu Zeiten von Assembler und ähnlichem war es üblich, rechts vom Befehl zu kommentieren - jede Zeile, egal wie einfach sie war

@Kotelettklopfer. Schreib die Beschreibung von Methoden nicht in den Body, sondern in den Javadoc-Bereich von Methoden. Eventuell nenne auch mögliche Exceptions, so in etwa:
Java: 
    /**
     * Gibt alle Element von <code>al</code> in einer Zeile nach <code>System.out</code> aus mit abschließendem Zeilenumbruch.
     * @param al Liste der Texte. Eine <code>NullpointerException</code> wird geworfen, falls <code>al == null</code>
     */
    public static void printAL(ArrayList<String> al) {
        for (String element : al) {
            System.out.print(element + " ");
        }
        System.out.println(" ");
    }
    /**
     * Beispiel einer Methode mit explizit angegebener Exception
     @ throws IOException falls was daneben geht.
     */
    private void doSomething throws IOException {
      
    }
So siehst du die Beschreibung der Methode dann in der IDE schon dort, wo du sie eintippst, auch wenn sie sich in einer anderen Klasse befindet.


Kleine Denksportaufgabe. Überleg dir mal etwas, wie man die Anzahl der print und println Zugriffe reduzieren könnte, jeder einzelne braucht nämlich doch eine gewisse Zeit (für diese Aufgabe nicht relevant, eher für die Zukunft).
 
Zuletzt bearbeitet:
White_Fox hat gesagt.:
@Nemi: Den Code hat er aus dem Buch...das ist nicht seiner.

Zum Thema kann ich mich leider gerade nicht äußern...erstmal arbeiten. Ich komme später wieder. 😉
Zum Vergrößern anklicken....
Genau, vielleicht habe ich mich falsch ausgedrückt.
Ich wollte anstatt alles in einen Forum Kommentar zu packen meine Anmerkungen direkt in den Code packen.

Ich wollte nur Feedback ob stimmt was ich da kommentiert habe...
Habe im Selbststudium keinen Dozenten den ich anhauen kann deswegen und der mich korrigieren könnte 🙂
 
Java: 
// Nehme den Inhalt der ArrayList und gebe ihn in der Konsole aus (so ganz check ich ncoh nicht was hier abläuft)
for (String element : al) {
Das nennt man auch erweiterte for-Schleife oder for-each-Schleife.

Für das obenstehende könnte man sinngemäß schreiben: for each element in al do.. Es werden damit alle Elemente von "al" durchlaufen. Das gerade aktuelle Element steht in "element".

Die erweiterte for-Schleife sollte man einsetzen, wenn man den Wert der Indexvariablen nicht benötigt, dann führt sie zu lesbareren Code.
 
Die for-each-Schleife holt dir jedes einzelne Element aus einem Array oder einer Collection (also z.B. ArrayList, HashSet, HashMap,...).

Die meisten Zugriffe auf solche Sammelelemente sind Iterationen, d.h. du gehst alle Elemente einmal durch. Mit der for-each-Schleife mußt du die Zugriffe und Indexzählerei nicht mehr selber formulieren, das übernimmt die for-each-Schleife für dich.
 
So, ich hab mir deinen Quellcodefetzen eben nochmal in Ruhe angesehen.

Zeile 34: Ja, das ist ein Methodenaufruf, und zwar die Methoe printAl(). Diese Methoe iteriert über das ArrayList und schreibt alle Strings, die sich in al befinden, auf der Konsole in eine Zeile. Zur Ausgabe wird System.out.print/println verwendet. Die Methode print() schreibt einfach an der aktuellen Cursorposition weiter, println() (Kurzform von print line) beendet die aktuelle Zeile.

Zeile 44: Die bereits diskutierte for-each-Schleife. Wofür die da ist, weißt du ja jetzt und der Rest sollte dir keine größeren Schwierigkeiten bereiten: Die Schleife iteriert über das ArrayList und nimmt dabei jeden String einmal raus. Der String wird auf der Konsole ausgegeben, gefolgt von einem Leerzeichen. Ist die Schleife fertig, wurden alle Elemente in ArrayList ausgegeben, wird die Zeile mit einem println() beendet.
 
Ok, gestern war ich nicht mehr fähig das zu verstehen. Jetzt gerade hat sich der Knoten gelöst und ich habe verstanden wieso der Output so aussieht wie er aussieht.

Wieder etwas gelernt 🙂


Danke !!
 
Ich habe jetzt noch etwas an der ArrayList rumgespielt um das Wissen zu vertiefen.
Als Idee wollte ich zusätzlich zu den Namen die Indexnummer ausgegeben haben.

Der Output passt, frage mich nur ob es innerhalb der ArrayList keine Methode gibt um den Index auszulesen?

Java: 
public static void printNames(ArrayList<String> al) {

        int index = 0;

        for (String element : al
        ) {
            System.out.println("ID: " + index + " " + element);
            index++;
        }
    }

}

Ich habe jetzt eine Variable Index erstellt, diese mit 0 deklariert und dann nach jedem Durchlauf inkrementiert. Wäre das sauber?
 
Kotelettklopfer hat gesagt.:
Der Output passt, frage mich nur ob es innerhalb der ArrayList keine Methode gibt um den Index auszulesen?
Zum Vergrößern anklicken....
Es gibt i. A. nur die Möglichkeit, über die Methode indexOf() (auch lastIndexOf()) nach einem Objekt zu suchen, dann erhält man den Index des ersten gefundenen Objekts (es kann in einer Liste Duplikate geben) zurück. Aber das ist natürlich nicht effizient.

Kotelettklopfer hat gesagt.:
Ich habe jetzt eine Variable Index erstellt, diese mit 0 deklariert und dann nach jedem Durchlauf inkrementiert. Wäre das sauber?
Zum Vergrößern anklicken....
Ja.
 
So wie du's gemacht hast, ist es grundsätzlich nicht falsch. Das ergibt z.B. Sinn, wenn du was anderes als eine Liste hast und einen Zähler mitlaufen lassen willst. Wie @temi aber gesagt hat: Da dich der Index interessiert, ist es sinnvoller, gleich damit zu arbeiten.
Dann in der Schleife einmal das Objekt auslesen und dann damit arbeiten.
 
Ok das muss ich mir nachher mal in der IDE anschauen.
Kann mir gerade im Kopf nicht ausmalen, wie es aussehen muss wenn ich die Objekte nicht kenne die in der Liste stehen (Benutzereingabe zb.).

Bitte nicht spoilern, höchstens kleine Tips xD
 
Ich habe jetzt versucht es mit einer normalen for Schleife zu lösen und bekomme auch den Index ausgegeben.
Wie bekomme ich jetzt die Variable i (das ist der Index) in die Methode printNames um folgenden Output zu erhalten

0 Theo
1 Uschi
2 Bernd
3 Rüdiger

Ist dies überhaupt der von euch gemeinte Weg über eine normale for Schleife?

Java: 
import java.util.*;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> name = new ArrayList<String>();

        name.add("Theo");
        name.add("Uschi");
        name.add("Bernd");
        name.add("Rüdiger");

        printNames(name);

        int totalIndex = name.size();
        for (int i = 0; i < totalIndex; i++) {
            int index = i;
            System.out.println(i);

        }
    }


    public static void printNames(ArrayList<String> al) {


        for (String element : al) {
            System.out.println(element);


        }

    }


}

Versuche ich die for Schleife mit in die for each zu packen, findet er das Objekt name nicht.
Bin gerade etwas lost xD

Kleiner Hinweis vielleicht ? 🙂
 
Naja...du mußt einen String zusammenbauen, der das enthält was du ausgeben willst. Was willst du darin haben? Den Index, ein Leerzeichen und den String aus deiner ArrayList.

Und damit dann System.out.println füttern...
 
White_Fox hat gesagt.:
Naja...du mußt einen String zusammenbauen, der das enthält was du ausgeben willst. Was willst du darin haben? Den Index, ein Leerzeichen und den String aus deiner ArrayList.

Und damit dann System.out.println füttern...
Zum Vergrößern anklicken....
Das mit dem String weiß ich ja, aber dafür muss ich den index aus der Main ja erstmal unten in die Methode printNames bringen und das geht nicht. Irgendwas übersehe ich hier noch.
 
Java: 
        for (String element : al) {
            System.out.println(element);
        }
Das ist die for each Schleife. Und diese Schleife sollst Du zu einer normalen for Schleife umbauen:
Java: 
        for (int index=0; index < al.length(); index++) {
            String element = al[index];
            System.out.println(element);
        }

Und schon hast Du in der Schleife den Index und das Element.
 
kneitzel hat gesagt.:
Java: 
        for (String element : al) {
            System.out.println(element);
        }
Das ist die for each Schleife. Und diese Schleife sollst Du zu einer normalen for Schleife umbauen:
Java: 
        for (int index=0; index < al.length(); index++) {
            String element = al[index];
            System.out.println(element);
        }

Und schon hast Du in der Schleife den Index und das Element.
Zum Vergrößern anklicken....

So nimmt er das nicht. In der ArrayList gibt es kein .length. Da würde ich al.size nehmen wollen !?
Er hat außerdem ein Problem bei al[index];
Da wirft er "Array type expected; found: 'java.util.ArrayList<java.lang.String>"
 
Ja, da habe ich es mit dem Array gemischt weil ich nicht gut genug geschaut habe. ... size und dann statt [index] natürlich ein .get(index).
 
Java: 
public static void printNames(ArrayList<String> al) {


        for (int index=0; index < al.size(); index++) {
            String element = al.get(index);
            System.out.println("ID: " + index + " " + "Name: " + element);
        }
    }

Code mal angepasst.

Da ich, zum Ärger meiner Vorgesetzten und Kollegen alles hinterfrage bis ich es verstanden habe, auch hier die nervige Frage.
Wieso sollte man das mit for und nicht mit for each abbilden?

Liefert doch beides das gleiche Ergebnis !?
Ist einfach so oder gibt es einen "technischen" Hintergrund der mir als Laie noch verborgen bleibt?
 
Kotelettklopfer hat gesagt.:
Wieso sollte man das mit for und nicht mit for each abbilden?
Zum Vergrößern anklicken....
Es ist einfach schöner, dass man die Schleife mit dem Index verwendet, wenn man den Index innerhalb der Schleife verwendet. Das ist irgendwie "aufgeräumter", weil alles was zur Schleife gehört (Start, Ende, Inkrement) an einer Stelle ist.

Zudem kann es sein, dass der separat hochgezählte Index nicht unbedingt mit der Reihenfolge der for-each-Schleife übereinstimmen muss (Konsistenz Index - Daten). In deinem Fall ist das nicht so, aber es könnte sich ja um eine andere (vielleicht selbst implementierte) Liste handeln, wo das nicht mehr stimmt. In diesen Fällen wird durch die normale for-Schleife immer der Index angezeigt, der auch den Daten von get(index) entspricht.

Edit: Zusätzlich sollte man den Gültigkeitsbereich von Variablen so klein wie möglich halten (= Variablen so spät wie möglich deklarieren), bei der normalen for-Schleife ist die Schleifenvariable nur innerhalb der Schleife gültig. Es gibt natürlich auch Gründe, eine Variable, die man innerhalb der Schleife verändern möchte, vor der Schleife zu deklarieren. Eben damit man auch nach der Schleife noch auf den Inhalt zugreifen kann.
 
Zuletzt bearbeitet:
Ach noch was, um dich komplett zu verwirren 🙂

So etwas würde auch funktionieren:
Java: 
int index = 0;   
for (; index < al.size(); index++) {
    String element = al.get(index);
    System.out.println("ID: " + index + " " + "Name: " + element);
}

// oder z. B. auch

int index = 0;   
for (; index < al.size(); ) { // das entspricht dann while(index < al.size())
    String element = al.get(index);
    System.out.println("ID: " + index + " " + "Name: " + element);
    index++;
}
Prima, um etwas Verwirrung zu stiften 🙂 Dann ist die Variable "index" natürlich auch nach der Schleife noch gültig, was man allerdings meist nicht möchte.
 
Zuletzt bearbeitet:
Kotelettklopfer hat gesagt.:
Wieso sollte man das mit for und nicht mit for each abbilden?
Zum Vergrößern anklicken....
Mit der for-Schleife hast du den Index ja bereits, bei der for-each-Schleife mußt du den Index erst holen. Du hast da eigentlich keine Gewalt darüber, welcher Index dir geliefert wird.

Probiere doch mal folgendes: Implementiere beide Methoden nacheinander, vielleicht noch mit einer kurzen Meldung dazwischen damit du weißt, wann die Ausgabe welcher Methode anfängt.
Und dann stopf doch mal den gleichen String mehrmals in deine ArrayList und schau was passiert. Mich würde das gerade auch interessieren.
 
Kotelettklopfer hat gesagt.:
Java: 
public static void printNames(ArrayList<String> al) {


        for (int index=0; index < al.size(); index++) {
            String element = al.get(index);
            System.out.println("ID: " + index + " " + "Name: " + element);
        }
    }

Code mal angepasst.

Da ich, zum Ärger meiner Vorgesetzten und Kollegen alles hinterfrage bis ich es verstanden habe, auch hier die nervige Frage.
Wieso sollte man das mit for und nicht mit for each abbilden?

Liefert doch beides das gleiche Ergebnis !?
Ist einfach so oder gibt es einen "technischen" Hintergrund der mir als Laie noch verborgen bleibt?
Zum Vergrößern anklicken....
Also erst einmal liefert es nicht das gleiche Ergebnis.

Bei deinem Beispiel ganz deutlich: Bei der for each Schleife hattest Du innerhab der Schleife eben nicht den Index. Das war ja der Grund, dass Du es umgeschrieben hast!

Und dann hast Du zwei unterschiedliche Schleifen, die Du vergleichst:
- Einmal die typische Zählschleife. Du zählst eine Variable von einem Startwert hoch bis zu einer bestimmten Grenze.
- Das andere ist eine Schleife, die einen Iterator abarbeitet. (Oder alternativ ein Array) Bei einem Iterable ist ein Zugriff über einen Index auch nicht zwingend möglich.

Es gibt hier also grundlegende Unterschiede zwischen den beiden Schleifen. (Wobei unter dem Strich jede Schleife in eine andere umgewandelt werden kann. Aber dann hätte man in der normalen for Schleife keine Zählvariable.)

Somit haben wir hier aber klare und deutliche Unterschiede.

Generell ist aber auch wichtig: Es gibt oft mehrere Wege, die zum Ziel führen und es ist schwer, Vor- und Nachteile genau zu bewerten.

Edit: Ein wichtiger Punkt ist dann auch noch, dass beim Iterator nicht zwingend eine feste Reihenfolge vorgegeben wurde. Bei einer List, in einem Array, ... da haben Elemente eine klare Position / Reihenfolge. Das ist bei anderen Collections aber nicht zwingend gegeben.
 
White_Fox hat gesagt.:
Stimmt...das hab ich ganz vergessen. Manche Collections (z.B. HashMap oder HashSet) haben sowas wie einen Index gar nicht, da kannst du nur mit for-each oder dem Iterator direkt alle Elemente abarbeiten.
Zum Vergrößern anklicken....
Das wäre dann aber die Antwort auf die Frage "Warum soll (muss) ich das mit for-each und nicht mit for abbilden?" 😉
 
kneitzel hat gesagt.:
Also erst einmal liefert es nicht das gleiche Ergebnis.
Zum Vergrößern anklicken....
Das finde ich jetzt verwirrend, denn das Ergebnis, welches am Ende auf der Konsole steht ist ja schon identisch. Oder was meinst du damit?

Edit: Ich glaub ich habe gerade, beim nochmaligen Lesen, verstanden, was du meintest. Die Betonung liegt auf "erst mal" und meint die blanke for-each Schleife ohne parallelen Index. Ja, ist korrekt, aber echt verwirrend. 😉
 
temi hat gesagt.:
Das wäre dann aber die Antwort auf die Frage "Warum soll (muss) ich das mit for-each und nicht mit for abbilden?" 😉
Zum Vergrößern anklicken....
Ja und nein ... die klassische for Schleife mit index als Zähler geht nicht. Aber generell lassen sich alle Schleifen beliebig ineinander umwandeln:

Ein
for(T elem : iterable) { ... } (mit Iterable<T> iterable)
ist dann nichts anderes als:
for(Iterator<T> iter = iterable.iterator; iter.hasNext(); ) { T elem = iterator.next(); .... }

Jede Schleife lässt sich in eine andere umwandeln. Es gibt also nichts, das Du als for, for each oder while abbilden kannst, das Du nicht auch mit den anderen Schleifen darstellen kannst.

temi hat gesagt.:
Edit: Ich glaub ich habe gerade, beim nochmaligen Lesen, verstanden, was du meintest. Die Betonung liegt auf "erst mal" und meint die blanke for-each Schleife ohne parallelen Index.
Zum Vergrößern anklicken....
Ja genau - Aber dabei aber auch wirklich eine limitierung der for Schleife auf die Zähl-Schleife! Also explizit keine for Schleife wie hier als Ersatz für die for each Schleife gezeigt.
 
Ok... Das ist wieder Input overload ... Aber ich habe ja gefragt.

Ich halte fest, dass ich mit der for each schon nicht gaaanz falsch lag und hatte auch erstmal das richtige Ergebnis.
Das stimmt mich schonmal stolz xD
Der Rest bleibt irgendwo im Hirn kleben und wird bei Bedarf bestimmt mal wieder hervor kommen.
Das war ja nur ein kleiner Exkurs, jetzt geht es zurück ins Buch .

Danke Euch
 
Bis jetzt dachte ich "Ok, klingt kompliziert, aber werde ich irgendwann packen".
Jetzt Kapitel Interface und Polymorphie... Mein Kopf wünscht sich das Yps Heft zurück xD

Ist das heftig....
 
Kotelettklopfer hat gesagt.:
Bis jetzt dachte ich "Ok, klingt kompliziert, aber werde ich irgendwann packen".
Jetzt Kapitel Interface und Polymorphie... Mein Kopf wünscht sich das Yps Heft zurück xD

Ist das heftig....
Zum Vergrößern anklicken....
Du wirst das packen...da, wo du jetzt stehst, standen die meisten irgendwann mal.
Bleib dran, dann wird dir das bald lächerlich einfach vorkommen.

Wie gesagt, es ist nicht so wichtig, alles gleich auf Anhieb zu verstehen. Und natürlich, wenn es einfach wäre könnte es ja jeder, und niemand müßte den Kram jahrelang studieren.
Wenn du nicht gleich verstehst wozu ein Interface nützlich ist - in dem Buch, das du da gerade durcharbeitest, wird das auch eher am Rande erklärt. Im Buch über Entwurfsmuster derselben Reihe wird da nochmal richtig drauf eingegangen (und ich habe, obwohl ich damals durchaus passabel und in mehreren Sprachen programmieren konnte, erst bei Entwurfsmustern verstanden was Softwareentwickler eigentlich so richtig machen).

Edit:
Ich habe damals Java in der Vorlesung "Softwaretechnik" gelernt (E-Techniker, keine Informatiker!). Mein Prof, ein sehr fähiger Dozent der hervoragend Wissen vermitteln konnte, hat das gesamte Semester damit verbracht uns zu erkären, was der Unterschied zwischen einem Objekt und einer Klasse ist. Zwar nicht wozu das nützlich ist, dazu war keine Zeit mehr, sondern tatsächlich nur Objekt vs. Klasse.

Die Leute in meinem Jahrgang waren definitiv nicht die allerdümmsten, jedenfalls nicht alle, trotzdem hat das echt gedauert das zu verstehen. Ja, es ist wirklich lächerlich einfach wenn man es verstanden hat, keine Frage. Trotzdem muß der Weg bis dahin erstmal gegangen werden.

Wie schon mehrmals gesagt - du steckst da in einem ganz normalen Lernprozess mit den ganz normalen Schwierigkeiten, die jeder andere auch hat. Und es ist völlig normal, daß das dauert. Nicht den Kopf hängen lassen, dranbleiben...es lohnt sich, vor allem wenn du Beratung in dem Bereich machst, man sollte den Kram kennen.
 
Zuletzt bearbeitet:
White_Fox hat gesagt.:
Du wirst das packen...da, wo du jetzt stehst, standen die meisten irgendwann mal.
Bleib dran, dann wird dir das bald lächerlich einfach vorkommen.

Wie gesagt, es ist nicht so wichtig, alles gleich auf Anhieb zu verstehen. Und natürlich, wenn es einfach wäre könnte es ja jeder, und niemand müßte den Kram jahrelang studieren.
Wenn du nicht gleich verstehst wozu ein Interface nützlich ist - in dem Buch, das du da gerade durcharbeitest, wird das auch eher am Rande erklärt. Im Buch über Entwurfsmuster derselben Reihe wird da nochmal richtig drauf eingegangen (und ich habe, obwohl ich damals durchaus passabel und in mehreren Sprachen programmieren konnte, erst bei Entwurfsmustern verstanden was Softwareentwickler eigentlich so richtig machen).
Zum Vergrößern anklicken....
Das Entwurfsmuster habe ich danach auch noch vor mir 🙂

Ich habe jetzt mal aus dem Kopf versucht mit einem Interface zu arbeiten. Scheint funktioniert zu haben.
Ich habe zwei Klassen die jeweils auf die Methoden im Interface zugreifen und diese jeweils für sich "nutzen" bzw. überschreiben.
Also man sieht mal wieder.. Machen ist dann meist doch verständlicher als nur lesen ... aber das Thema hatten wir ja nun auch schon des öfteren.
 
Siehste...sagen wir dir ja. 😉

Und auch das Interface ist so ein Ding, wo du die englische Sprache ruhig wörtlich nehmen kannst. Es ist genau das, was die Bezeichnung ausdrückt, und wird exakt dazu verwendet.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

RMI Klasse wird unter falschem Pfad gesucht
Antworten: 4
JMenu erscheint nach RDP-Verbindung auf falschem Desktop
Antworten: 1
Rewrite mit falschem Ordner
Antworten: 6
TabbedPane mit falschem Inhalt.
Antworten: 2
Output Stream / Protokoll does not support output
Antworten: 2

Zurück
Oben