Java Vererbung Fragen (zu Code Beispiel)

[BobbyJean]

Hallo liebe Community,
ich bin gerade dabei mich mit der Vererbung bei Java zu beschäftigen und um Dinge nachzuvollziehen gehe ich oft wie unten vor, ich schreibe relativ viele Kommentare im Code um mir zu merken "was was macht" und "was was ist" etc.

Beim folgenden Code Beispiel habe ich ein paar Probleme was den Ablauf angeht, ich versuche dann den Code mit dem Debugger (verwende Eclipse) zu öffnen um zu sehen wie die Schritte durchgegangen werden aber irgendwie hab ich hier Probleme das Ganze nachzuvollziehen:

//Basisklasse
class Basis2 {
   
    //Attribut:
    int b_wert;
   
    //Methode Basis2, b_wert wird auf 1 gesetzt:
    Basis2() {
        b_wert = 1;
    }
   
    //Werden Variablen mit final gekennzeichnet,
    //so sind sie nach der Initialisierung nicht mehr änderbar
    //Methode Basis2, als Parameter wird final double p übergeben:
    Basis2(final double p) {
        //b_wert wird auf ???
        b_wert = (int) p;
    }
   
    //Methode Basis2, als Parameter wird final int p übergeben:
    Basis2(final int p){
        //b_wert wird auf p gesetzt
        b_wert = p;
    }
   
}

    //mit extends wird Basis2 als Basisklasse verwendet:

class Abgeleitet extends Basis2 {
    //Attribut:
    int abg_wert;
   
    //Methode Abgeleitet, abg_wert wird auf 1 gesetzt:
    Abgeleitet() {
        abg_wert = 1;
    }
   
    //Hier werden Argumente an den Basisklassenkonstruktor weitergereicht:
    Abgeleitet(final int param1, final double param2){
        //mit super wird der Konstruktor der Basisklasse aufgerufen, param2 wird übergeben
        super(param2);
        //abg_wert wird auf param1 gesetzt:
        abg_wert = param1;
    }
}


//Main Methode, diese wird immer als erstes ausgeführt:
class Basisklassenkonstruktor {
    public static void main(final String[] args) {
        //Absatz:
        System.out.println();
       
        //Es wird nun ein neues Objekt mit dem Namen obj1 und dem Typ Abgeleitet angelegt
        final Abgeleitet obj1 = new Abgeleitet();
        System.out.println(" obj1 /n");
        System.out.println(" b_wert = " +obj1.b_wert);
        System.out.println(" abg_wert = " +obj1.abg_wert);
       
       
        //Es wird nun ein neues Objekt mit dem Namen obj2 und dem Typ Abgeleitet angelegt
        //es werden 2 Parameter übergeben: 22 und 11.90
        final Abgeleitet obj2 = new Abgeleitet(22, 11.90);
        System.out.println(" obj2 /n");
        System.out.println(" b_wert = " +obj2.b_wert);
        System.out.println(" abg_wert = " +obj2.abg_wert);
       
    }
}

meine Fragen wären:
1. Vielleicht könntet ihr mir was den Ablauf betrifft weiterhelfen und eine kurze Übersicht geben wie dieser hier ist
2. Diese Zeile versteh ich nicht ganz: "b_wert = (int) p;", hier wird meiner Meinung nach b_wert auf int p gesetzt. Warum ist das int in Klammern?
3. Falls ihr Ergänzungen/Tipps zu meinen Kommentaren im Code habt, ich in für jeden Tipp dankbar. Wie gesagt mir geht es grundsätzlich darum das Ganze nachzuvollziehen und ich bin der Meinung wenn man die Zeilen immer ein bisschen definiert und schreibt was so vorgeht fällt einem das Ganze leichter (oder was meint ihr?)

Vielen Dank schon mal für Eure Hilfe, falls Fragen bestehen immer her damit

 

[Dimax]

1.Im class Basis 2 sind Konstruktoren beschrieben wie ein Objekt dieser classe erstellt wird
wenn mann Basis2 test=new Basis2(25.5); schreib nimmt Java
Basis2(final double p) {
//b_wert wird auf ???
b_wert = (int) p;
}
Variante usw..
2 b_wert = (int) p;-> einfaches Type Casting Variable p ist double b_wert ist int-> aus p wird int gemacht also nur ganzes Teil genommen.

 

[Dimax]

//Basisklasse oder  Vaterklasse
class Basis2 {
 
    //Attribut:
    int b_wert;
 
    //Methode Basis2, b_wert wird auf 1 gesetzt: !Falsch Keine Methode-> Konstruktor-Unterschied im Namen
//Konstruktoren tragen immer gleichen Namen wie die Klasse selbst Methoden einer Klasse dürfen sowas nicht
    Basis2() {
        b_wert = 1;
    }
 
    //Werden Variablen mit final gekennzeichnet,
    //so sind sie nach der Initialisierung nicht mehr änderbar
    //Methode Basis2, als Parameter wird final double p übergeben: !Konstruktor Variante 2 mit double Parameter
    Basis2(final double p) {
        //b_wert wird auf ???
        b_wert = (int) p; // TypeCasting
    }
 
