Java Anfängerfragen Java-Einstieg

[It'sNever2Late!]

Also ich habe die Bezeichnungen so verstanden:

 // Klasse
 // Typ
    |  // Instanz
    |       |    // Referenz
    Person vater = new Beamter();

------------------------------

Person vater = new Beamter();

Vater ist eine Referenzvariable vom Typ Person, welche auf eine Instanz des Typs Beamter verweist.

Verstanden. Bis auf die unterschiedlichen Bezeichnungen.

Du kannst darauf die Methoden aufrufen, die der Typ Person veröffentlicht.

Gut, verstanden.
Typ variablenname = new Referenz();
variablenname kann alle methoden der Klasse typ aufrufen.

Wenn deine Beamtenklasse Methoden der Person überschreibt (beispielsweise wenn beide eine Methode 'Hallo' jaben),override? dann ruft du trotzdem die Implementierung aus Beamter und nicht aus Person auf (Late binding). Der Überbegriff für das ganze ist Polymorphie, evt. hilft dir das bei deiner Recherche.

da muss ich mal schauen, hört sich wieder kompliziert an.

 

[Tumbleweed]

Sieht so aus als hättest du die Begrifflichkeiten genau verkehrt herum gelernt.

Override, zu deutsch "überschreiben", erlaubt untergeordneten Klassen, Methoden, die bereits in der Klasse, von der sie selbst erben, existieren, zu überschreiben, d.h. deren Implementierung zu ersetzen.
// Um Himmels Willen, ob hier die Interpunktion stimmt?

Sieht dann z.B. so aus:

    public static void main(String[] args) {
        Beamter vater = new Beamter();
    }

    private static class Person {

        public void tanzen() {
            System.out.println("Ich tanze Walzer");
        }
    }

    private static class Beamter extends Person {
        // Vor Java 7 stand hier @Override als "annotation" drüber
        public void tanzen() {
            System.out.println("Ich tanze Tango");
        }
    }

Edit: Ach so, na dann ist ja alles in Butter. Dachte nur, du wüsstest das nicht, weil du das override fett markiert hattest.
Muss übrigens keinesfalls abstract sein, um überschrieben zu werden. Sie darf nur nicht final sein.

 

[It'sNever2Late!]

Hättest du dir mein Programm von Post 31 angesehen wüsstest du, dass ich zumindest override beherrsche.

override = abstracte methode einer klasse überschreiben.

Ich kenn das sogar von PHP, da habe ich die Funktion _query() überschrieben

Edit:
Ich habe es fett geschrieben, weil ich dachte, dass er override meint, da ich seinen Post (late binding, poly...) nicht so ganz verstanden hatte.

Ist denn die restliche Bezeichnung korrekt? Also das:

    // Klasse
    // Typ
    | // Instanz
    | | // Referenz
    Person vater = new Beamter();

 

[Darlis]

override = abstracte methode einer klasse überschreiben.

Teilweise richtig
Überschreiben kannst du alle Methoden der Superklasse (muss nicht zwingend abstract sein) und Methoden aus einem Interface.

Ist denn die restliche Bezeichnung korrekt? Also das:

    // Klasse
    // Typ
    | // Instanz
    | | // Referenz
    Person vater = new Beamter();

Fast: vater (die Variable) ist eine Referenz (zeigt auf) auf eine Instanz (new Beamter()).

 

[Tumbleweed]

Wichtig dabei ist, dass die Referenz (wie du schon gemerkt hast) einen (auf den ersten Blick) anderen Typ haben kann als die Instanz, zu der sie zeigt. Und das ist unheimlich nützlich! Die Typen der Referenz und der Instanz müssen allerdings in "hierarchisch sinnvollem" Zusammenhang stehen (wie vorher erläutert wurde).

 

[It'sNever2Late!]

@Darlis

aufgrund eines Fehlers beim Kopieres der Bezeichnungen (ich hatte die Bezeichnungen schonmal gepostet) sind die Bezeichnungen alle etwas verrutscht, also hier nochmal:

 // Klasse
 // Typ
    |  // Instanz
    |       |    // Referenz
    Person vater = new Beamter();

Oder:

Person vater = new Beamter();
KLASSE/TYP INSTANZ/OBJEKT = NEW REFERENZ();


Solange das nicht geklärt ist, werde ich andauernd verwirrt.

Überschreiben kannst du alle Methoden der Superklasse (muss nicht zwingend abstract sein) und Methoden aus einem Interface.

Also:
abstracte Methode => muss in abgeleiteter Klasse überschrieben werden
normale Methode => kann in abgeleiteter Klasse überschrieben werden
final Methode => kann nicht überschrieben werden

 

[dcobra]

@Darlis

aufgrund eines Fehlers beim Kopieres der Bezeichnungen (ich hatte die Bezeichnungen schonmal gepostet) sind die Bezeichnungen alle etwas verrutscht, also hier nochmal:

 // Klasse
 // Typ
    |  // Instanz
    |       |    // Referenz
    Person vater = new Beamter();

Oder:

Person vater = new Beamter();
KLASSE/TYP INSTANZ/OBJEKT = NEW REFERENZ();

Eigentlich ist es eher

Referenztyp Referenz(variable) = Instanz/Objekt (Typ)();

Also:
abstracte Methode => muss in abgeleiteter Klasse überschrieben werden
normale Methode => kann in abgeleiteter Klasse überschrieben werden
final Methode => kann nicht überschrieben werden

Punkt 1: Ja, es sei denn es wird beim Ableiten wieder abstract, dann kein Zwang
Punkt 2: ja, sofern die Zugriffsmodifizierer das überhaupt zulassen
Punklt 3: ja

 

[It'sNever2Late!]

Ganz toll und ich stütze mich auf diesen Post:
https://www.computerbase.de/forum/threads/anfaengerfragen-java-einstieg.1058450/page-2#post-12004199

Zitat:

Motorrad mrad = new Motorrad(60);

Eine Instanz einer Klasse ist nur ein Objekt dieser Klasse. Zum Beispiel ist mrad in meinem Beispiel oben eine Instanz der Klasse Motorrad.

 

[dcobra]

Ganz toll und ich stütze mich auf diesen Post:
https://www.computerbase.de/forum/threads/anfaengerfragen-java-einstieg.1058450/page-2#post-12004199

Zitat:

"Eine Instanz einer Klasse ist nur ein Objekt dieser Klasse."
-> Richtig, sind nur Synonyme

"Zum Beispiel ist mrad in meinem Beispiel oben eine Instanz der Klasse Motorrad."
-> Verwirrend, aber das sagt man umgangssprachlich leider so. Genauer müsste man so sagen: mrad ist eine Referenz, welche eine Instanz des Typs Motorrad referenziert. Aber das oben genannte wirst du trotzdem überall finden, da du indirekt (nämlich über die Referenz) ja schon auf dem Objekt arbeitest. Wenn man es genau nimmt ist es aber nicht ganz korrekt.

 

[Tumbleweed]

Das stimmt umgangssprachlich schon so, du hast es aber falsch verstanden, weil das genau der Knackpunkt ist. Wenn man sagt "mrad ist..." dann meint man damit, dass sich hinter der Referenz(variable) mrad eine Instanz der Klasse Motorrad versteckt, nicht dass das Wort mrad eine Instanz ist.

edit: verdammt, zu lahm

 

[It'sNever2Late!]

Motorrad mrad = new Motorrad(60);
Referenztyp Referenz(variable) = Instanz/Objekt (Typ)();

mrad ist eine Referenz(-variable), welche eine Instanz(Objekt-Typ) des Typs Motorrad(Referenztyp) referenziert.

Ich hoffe ich habe es jetzt korrekt verstanden. :S

Dann kann ich ja jetzt meine Frage zum xten Mal stellen, aber diesmal mit richtigen Bezeichnungen:

Was genau ist hier anders?
Hier kann vater alle Methoden von Person aufrufen:

Person vater = new Person();

Und hier auch, aber diesmal ist der Objekt-Typ der einer abgeleiteten Klasse:

Person vater = new Beamter();

Worin liegt der Unterschied zwischen diesen beiden Referenzvariablen, die zwar denselben Referenztypen aber unterschiedliche Objekt-Typen haben?

 

[Tumbleweed]

Da gibt es keinen Unterschied. Die Referenzvariable an sich ist auch nahezu "nichts". Das sind nur ein paar bytes, in denen die Adresse des Objekts gespeichert wird. Wie ein Wegweiser-Schild, was einfach nur in eine Richtung zeigt.

        Beamter vaterB = new Beamter();
        Person vaterP = vaterB;

sind z.B. nur 2 Wegweiser, die zur selben Instanz zeigen und dabei unterschiedliche Methoden (ohne casten) anbieten.

 

[It'sNever2Late!]

Das bedeutet also, dass der Objekt-Typ vollkommen egal ist?

Obwohl man ja mit dem zuweisen des objekt-typen auch den konstruktor der jeweiligen klasse aufruft und ihm ggf. unterschiedliche Argumente mitgeben kann.

Die Konstruktoren von Person und der von person abgeleiteten Klasse Beamter müssen ja nicht gleich sein bzw. können unterschiedliche Argumente erwarten.

 

[Tumbleweed]

Nicht vollkommen, denn wie ich hier schrieb, muss natürlich ein hierarchischer Zusammenhang bestehen.
D.h. du kannst keinen Personenzeiger (ich nenne es jetzt mal Zeiger der Einfachheit wegen) auf ein Auto zeigen lassen, es sei denn Auto würde sinnloserweise von Person erben.

 

[It'sNever2Late!]

Mir wäre es lieber wenn wir bei Referenztyp Referenzvariable = new Objekttyp(); bleiben würden, da ich das gerade wieder verinnerlicht habe.

Mit Personenzeiger meinst du Objekttyp nehme ich mal an.

abstract class Person

class Beamter extends Person

class Student extends Person

Und

abstract class Fahrzeug

class Auto extends Fahrzeug

class Moped extends Fahrzeug

haben nichts miteinander zu tun. (ist doch klar)

In Beispiel 1 ist folgendes möglich

Person beamter =new Beamter(); // ist das überhaupt möglich? denn die Klasse Person ist ja abstrakt
Beamter beamter2 = new Beamter();
Person student = new Student(); // ist das überhaupt möglich? denn die Klasse Person ist ja abstrakt
Student student2 = new Student();

Und in Beispiel2 dasselbe:

Fahrzeug auto = new Auto(); // ist das überhaupt möglich? denn die Klasse Fahrzeug ist ja abstrakt
Auto auto2 = new Auto();
Fahrzeug moped = new Moped(); // ist das überhaupt möglich? denn die Klasse Fahrzeug ist ja abstrakt
Moped moped2 = new Moped();

Ich weiß aber immernoch nicht wie unterschiedlich sich Referenzvariablen desselben Referenztypen mit unterschiedlichen Objekttypen verhalten bzw. was sie unterscheidet.

Ich bin mir inzwischen dessen bewusst, dass man das alles hierarchisch aufbauen muss.

 

[Tumbleweed]

Tut mir leid, ich wollte nicht noch mehr Verwirrung mit den Begriffen stiften.

Du fragst dich also, wo der Unterschied ist, zwischen

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

Der einzige Unterschied besteht darin, dass moped2 auf einen spezielleren Typ der Typenhierarchie "Fahrzeug" verweist. Das führt dann im Verhalten dazu, dass dir per

moped2.

andere Methoden zur Verwendung bereitstehen, als wenn du

moped.

benutzt. Das fällt am besten auf, wenn du in einer IDE arbeitest, die dir die Methoden anbietet, die zur Verfügung stehen. Hat z.B. das Moped eine Methode staenderAusklappen(), dann kannst du diese nur über moped2 aufrufen, nicht über moped. Würdest du sie über moped aufrufen wollen, müsstest du erst einmal sicherstellen, dass es sich bei dem Fahrzeug um ein Moped handelt.

if (moped instanceof Moped)
   ((Moped) moped).staenderAusklappen();

 

[It'sNever2Late!]

Hierarchie:
class Fahrzeug
class Auto extends Fahrzeug

Also es gibt 4 Deklarationsmöglichkeiten

Fahrzeug eins = new Fahrzeug();

eins ist eine Referenzvariable vom Referenztyp Fahrzeug und zeigt auf den Objekttypen Fahrzeug
eins kann alle Methoden der Klasse Fahrzeug aufrufen

Auto zwei = new Auto();

zwei ist eine Referenzvariable vom Referenztyp Auto und zeigt auf den Objekttypen Auto
da Auto eine abgeleitete Klasse der Klasse Fahrzeug ist kann zwei die Methoden der Klasse Auto und die noch nicht überschriebenen Methoden der Klasse Fahrzeug aufrufen

Fahrzeug drei = new Auto();

drei ist eine Referenzvariable vom Referenztyp Fahrzeug und zeigt auf den Objekttypen Auto
drei kann die Methoden der Klasse Fahrzeug aufrufen (glaube ich zumindest)
ICH HABE KEINE AHNUNG WIE SEHR DER OBJEKTTYP new Auto(); die Referenzvarialbe drei BEEINFLUSST

Auto vier = new Fahrzeug();

vier ist eine Referenzvariable vom Referenztyp Auto und zeigt auf den Objekttypen Fahrzeug
vier kann die Methoden der Klasse AUto aufrufen (glaube ich zumindest)
ICH HOFFE DOCH SEHR, DASS DAS IN KEINSTER WEISE MÖGLICH IST, DA ICH MIR NIX DARUNTER VORSTELLEN KANN

Ich hoffe du weiß jetzt was ich nicht verstehe und was ich verstehe bzw. meine zu verstehen

 

[Tumbleweed]

ICH HABE KEINE AHNUNG WIE SEHR DER OBJEKTTYP new Auto(); die Referenzvarialbe drei BEEINFLUSST

Gar nicht. Die Referenzvariable steht für sich und wird von nichts beeinflusst. Was da auf der rechten Seite rangehangen wird, ist ihr Wurst, solange es hierarchisch korrekt bleibt.

Vier geht gar nicht, weil du da mindestens ein Auto dranhängen musst oder etwas, was von Auto erbt. In diese Richtung der Hierarchie kann man also nicht referenzieren, denn wenn jemand vier benutzt, geht er davon aus, dass da ein Auto dranhängt, mit allem was ein Auto kann. Fahrzeug kann aber alles mögliche sein und daher funktioniert das nicht.

Ansonsten scheinst du das doch schon ganz gut begriffen zu haben.

 

[It'sNever2Late!]

solange es hierarchisch korrekt bleibt.

Am besten wäre es also Auto = new Auto() und Moped = new Moped() zu machen und sowas wie Fahrzeug = new Auto() wegzulassen. (ich denke es ist sowieso verboten, da Fahrzeug ne abstrakte Klasse ist)

Vier geht gar nicht,

Das ist gut.

if (moped instanceof Moped)
 ((Moped) moped).staenderAusklappen();

Die Methode staenderAusklappen würde nicht aufgerufen werden.

 

[Tumbleweed]

Naja damit sind wir schon wieder bei der nächsten Baustelle. Es ist schon sinnvoll, einen höheren, abstrakten Typ zu verwenden. Wenn dich das aber nur verwirrt, dann lass das erst einmal weg. Das ist dann schon für Fortgeschrittene.
Wenn Fahrzeug abstract ist, kann es nicht mit new instantiiert werden, richtig.

Doch, staenderAufklappen() würde aufgerufen (bitte nicht aufgeben, du hast es fast geschafft ). Denn - wenn da steht moped instanceof Moped, dann wird nicht der Typ von moped selbst (der Referenzvariable) getestet, sondern der Typ der Instanz, auf die moped verweist. Es wird quasi nur dem Wegweiser moped gefolgt und der zeigt auf eine Instanz.
Und da du ja moped auf new Moped() verweisen lässt, würde dieser Ausdruck true liefern und der Ständer würde ausgeklappt.

Es würde ja auch gar keinen Sinn ergeben, auf den Typ der Referenzvariable zu prüfen, denn der ist zur Kompilierung schon bekannt und bleibt gleich. Der Typ des referenzierten Objekts kann sich aber zur Laufzeit ändern, daher macht man solche checks.