Java Anfängerfragen Java-Einstieg

[It'sNever2Late!]

Referenztyp Referenzvariable = new Objekttyp();

abstract class Fahrzeug
class Auto extends Fahrzeug
class Moped extends Fahrzeug

Der Objekttyp kann nie Fahrzeug sein, sondern nur Auto/Moped, da Fahrzeug eine abstrakte Klasse ist
Der Referenztyp kann Fahrzeug/Auto/Moped sein.

Fahrzeug moped = new Moped();
// und
Moped moped2 = new Moped();

Beide Beispiele sind korrekt, da die Objekttypen und Referenztypen gültig sind.

Denn - wenn da steht moped(Referenzvariable) instanceof Moped(Objekttyp), dann wird nicht der Typ von moped selbst (der Referenzvariable) getestet, sondern der Typ der Instanz(Objekttyp), auf die moped(Referenzvariable) verweist.

Ist das so korrekt?

Also bei deinem Beispiel:

Fahrzeug moped = new Moped();
if (moped instanceof Moped)
  ((Moped) moped).staenderAusklappen();

Es wird geprüft ob der Objekttyp(new Moped(); ) der Referenzvariable moped....AUSSETZER WTF
Auf was soll der Objekttyp zeigen? ...

 

[Tumbleweed]

Es wird geprüft, ob der Typ des Objekts, auf das die Referenzvariable moped referenziert, mit dem Typ Moped übereinstimmt. Der Typ Moped ist ja einfach erst einmal nur ein selbst definierter Typ, das ist noch kein Objekt, sondern nur eine Klasse, die du geschrieben hast, d.h. ein Typ, den das Programm kennt.

Und dann um noch einmal pingelig zu sein:

wenn da steht moped(Referenzvariable) instanceof Moped(Objekttyp)

Da steht die Referenzvariable moped, ja, allerdings dient dieses Wörtchen moped dabei nur als Verweis auf das, was dieser Referenzvariable zugewiesen wurde. Welchen Typ die Referenzvariable selbst hat, ist hier egal.
Und mit Moped ist hier nur der Typ gemeint, den du als Klasse definiert hast. Das ist kein Objekt.

Sonst war das schon alles korrekt, was du geschrieben hast.

 

[It'sNever2Late!]

Es wird geprüft, ob der Typ des Objekts, auf das die Referenzvariable moped referenziert, mit dem Typ Moped übereinstimmt.

Aber der Objekttyp ist doch immer == New Moped();.
In diesem Fall referenziert die Referenzvarialbe auf den Objekttypen new Moped();

Entweder verstehe ich die IF-Abfrage nicht oder die Zuweisung/Referenz/Deklaration sitzt immer noch nicht. (ich meine aber letzteres verstanden zu haben)

???

 

[Tumbleweed]

In diesem Fall referenziert die Referenzvariable auf ein Objekt mit dem Typ Moped, das ist korrekt. Und daher ergibt der Ausdruck in der if-Bedingung auch true, denn ein Objekt des Typs Moped ist ja eine "instanceof" Moped (und das sogar sehr offensichtlich, was nicht immer so sein muss).

Nun kann es aber durchaus vorkommen, dass die Referenzvariable nicht mehr auf ein Moped zeigt. Das geht deshalb, weil deine Referenzvariable moped (ungünstiger Name an der Stelle. fahrzeug wäre besser) ja vom Typ Fahrzeug ist.
Beispiel:

Fahrzeug fahrzeug = null;

if (sonneScheint)
   fahrzeug = new Moped();
else
   fahrzeug = new Auto();

// Irgendwo später im Programm
if (anhalten && fahrzeug instanceof Moped)
   ((Moped) fahrzeug).staenderAusklappen();

Spoiler

Dass das hier eleganter ohne check lösbar wäre, sei einfach mal dahingestellt, solange der TE noch verwirrt ist.

 

[It'sNever2Late!]

Dann nochmal die If-Bedingung in meinen Worten:

Wenn die Referenzvariable moped auf den Objekttypen new Moped(); referenziert ALSO zeigt dann ist die if-bedingung true.

dann haben wir

fahrzeug moped = new Moped

Und weil die Referenzvariable vom Referenztyp fahrzeug ist kann sie keine Methoden der Klasse Moped aufrufen, deswegen machen wir folgendes:

((Moped) fahrzeug).staenderAusklappen();

das (Moped) ändert kurzzeitig den Objekttypen, also die eigentliche Referenz der variable um das Aufrufen der Methode zu ermöglichen.

Spoiler

ICH HABS KAPIERT

 

[Tumbleweed]

Super, du hast es!

Man könnte den check mit instanceof übrigens auch weglassen und einfach stur casten. Damit riskiert man aber eine Exception zur Laufzeit, weil eben genau das passieren kann, was ich gerade beschrieben habe und sich das fahrzeug dummerweise geändert hat (und ein Auto beim besten Willen keinen Ständer zum Ausklappen bietet ).

Schön, dass du so beharrlich bist. Behalte dir das bei.

P.S.: Eine pingelige Kleinigkeit noch:

Wenn die Referenzvariable moped auf den Objekttypen new Moped(); referenziert

besser: "wenn die Referenzvariable moped auf ein Objekt des Typs Moped referenziert..."

Ergänzung (10. Mai 2012)

Na dann teste dich mal, ob du hier durchblickst! Geht vor allem ums Überschreiben und eben darum, was wohl auf der Konsole ausgegeben wird, je nachdem ob die Sonne scheint oder nicht.

Spoiler

public class Fuhrpark {

    private static Fahrzeug fahrzeug;
    
    public static void main(String[] args) throws InterruptedException {
        
        fahrzeug = null;
        boolean sonneScheint = false;
        boolean unterwegs = true;
        
        while (unterwegs)
        {
            if (fahrzeug == null)
            {
                if (sonneScheint)
                    fahrzeug = new Moped();
                else
                    fahrzeug = new Auto();
                
                fahrzeug.losfahren();
                
                TimerTask anhalteTask = new TimerTask() {
                    public void run() {
                        Fuhrpark.fahrzeug.anhalten();
                    }
                };
                new Timer().schedule(anhalteTask, 5000);
            }
            if (!Fuhrpark.fahrzeug.angehalten)
                System.out.println("Und wir fahren weiter");
            else break;
            
            Thread.sleep(1000);
        }
        
        System.exit(0);
    }
}

public abstract class Fahrzeug {

    public int speed;
    public boolean angehalten;
    
    public void anhalten()
    {
        speed = 0;
        angehalten = true;
        hupen();
    }
    
    public abstract void hupen();

    public void losfahren() {
        System.out.println("brumm brumm");
        speed = 100;
    }
}

public class Moped extends Fahrzeug {

    public void hupen() {
        System.out.println("Möp Möp!");
    }

    public void anhalten() {
        super.anhalten();
        staenderAusklappen();
    }
    
    public void staenderAusklappen()
    {
        System.out.println("quietsch, ratsch, plop. Ständer ausgeklappt!");
    }
}

public class Auto extends Fahrzeug {

    public void hupen() {
        System.out.println("Tröööööt");
    }

    public void anhalten() {
        super.anhalten();
        handbremseAnziehen();
    }
    
    public void handbremseAnziehen() {
        System.out.println("Ratsch! Handbremse festgezogen");
    }
}

 

[It'sNever2Late!]

Das ist dann doch nochmal ein gutes Stück schwerer.

Du hättest ja auch klein Anfangen können und dann langsam steigern, z.b. erst nur die Klasse Fuhrpark und dann später Fahrzeug mit abgeleiteten Klassen und ausgelagerten/überschriebenen Methoden, aber nun gut.

Die Sonne scheint nicht, das tut sie im Mai sowieso nie.
Deswegen referenziert die variable fahrzeug vom Referenztyp Fahrzeug auf ein Objekt vom Typ Auto.

In der Klasse Fahrzeug gibt es ne abstrakte Methode hupen und die nicht-abstrakten methoden(wie war der Begriff dafür nochmal) losfahren und anhalten.
Die Methode hupen wird in der Klasse Auto überschrieben (@Override fehlt!, ich arbeite unter uBuntu mit Java6)
Und die Methode anhalten wird in der Klasse Auto auch überschrieben, obwohl die Methode anhalten in der Superklasse(ich hoffe, dass Fahrzeug ne Superklasse ist) nicht abstrakt ist. (ich weiß, dass man sowohl normale als auch abstrakte Methoden überschreiben kann, während man bei normalen die freie wahl hat muss man abstrakte methoden immer überschreiben(ich würde mich nochmal über ein Beispiel zu nem Interface freuen, soweit ich weiß ist das ne abstrakte Klasse + nur abstrakte Methoden)).

da die variable unterwegs immer true ist hättest du auch while(true) schreiben können, da du die schleife ja mittels break verlässt. (PHP too easy)

Kurze Anmerkung, ich musste die Klassen .Timer; und .TimerTask; noch importieren und da die Variable ein Objekt vom Typ Auto referenziert kann ich in meiner Beschreibung/nacherzählung dieses Programms(wie nennt man die teile eig. ich mein Programme sind das ja nciht im direkten Sinne) die Klasse Moped ignorieren.

Am Anfang der Schleife wird geprüft ob die variable fahrzeug == null ist, also noch kein Objekt referenziert.
Komisch, dass du die If-Abfrage innerhalb der While schleife hast, das kostet unnötig ressourcen (schließlich brauchst du sie ja auch nur einmal)

Danach wird losgefahren und speed (ist es ratsamer innerhalb einer methode einer Superklasse this.speed anstatt speed zu schreiben (und sag nich das is egal, ich hätte gerne einen überzeugenen Grund (sofern es einen gibt))) wird auf 100 (km/h) gesetzt.

dann kommt das schwere und neue für mich:

eine neue Referenzvariable vom Referenztyp TimerTask(also der Klasse TimerTask) mir Referenz auf ein Objekt vom Typ TimerTask wird deklariert und dann geschweifte Klammer auf??

Wenn eine Methode innerhalb der Main-Funktion(ich habe sicher etwas falsch verstanden, bzw gibts hier ne ausnahemregel) innerhalb einer Variable deklariert wird, wird sie dann automatisch ausgeführt? (denn die Methode .run wird ja nirgends aufgerufen)

Ansonsten ruft die Methode run die Methode anhalten der Klasse Auto auf. Was noch unklar ist, ist folgendes:
das alles wird am Anfang nur einmal innerhalb der if-Abfrage fahrzeug==null ausgeführt.
Aber das Auto wird erst später angehalten. ICH glaube ja, dass das mit dem Timer.schuedule,anhaltetask 5000 zusammenhängt, der es der Methode run erst nach 5000ms also 5sekunden erlaubt ausgeführt zu werden. (komisch ist dann die reihenfolge)

Also Zeilen 23-27 sind nicht soo klar.

Das ALLES passiert allerdings nur EINMAL beim deklarieren einer Variable.

Die restliche Zeit der while-Schleife wird geprüft ob das Fahrzeug nicht angehalten hat ansosnten wird die schleife beendet.

Sollte die schleife noch nicht beendet worden sein kommt ne Pause von einer Sekunde.

 

[Tumbleweed]

Bin beeindruckt. Hast du doch gut gemeistert.

Ich versuche mal deine Fragen aufzusammeln:
- Override annotations fehlen hier, das stimmt. Das liegt daran, dass ich das manuell sowieso nie gesetzt habe (macht Eclipse automatisch, wenn man mit ctrl+space arbeitet) und ich unter Xubuntu mit Eclipse und OpenJDK7 arbeite und da offensichtlich diese annotation rausgeflogen ist. Ist mir auch gestern erst aufgefallen.
- dass ich unterwegs nicht sinnvoll benutze, hast du richtig bemerkt. War erst geplant, aber bei quick & dirty hacks kommt das schon einmal vor.
- ich würde das schon Programm nennen, denke ich. Einzelne teile dann eben Programmteile.
- imports habe ich weggelassen, ja. Spart platz und übernimmt sowieso eine gute IDE (ctrl+shift+o in Eclipse). Generell hätte man das auch problemlos ohne Timer und TimerTask lösen können, aber ich benutze das ganz gerne und fand es hier auch ganz gut nachvollziehbar.
- this. ist in den meisten fällen optional und eine Frage des Stils. Ich benutze es nur in Konstruktoren und Methoden, wo die Parameter gleich benannt sind wie die Klassenattribute. Wenn du nicht weißt, wie ich das meine, kann ich das auch noch einmal ausführen. Ansonsten finde ich, sollte man sich this sparen. Generell bin ich Freund von kompaktem Code.
- hehe, das mit den geschweiften Klammern nach dem TimerTask, hatte ich gar nicht absichtlich als Schwierigkeit eingebaut, sondern aus Gewohnheit. Das ist eine anonyme Implementierung. Wird dir noch öfter unterkommen. Ich überschreibe da quasi "inline" die run()-Methode des TimerTask.
Danach siehst du, wie ich eine Instanz der Klasse Timer instantiiere und das ohne eine Referenz darauf zu behalten. Würde ich damit nichts weiter machen, würde diese Instanz direkt wieder verloren gehen. Ich benutze aber direkt eine Methode dieser Instanz, denn für mehr brauche ich sie nicht. Danach kann sie wieder verschwinden.

Lustigerweise hast du hier zufällig direkt Bekanntschaft mit einem Interface gemacht. Nämlich bei TimerTask. TimerTask "implements" das Interface Runnable. Bei Interfaces ist die Besonderheit, dass du keinen "method body" ("Methodenkörper/-rumpf" vermutlich) als Standardimplementierung mitgeben kannst. Bei einer abstract class schon (wie hier in dem Beispiel auch). Daher zwingt dich dieses Interface bei Verwendung von TimerTask, dass du die run() implementierst. Runnables können dann zum Beispiel von separaten Threads oder eben so einem Timer (auch parallel) ausgeführt werden.

 

[It'sNever2Late!]

- Override annotations fehlen hier, das stimmt. Das liegt daran, dass ich das manuell sowieso nie gesetzt habe (macht Eclipse automatisch, wenn man mit ctrl+space arbeitet) und ich unter Xubuntu mit Eclipse und OpenJDK7 arbeite und da offensichtlich diese annotation rausgeflogen ist. Ist mir auch gestern erst aufgefallen.
- dass ich unterwegs nicht sinnvoll benutze, hast du richtig bemerkt. War erst geplant, aber bei quick & dirty hacks kommt das schon einmal vor.
- ich würde das schon Programm nennen, denke ich. Einzelne teile dann eben Programmteile.

Kapiert.

- imports habe ich weggelassen, ja. Spart platz und übernimmt sowieso eine gute IDE (ctrl+shift+o in Eclipse). Generell hätte man das auch problemlos ohne Timer und TimerTask lösen können, aber ich benutze das ganz gerne und fand es hier auch ganz gut nachvollziehbar.

Ich nutze JOE, Java Oriented Editing unter Windows @ Home und hier auf der Arbeit Geany. Beide IDEs erleichtern einem die Arbeit nicht und das ist auch beabsichtigt. Außerdem kostet JOE keine 2MB währen NetBeans/Eclipse xxxMB verbraucht. Joe Startet instant.

- this. ist in den meisten fällen optional und eine Frage des Stils. Ich benutze es nur in Konstruktoren, wo die Parameter gleich benannt sind wie die Klassenattribute. Wenn du nicht weißt, wie ich das meine, kann ich das auch noch einmal ausführen. Ansonsten finde ich, sollte man sich this sparen. Generell bin ich Freund von kompaktem Code.

Was ist wichtiger, Kompakter Code oder gut lesbarer Code. ich weiß, dass du das auf die Schnelle getippt hast und ja ich habe Bereits hier mit nem Konstruktor gearbeitet und mit this. (nagut ich hatte es einfach von woanders geklaut)
Denn mir ist es wichtig genau zu wissen welche Variable ich ändere und ob die Änderung auch übernommen wird.
In PHP und Java haben (soweit ich es korrekt Verstanden habe) Funktionen und Methoden einen Unterschied
Rufe ich eine Funktion in PHP aus sind alle Variablen innerhalb der Funktion(bis auf den Return-Wert) automatisch private, während (ich hoffe ich habs richtig verstanden/interpretiert) eine Methode in Java immer Werte eines bestimmten Objekts ändert. Und eben da ist es wichtig (mMn) mit this. zu arbeiten um zu wissen ob ich jetzt irgend ne temp-Variable bearbeite oder direkt ne Variable der Klasse. (hier auch noch ne Frage, wenn ich eine Variable mit referenz auf ein objekt vom typ auto deklariere und dann bekommt auto innerhalb des Konstuktors der Klasse Auto geschwindigkeit und baujahr zu gewiesen, wie nennt man dann geschwindigkeit und baujahr, heißen die Eigenschaften? in PHP ist das etwas anders/einfacher) (einfahc key => value))

- hehe, das mit den geschweiften Klammern nach dem TimerTask, hatte ich gar nicht absichtlich als Schwierigkeit eingebaut, sondern aus Gewohnheit. Das ist eine anonyme Implementierung. Wird dir noch öfter unterkommen. Ich überschreibe da quasi "inline" die run()-Methode des TimerTask.

Muss ich das heute noch verstehen?
Anstatt die Methode oben reinzuschreiben (also außerhalbt der Main-Methode) kommt sie einfach da rein?
Das ist ja unleserlich^2

Danach siehst du, wie ich eine Instanz der Klasse Timer instantiiere und das ohne eine Referenz darauf zu behalten. Würde ich damit nichts weiter machen, würde diese Instanz direkt wieder verloren gehen. Ich benutze aber direkt eine Methode dieser Instanz, denn für mehr brauche ich sie nicht. Danach kann sie wieder verschwinden.

Echt fies von dir mir als Anfänger sowas vorzugeben.
Besser wäre es mir diese Methode, diesen Zeilen erst auf meinem Niveau zu zeigen(also anfänger) und dann die verkürzte.


Und ab implements habe ich nicht wirklich viel verstanden.

Soweit ich weiß implementiert (also zwingt ) ne abstrakte Methode der Superklasse alle abgeleiteten Klassen dazu diese Methode zu erstellen/deklarieren/iniziieren.
Deinen letzen Absatz hab ich nicht ganz verstanden.

 

[Tumbleweed]

Ich habe bisher nur ein einziges mal in "real world code" die konsequente Verwendung von this gesehen. Das war in der BoneCP api. Wenn dir das gefällt und du es durchziehst, kannst du das gerne tun. Wundere dich aber nicht, wenn du das bei "snippets" (also Code-Ausschnitten) im Netz nicht finden wirst.

Wenn du die run() nicht auf diese Weise implementieren willst, weil es dir zu unsauber ist, dann geht das zum Beispiel auch noch so:

Spoiler

import java.util.Timer;
import java.util.TimerTask;


public class Fuhrpark {

    static Fahrzeug fahrzeug;
    
    public static void main(String[] args) throws InterruptedException {
        
        fahrzeug = null;
        boolean sonneScheint = false;
        boolean unterwegs = true;
        
        while (unterwegs)
        {
            if (fahrzeug == null)
            {
                if (sonneScheint)
                    fahrzeug = new Moped();
                else
                    fahrzeug = new Auto();
                
                fahrzeug.losfahren();
                
                new Timer().schedule(new AnhalteTask(), 5000);
            }
            if (!Fuhrpark.fahrzeug.angehalten)
                System.out.println("Und wir fahren weiter");
            else break;
            
            Thread.sleep(1000);
        }
        
        System.exit(0);
    }
}

class AnhalteTask extends TimerTask {
    public void run() {
        Fuhrpark.fahrzeug.anhalten();
    }
}

Und das mit dem new Timer(), hast du doch verstanden oder? Sonst wäre es eine Zeile mehr gewesen.

Timer timer = new Timer();
timer.schedule(...);

Es gibt übrigens da keinen Königsweg zwischen weglassen und Code aufblasen. Das ist reine Geschmackssache und da streiten sich Programmierer schon Ewigkeiten drüber. Für dich ist es ausführlich hingeschrieben vielleicht verständlicher. Für andere ist jedes überflüssige Zeichen im Code zu viel, weil es vom Inhalt ablenkt, wenn es keinen Nutzen hat. Die Tendenz bei moderneren Sprachen geht zu kompaktem Code. Da fliegt so viel raus wie möglich.

Zu deiner Frage der "scopes" (so nennt man die "Sichtbarkeitsräume" von Variablen): Es ist einfach so - was du innerhalb eines Blocks (also innerhalb von { } ) definierst, ist auch nur darin verfügbar, nicht außerhalb. Mit private hat das innerhalb von Methoden nichts zu tun. Das information hiding (also private, protected, public und package) ist nur interessant für Klassenattribute und Methoden, die von außerhalb einer Klasse (und folglich den Instanzen der Klasse) ansprechbar sind. In meiner Klasse Fahrzeug, wären das

    public int speed;
    public boolean angehalten;

Wenn ich aber zum Beispiel innerhalb von losfahren() etwas deklariere, wie zum Beispiel einen Countdown, bevor das Losfahren beginnt, dann bleibt das auch innerhalb dieses scopes.

Ich glaube, dass mit dem Interface hast du schon fast richtig mitbekommen. Verwendet eine Klasse ein Interface (implements), dann muss entweder diese Klasse direkt eine Implementierung für die im Interface definierten Methoden liefern oder aber (wie z.B. TimerTask), man "reicht die zu implementierenden Methoden weiter durch". Sieh dir mal hier den source code der Klasse TimerTask an. Da siehst du "implements Runnable" (das ist ein Interface, welches die Implementierung einer run()-Methode vorschreibt). Allerdings liefert TimerTask keine Implementierung sondern

        /**
        * The action to be performed by this timer task.
        */
        public abstract void run();

und deswegen liegt es dann am Programmierer, der TimerTask verwenden will, eine Implementierung zu erstellen.

 

[It'sNever2Late!]

Wenn du die run() nicht auf diese Weise implementieren willst, weil es dir zu unsauber ist, dann geht das zum Beispiel auch noch so: spoiler, fkt-änderung etc..

besser!
Nur wird in Zeile 26 dann automatisch die Methode run() aufgerufen? (zumindest sieht das so aus, da die Methode run. nirgends mit .run() aufgerufen wird)

Zu deiner Frage der "scopes" (so nennt man die "Sichtbarkeitsräume" von Variablen): Es ist einfach so - was du innerhalb eines Blocks (also innerhalb von { } ) definierst, ist auch nur darin verfügbar, nicht außerhalb.

Aha und dennoch ändert mann dann die scopes einer Referenzvariable z.b. innerhalb eines Konstruktors oder (wie in deinem Beispiel) innerhalb der Methode anhalten. (speed = 0)
das erschließst sich mir dann doch nicht so ganz. Mal kann man sie ändern, mal nicht. ?

Wenn ich aber zum Beispiel innerhalb von losfahren etwas deklariere, wie zum Beispiel einen Countdown, bevor das losfahren beginnt, dann bleibt das auch innerhalb dieses scopes.

Das ist klar, wenn ich innerhalb einer Methode eine temp Variable deklariere weiß das Haupt programm nix davon. (wie in PHP)

Das information hiding (also private, protected, public und package) ist nur interessant für Klassenattribute und Methoden, die von außerhalb einer Klasse (und folglich den Instanzen der Klasse) ansprechbar sind. In meiner Klasse Fahrzeug, wären das (speed & angehalten)

Das bedeutet, dass es einen Fehler geben würde, wenn die beiden Variablen als protected oder private oder package deklariert wurden, weil die Klasse Auto eben nicht auf diese Variablen zugreifen könnte. Interessant

 

[Tumbleweed]

Die run() wird innerhalb der Timer-Klasse aufgerufen (oder zum Beispiel auch innerhalb der Thread-Klasse). Das siehst du also nicht. Würde man die run selbst aufrufen (das geht), dann würde die Ausführung sequentiell, also im gleichen (aktuellen) Thread stattfinden und genau das will man in der Regel vermeiden. Sowohl die Klassen Timer als auch Thread erwarten also eine Instanz einer Klasse, die Runnable implementiert, das ist alles.

Man ändert den scope dieser Attribute nicht, wenn man innerhalb einer Methode auf so ein Attribut zugreift, denn sind sie als Klassenattribut definiert (auch Felder genannt), dann sind sie sozusagen im "class scope", d.h. alles innerhalb dieser Klasse, kann sie benutzen, auch wenn sie private sind. Die Methoden sind ja ebenfalls innerhalb der Klasse und haben somit Zugriffsrechte. Definieren sie eigene Variablen mit gleichem Namen, dann haben diese Vorrang innerhalb des Methoden-Scopes. Will man dennoch innerhalb der Methode auf das Klassenattribut mit diesem Namen zugreifen, genau dann und nur dann, benötigt man this, um den Unterschied zu machen zwischen method und class scope.
Sind sie protected, können sie sogar noch in erbenden Klassen direkt modifiziert werden (z.B. von Auto oder Moped aus). Bei public von überall, auch von außerhalb der Klasse.

 

[It'sNever2Late!]

Nagut, dann werde ich mir nochmal Polymorphie und Scopes in Ruhe anschauen und warhscheinlich noch ein Programm schreiben welches beides beinhaltet.

Desweiteren würde ich gerne wissen ob ich schonmal die Java-"Basics" drauf habe oder ob es noch einges zu Lernen gibt bis man die Grundkenntnisse beherrscht.

Und ich würde gerne wissen was die Themen der nächsten Schwierigkeitsstufe wären um zu wissen was ich lernen muss.

Und ob ich für das im September beginnende Informatik-Studium in Sachen OOP gewappnet bin.

 

[Tumbleweed]

Die Hälfte hast du bis morgen wieder vergessen. Beim Programmieren hilft nur Anwenden und dadurch verinnerlichen. Eben an konkreten, halbwegs sinnvollen Beispielprogrammen.

Interessante Themen als nächstes wären:

• Streams (IO, Dateien lesen, verarbeiten, schreiben)
• einfache Netzwerkverbindung mit Sockets
• Kommunikation mit einer Datenbank (JDBC)
• Multithreading (und entsprechende pitfalls des gleichzeitigen Zugriffs auf Daten)
• GUI
• design patterns

Alles Themen, die easy to learn, hard to master sind.


Uni-näher wären Dinge wie Sortier- und Suchalgorithmen. Musst du wissen, was dich mehr interessiert.

 

[It'sNever2Late!]

Was mich am meisten Interessieren würde wäre ja eine Java-Applikation welche im Browser ausgeführt wird und div. querys ausführt.

Bis ich das kann muss ich aber erstmal die Punkte 'GUI' und 'Kommunikation mit einer Datenbank (JDBC)' abarbeiten.

Und ganz cool wäre ein Video-Player in Java, der auch im Browser ausgeführt wird.

Desktop-Programme in Java wollte ich eigentlich ungern schreiben (außer zum Lernen).
Höchstens ne App für mein Smartphone. (obwohl ich davon sicher noch weit entfernt bin)

 

[Tumbleweed]

Kannst du alles als Applet umsetzen, ist aber etwas fummeliger, als eine simple Anwendung. Am besten ist es, wenn du dir von Anfang an angewöhnst, die Darstellungslogik (sog. "view") vom Rest des Programms ("controller" und "model") zu trennen. Das erlaubt dir nämlich, wenn du es korrekt machst, einfach von Anwendung auf Applet umzusteigen, ohne deinen Programmcode großartig ändern zu müssen.

JDBC+GUI habe ich auch recht früh gemacht, das ist schon ein schönes Erfolgserlebnis und relativ leicht umsetzbar.