    //Methode Basis2, als Parameter wird final int p übergeben:// Konstruktor Variante 3
    Basis2(final int p){
        //b_wert wird auf p gesetzt //besser wird es zu sagen b_wert wird mit dem p wert initialisiert
        b_wert = p;
    }
 
}

    //mit extends wird Basis2 als Basisklasse verwendet:
/*besser zu sagen Die Vaterklasse Basis2 wird im Klass Abgeleitet
erweitert..also zu dem was die Klasse Basis2 gehabt hat werden zusätzliche Methoden Parameter oder Konstruktoren hinzugefügt oder vorhandene mit @Override überschrieben
*/
class Abgeleitet extends Basis2 {
    //Attribut:
    int abg_wert;
 
    //Methode Abgeleitet, abg_wert wird auf 1 gesetzt:
//besser mit 1 initialisiert weil sowie du schreibst ist 1 der Platzhalter für das Wort abg_wert
    Abgeleitet() {
        abg_wert = 1;
    }
 
    //Hier werden Argumente an den Basisklassenkonstruktor weitergereicht:
/* nein das ist ein neues Konstruktor der Klasse Abgeleitet der ein Konstruktor der Vaterklasse mit Basis2(double)
um ein zweites parameter erweitert*/
    Abgeleitet(final int param1, final double param2){
        //mit super wird der Konstruktor der Basisklasse aufgerufen, param2 wird übergeben
        super(param2);
        //abg_wert wird auf param1 gesetzt:
        abg_wert = param1;
    }
}


//Main Methode, diese wird immer als erstes ausgeführt:
class Basisklassenkonstruktor {
    public static void main(final String[] args) {
        //Absatz://Leerzeile wird gedrückt
      System.out.println();
  
        //Es wird nun ein neues Objekt mit dem Namen obj1 und dem Typ Abgeleitet angelegt
/*Es wird ein Objekt der Klasse Abgeleitet erstellt da aber die Klasse Abgeleitet kein Konstruktor ohne Parameter
hat wird der Konstruktor der Vaterklasse aufgerufen..so wie du erkannt hast mit super()
new Abgeleitet() bedeute neues Objekt was in Klammern steht ist entscheidend bei dem Konstruktor Auswahl
*/
        final Abgeleitet obj1 = new Abgeleitet();

        System.out.println(" obj1 /n");
        System.out.println(" b_wert = " +obj1.b_wert);
        System.out.println(" abg_wert = " +obj1.abg_wert);
  
  
        //Es wird nun ein neues Objekt mit dem Namen obj2 und dem Typ Abgeleitet angelegt
        //es werden 2 Parameter übergeben: 22 und 11.90
/* new Abgeleitet (int,double) zeigt Java welchen Konstruktor verwendet muss,also das ist der von der Kind Klasse
Abgeleitet weil Klasse Basis2 hat kein Konstruktor mit (int,double) also new Basis2(22,11.90) wird nicht funktionieren*/
        final Abgeleitet obj2 = new Abgeleitet(22, 11.90);
        System.out.println(" obj2 /n");
        System.out.println(" b_wert = " +obj2.b_wert);
     System.out.println(" abg_wert = " +obj2.abg_wert);
  
    }
}

 

[mihe7]

Fangen wir mal von hinten an.

Wenn Du einen Kommentar brauchst, um zu wissen, dass a=1 der Variablen a den Wert 1 zuweist, dann solltest Du Dich erst mit den Grundlagen vertraut(!) machen.

Solche Kommentare haben keinen Mehrwert und behindern nur das Lesen des Codes. Kommentare sind dazu da, zu beschreiben, WARUM man etwas gemacht hat, NICHT WAS man gemacht hat. Letzteres steht nämlich schon im Code.

Es mag am Anfang schwieriger sein, ohne solche Kommentare auszukommen. Du willst aber lernen, den Code zu lesen. Wenn Du wirklich etwas nachvollziehen musst und glaubst, mit Kommentaren besser zurecht zu kommen, dann würde ich die nur temporär dazuschreiben und hinterher wieder löschen.

Besser wäre es dagegen, wenn Du sinnvolle(re) Namen verwenden würdest. Basis2 ist doch sehr abstrakt, b_wert auch. Und abg_wert ist fast schon falsch, denn es ist gerade nicht der abgeleitete Wert, sondern ein neues Attribut, das in der abgeleiteten Klasse deklariert wurde. Nimm doch lieber was griffigeres, dann macht es das Lesen leichter.

Die Frage 2 hat @Dimax ja schon beantwortet. Hintergrund ist, dass es in Java nicht direkt möglich ist, eine Fließkommazahl (float oder double) einer Ganzzahl zuzuweisen, weil dadurch Informationen verloren gehen würden. D. h. man muss dem Compiler explizit mitteilen, dass er die Variable p, die vom Typ double ist, wie eine Variable vom Typ int behandeln soll. Dies geschieht, indem man den Zieltyp (hier: int) in Klammern vor dem Wert bzw. der Variablen schreibt. Genannt wird dieses Vorgehen (explicit) type-casting, auf Deutsch (explizite) Typumwandlung.

Wie "explizit" schon andeutet, gibt es auch eine implizite Form der Typumwandlung. Diese wird vom Compiler automatisch durchgeführt. Willst Du beispielsweise eine int- und eine double-Variable miteinander multiplizieren, behandelt der Compiler die int-Variable automatisch so, als wäre sie vom Typ double.

Zu Frage 1: was willst Du denn wissen?