Konstruktoren und Variablen

C

clash

Mitglied
Hallo zusammen,
also ich habe folgendes Problem. Ich soll nur die 1 Variable deklarieren, aber 3 Konstruktoren "erschafffen" welche dann auch noch Variablen haben. Ich habe,das Problem sonst umgangen in dem ich einfach mehr Variablen am Anfang genommen habe, das soll bzw. darf ich aber nicht mehr. Es geht dabei um das "public void setPosition". Ich habe vorher halt immer setXpos/Ypos deklariert und damit dann weiter gearbeitet. Das soll ich jetzt aber nicht mehr machen und ich sitze schon gefühlt ewig dran. Ich verstehe nicht, wie das gehen soll, wenn ich vorher nicht double xpos/ypos deklariere. Vielleicht könnt ihr mir helfen?Ich hoffe ihr versteht, was ich meine. Ich kann aber natürlich weitere Ausführungen geben. Vielen lieben dank schon mal :)
Wie es sein soll:
public abstract class Figure2 implements IFigure {
    private Tupel position;
    

    
    public Figure2() {
        
    }
    public Figure2(double xpos, double ypos) {
    }
    public Figure2(Tupel position) {
        this.position= position;
    }
    public Tupel getPosition() {
        return position;
    }
    
    public void setPosition(double x, double y) {
        this.position=XXXX ;   //genau hier weiß ich nicht weiter
    }
Wie es ist:
public abstract class Figure implements IFigure {
    
    private double xpos,ypos;
     private Tupel position;



    //Standardkontruktor
        public Figure(){
        this.xpos = 0.0;
        this.ypos = 0.0;
    }
        //Initialisierungskonstruktor
        public Figure(double xpos, double ypos){
                setXpos(xpos);
                setYpos(ypos);
            }
        //Initialisierungskonstruktor
        public Figure(Tupel position){
                setPosition(xpos, ypos);
            }
    //Getter

        public Tupel getPosition() {
            return position;
        }
        public double getXpos() {
            return xpos;
        }
        public double getYpos() {
            return ypos;
        }
        
    //Setter   

        public void setPosition(double xpos, double ypos) {
            this.xpos = xpos;
            this.ypos = ypos;
        }
        public void setXpos(double xpos) {
            this.xpos = xpos;
        }
        public void setYpos(double ypos) {
            this.ypos = ypos;
        }
        }
 
temi

temi

Top Contributor
Ich kenne deine Klasse Tupel nicht, aber die hat doch sicher einen Konstruktor mit zwei Werten, bzw. getter/setter, oder?

Dann kannst du doch mit den zwei Parametern deines Konstruktors ein Tupel erzeugen und der Instanzvariablen "position" zuweisen.

Oder ich hab dich völlig falsch verstanden, dann solltest du dein Problem evtl. noch einmal genauer beschreiben.
 
Zuletzt bearbeitet:
C

clash

Mitglied
Danke, für die schnelle Antwort. Ich verstehe aber nicht ganz wie du das meinst...
Ich kenne deine Klasse Tupel nicht, aber die hat doch sicher einen Konstruktor mit zwei Werten, bzw. getter/setter, oder?

Dann kannst du doch mit den zwei Parametern deines Konstruktors ein Tupel erzeugen und der Instanzvariablen "position" zuweisen.

Oder ich hab dich völlig falsch verstanden, dann solltest du dein Problem evtl. noch einmal genauer beschreiben.



Tupel:
public class Tupel {
   public double x, y;
   public Tupel (double x, double y) {

}
}
 
kneitzel

kneitzel

Top Contributor
Tupel hat somit x und x ... also kannst du eine neue Tupel Instanz mit den x/x Werten erzeugen und dann der Variable zuweisen
 
C

clash

Mitglied
Okay, ich hätte da jetzt noch eine weitere Frage. Ich habe das jetzt alles implementiert und es funktioniert wunderbar. Da Figure abstract ist, habe ich noch eine Klasse die heißt Ellipse. in dieser soll ich jetzt den Umfang und den Flächeninhalt berechnen. Das habe ich vorher immer mit getXpos/getYpos bzw. getWidth/getHeight und der jeweiligen Formel bewerktstelligt. Aber ich habe jetzt weder getXpos/ypos noch getWidht/Height sondern nur noch getSize und getPosition. Ich müsste also immer nur einen Teil nutzen und dann später den zweiten. Geht das Überhaupt?
Eillipse:
 public class Ellipse extends Figure {
    
     /*
      * Konstruktoren
      */
     public Ellipse(double xpos, double ypos, double width, double height){
            setPosition(xpos, ypos);
            setSize(width, height);
        }
     public Ellipse(Tupel position, Tupel size){   
         Tupel t = new Tupel();
            setPosition(t.x, t.y); //keine Ahnung ob das so richtig ist.
            setSize(t.x,t.y);
         }
     /*
      * Standardkonstrukor
      */
     public Ellipse () {
            setPosition(0.0,0.0);
            setSize(100, 50);
        }           
    
    /**
     * string representation of the object
     * @return string
     */
    @Override
    public String toString() {
        return "Position X = " +this.getPosition() + " Weite = " +this.getSize()+ " Umfang" + circumference() + " Fläche = "+ area();}

    /**
     * Umfangsberechnung
     * @return Umfang
     */
    @Override
      public double circumference () {
         double umfang;
         umfang = 2*(this.getSize()); //hier komme ich nicht weiter
          return umfang;}
        
    /**
     * Flaechenberechnung
     * @return Flaecheninhalt
     */
    @Override
    public double area () {
        double flaeche;
        flaeche = (this.getWidth())*(this.getHeight()); //so war es vorher
        return flaeche;}
    @Override
    public Rectangle clone() {
        return new Rectangle(getSize(), getPosition())}
 
temi

temi

Top Contributor
Java:
public Ellipse(Tupel position, Tupel size){ 
    Tupel t = new Tupel();
    setPosition(t.x, t.y);
    setSize(t.x,t.y);
}

Du erzeugst da ein Tupel ohne Werte. Gibt es für Tupel überhaupt einen Standardkonstruktor, der das erlaubt?

Angenommen, das leere Tupel konnte erzeugt werden, dann versuchst du nun die Werte aus diesem einem Tupel (die vermutlich alle 0 sind) für Position und Größe zu verwenden. Warum nutzt du dafür nicht die als Parameter übergebenen Werte?

Aber ich habe jetzt weder getXpos/ypos noch getWidht/Height sondern nur noch getSize und getPosition.
Die beiden genannten Methoden getSize() und getPosition() liefern als Rückgabewert ein Tupel. Wie du auf die darin enthaltenen beiden Werte zugreifen kannst das weißt du ja (siehe Zugriff auf das Tupel t im Code weiter oben).
 
C

clash

Mitglied
Eigentlich nicht nein, aber ich wusste nicht wie ich das anders machen soll...

Weil ich nicht weiß, wie ich das mache. Ich habe in der Main Methode ja keine Variablen deklariert.
 
temi

temi

Top Contributor
Eigentlich nicht nein, aber ich wusste nicht wie ich das anders machen soll...

Weil ich nicht weiß, wie ich das mache. Ich habe in der Main Methode ja keine Variablen deklariert.
Keine Ahnung was du meinst. Zeig mal nur die Stellen, mit denen du Probleme hast.

In dem oben gezeigten Codeausschnitt greifst du auf den x-Wert des Tupel t mit t.x zu. Was spricht dagegen, direkt auf den x-Wert z. B. der übergebenen Position (die ja auch ein Tupel ist) zuzugreifen? Tipp: position.x
 
Zuletzt bearbeitet:
C

clash

Mitglied
In dem oben gezeigten Codeausschnitt greifst du auf den x-Wert des Tupel t mit t.x zu. Was spricht dagegen, direkt auf den x-Wert z. B. der übergebenen Position (die ja auch ein Tupel ist) zuzugreifen? Tipp: position.x
Ich glaube das wird mich weiter bringen. Sorry, dass ich so viele Fragen stellen, aber wir fliegen durch die Themen und es macht keinen Spaß. Ich hoffe ich komme so weiter. Danke dir
 
temi

temi

Top Contributor
Sorry, dass ich so viele Fragen stelle
Das ist völlig in Ordnung. Dafür gibt es dieses Forum ja.

Was mir noch auffällt: Die Klasse Figur verwendet anscheinend den Typ Tupel zum Speichern von Position und Größe. Warum werden dann in den beiden Settern für Position und Größe weiterhin Integerwerte verwendet? Ist das so vorgegeben?
 
C

clash

Mitglied
Was mir noch auffällt: Die Klasse Figur verwendet anscheinend den Typ Tupel zum Speichern von Position und Größe. Warum werden dann in den beiden Settern für Position und Größe weiterhin Integerwerte verwendet? Ist das so vorgegeben?
Es ist doch alles Double?

eine weitere Frage hab ich.
Berechnung:
public double area () {
        double flaeche;
        flaeche = (this.getWidth())*(this.getHeight());
        return flaeche;}

ich muss den Flächeninhalt berechnen. Das habe ich vorher immer mit dem Getter für die Höhe und Weite gemacht. Diese habe ich aber nicht mehr, weil jetzt beides in Size abgelegt ist. Aber der Getter gibt mir ja ein Tupel zurück. Wie kann ich denn auf einen Wert direkt zu greifen. Mittels size.x oder this.getSize(), gehts halt nicht.
 
Zuletzt bearbeitet:
temi

temi

Top Contributor
Es ist doch alles Double?
Ja, aber sollte es nicht Tupel sein? EDIT: Irgendwie witzig: double / tupel :)
Aber der Getter gibt mir ja ein Tupel zurück.
Ist doch prima, dann nimm das doch einfach. Steht doch alles schon da, wie es geht. Du erhältst über den Getter ein Tupel zurück und greifst auf dessen x und y zu Tupel size = getSize(); oder direkter Zugriff auf den Rückgabewert ohne zusätzliche Variable getSize().x
 
Zuletzt bearbeitet:
temi

temi

Top Contributor
Etwas anderes: In deiner ursprünglichen Methode verwendest du eine ausführliche Form, das ist auch völlig in Ordnung so. Ich schreibe dir dennoch mal ein paar Varianten hin, die ebenfalls funktionieren und evtl. übersichtlicher sind. Es ist allerdings nicht das Ziel den Code so kurz wie möglich zu schreiben, eher so gut lesbar wie möglich. Welche angebracht ist, muss von Fall zu Fall entschieden werden.
Java:
public double area () {
    double flaeche;
    flaeche = (this.getWidth())*(this.getHeight());
    return flaeche;
}

public double area () {
    // Deklaration und Zuweisung kann in einer Zeile gemacht werden
    // sowohl die Klammerung als auch this sind hier nicht unbedingt notwendig
    double flaeche = getWidth() * getHeight();
    return flaeche;
}

public double area () {
    // kürzeste Variante, die ohne lokale Variable auskommt
    return getWidth() * getHeight();
}
 
C

clash

Mitglied
Ja, aber sollte es nicht Tupel sein? EDIT: Irgendwie witzig: double / tupel :)
Was genau meinst du? Das hier?
setPosition:
public void setPosition(double xpos, double ypos) {
            this.position = new Tupel (xpos, ypos);
Also ich habe mich da an die JavaDoc datei gehalten.
Etwas anderes: In deiner ursprünglichen Methode verwendest du eine ausführliche Form, das ist auch völlig in Ordnung so. Ich schreibe dir dennoch mal ein paar Varianten hin, die ebenfalls funktionieren und evtl. übersichtlicher sind. Es ist allerdings nicht das Ziel den Code so kurz wie möglich zu schreiben, eher so gut lesbar wie möglich. Welche angebracht ist, muss von Fall zu Fall entschieden werden.
Java:
public double area () {
    double flaeche;
    flaeche = (this.getWidth())*(this.getHeight());
    return flaeche;
}

public double area () {
    // Deklaration und Zuweisung kann in einer Zeile gemacht werden
    // sowohl die Klammerung als auch this sind hier nicht unbedingt notwendig
    double flaeche = getWidth() * getHeight();
    return flaeche;
}

public double area () {
    // kürzeste Variante, die ohne lokale Variable auskommt
    return getWidth() * getHeight();
}
Okay, ich habs jetzt erstmal so gemacht, dass ich es verstehe. Wenn dann alles läuft, werde ich es noch optimieren :) danke
 
Zuletzt bearbeitet:
C

clash

Mitglied
So jetzt sitze ich vor einem weiteren Problem. Ich habe jetzt noch eine weitere Klasse geschrieben. Die Aufgabenstellung sieht folgendermaßen aus: "Die Klasse Drawing kann als eine Zusammenstellung von Objekten interpretiert werden, die von der abstrakten Klasse Figure abgeleitet sind. Folglich werden die Referenzen der in der Zeichnung enthaltenen Figuren in einem normalen Array namens shapes verwaltet. cnt gibt die Anzahl der Figuren an.
• Die Klasse Drawing muss zusätzlich zu den Standard- und Zugriffsfunktionen (für cnt, shapes) über eine Reihe von Methoden verfügen, die es ermöglichen,
• eine Figur zur Zeichnung hinzuzufügen (add)
• eine Figur über ihren Index durch eine andere Figur in der Zeichnung zu ersetzen (set),
• eine Figur über ihren Index abzufragen (get),
• eine Figur über ihren Index aus der Zeichnung zu löschen (remove(k))
• alle Figuren aus der Zeichnung zu löschen (remove())"

Drawing:
import java.util.Arrays;
import java.util.Comparator;

public class Drawing {
    private int cnt;
    private Figure[] shapes = new Figure[0];
    
    /*
     * Konstruktoren
     */
    
    public Drawing() {
        
    }
    public Drawing(int size) {
        cnt = shapes.length;
    }
    /*
     * Setter
     */
    public void setShapes(Figure[] shapes, int cnt) {
        this.shapes=shapes;
        this.cnt=cnt;
    }
    
    public void setCnt(int cnt) {
        for (int i = 0; i<shapes.length;i++) {
            if (shapes[i] != null) {
                cnt++;
            }
            
        }
        this.cnt= cnt;
    }
    
    public void set (Figure shape, int k) {
        this.shapes[k]= shapes[k+1];
    }
    
    /*
     * Getter
     */
    public Figure[] getShapes() {
        return shapes;
    }
    public int getCnt() {
        return cnt;
    }
    
    public Figure get(int k) {
        return shapes[k];
    }
    /*
     * Hinzufügen einer Figur
     */
    public int add(Figure f) {
        shapes[cnt]= shapes[cnt+1];
        return cnt;
    /*
     * Löschen einer Figur   
     */
    }
    public boolean remove (int k) {
        if (k == 0){
            return false;
            
        }
        else {
            shapes[k]=shapes[k+1];
            return true;
        }
        
    }
    /*
     * Löschen aller Figuren
     */
    public void remove () {
        for (int i = 0; i < shapes.length; i++) {
            shapes[i] = null;
            
        }
        
    }
Ich verstehe nicht wie ich das mit dem addieren machen soll. Ich muss doch das Array dann jeweils erweitern und dann? Vielleicht verstehe ich die Aufgabe auch überhaupt nicht. Es interagiert auch nicht mit meinen anderen Klassen und ich weiß nicht mal wie ich das testen soll. Ich möchte nicht, dass mir hier jemand eine Lösung präsentiert sondern mir nur tipps gibt. Nicht dass hier ein falscher Eindruck entsteht.
 
temi

temi

Top Contributor
Ich verstehe nicht wie ich das mit dem addieren machen soll. Ich muss doch das Array dann jeweils erweitern und dann? Vielleicht verstehe ich die Aufgabe auch überhaupt nicht. Es interagiert auch nicht mit meinen anderen Klassen und ich weiß nicht mal wie ich das testen soll.
Ja, bei add() muss das Array erweitert werden. Es gibt da verschiedene Möglichkeiten. Entweder du initialisierst das Array bereits so, dass es eine bestimmte Anzahl aufnehmen kann und erweiterst es auch immer um einen Block (Größe deiner Wahl) oder du erweiterst das Array immer um ein Element, wenn ein Element hinzugefügt werden soll. Wie auch immer, das solltest du in eine private Methode der Klasse packen, die bei Bedarf aufgerufen wird.

get() ist leicht, einfach über den Index das Element zurückgeben.
set() ist auch einfach, dazu muss nichts erweitert werden, es wird einfach ein Element ersetzt.

Bei remove() musst du entweder das Array verkleinern oder beim "blockweisen" Ansatz Elemente umkopieren, damit das Array keine "Lücken" hat.
removeAll() ist dagegen wieder leicht. Einfach das vorhandene Array durch ein neues leeres Array ersetzen.

Interaktion mit deinen vorhandenen Klassen musst du schaffen. Du kannst ja eine Anzahl Figuren (= Instanzen deiner Klassen) in das Drawing hineingeben und wieder abrufen/ersetzen/löschen. Wo liegt das Problem?
 
C

clash

Mitglied
Ja, bei add() muss das Array erweitert werden. Es gibt da verschiedene Möglichkeiten. Entweder du initialisierst das Array bereits so, dass es eine bestimmte Anzahl aufnehmen kann und erweiterst es auch immer um einen Block (Größe deiner Wahl) oder du erweiterst das Array immer um ein Element, wenn ein Element hinzugefügt werden soll. Wie auch immer, das solltest du in eine private Methode der Klasse packen, die bei Bedarf aufgerufen wird.
Okay, also ich soll das Array im Konstruktor initialisieren und zwar mittels "int size". Methoden bauen, welche nicht aufgeschrieben sind, darf ich nicht. Dann bekomme ich keine Punkte.... Ich hab das jetzt so gemacht:
Array:
public class Drawing {
    private int cnt; //Das ist die Variable, welche die Anzahl der gepeicherten Werte anzeigen soll.
    private Figure[] shapes; //Leider ist das nicht korrekt so, weil ich es damit immer einen Fehler bekomme, wenn ich "Drawing" clonen will

  
    /*
     * Konstruktoren
     */
  
    public Drawing() {
      
    }
    public Drawing(int size) {
        shapes = new Figure[size];
    }
get() ist leicht, einfach über den Index das Element zurückgeben.
set() ist auch einfach, dazu muss nichts erweitert werden, es wird einfach ein Element ersetzt.
Das hab ich so gemacht, eigentlich dachte ich dass es so klappen sollte, aber es ist nicht korrekt so. Weder das bei cnt noch bei shape. Ich bekomme immer den Fehler, dass es nicht "succesfull" war.
Get/set:
public void setShapes(Figure[] shapes, int cnt) {
        this.shapes=shapes;
        this.cnt=cnt;
    }
  
    public void setCnt(int cnt) {
        this.cnt= cnt;
    }
  
    public void set (Figure shape, int k) {
        this.shapes[k]= shape;
    }
  
    /*
     * Getter
     */
    public Figure[] getShapes() {
        return shapes;
    }
    public int getCnt() {
        return cnt;
      
    }
  
    public Figure get(int k) {
        return shapes[k];
    }
Bei der Addition hab ich mir das hier überlegt:
Addition:
public int add(Figure f) {
        cnt++;
        shapes[cnt]= f;
        return cnt;
Leider klappt es nicht bzw. es ist nicht so wie es sein soll
Und beim Löschen hab ich jetzt das hier gemacht:
Löschen:
public boolean remove (int k) {
        if (k> shapes.length){ //das klappt nicht :(
            return false;
          
        }
        else {
            while (k<= shapes.length) {
            shapes[k]=shapes[k+1];
            k++;
            }
            cnt--;
            return true;
        }
      
    }
    /*
     * Löschen aller Figuren
     */
    public void remove () {
        Figure[] shapes2 = new Figure[0]; // das klappt soweit
        shapes= shapes2;
Interaktion mit deinen vorhandenen Klassen musst du schaffen. Du kannst ja eine Anzahl Figuren (= Instanzen deiner Klassen) in das Drawing hineingeben und wieder abrufen/ersetzen/löschen. Wo liegt das Problem?
Weil das immer zu Fehlern im VPL führt....
 
Zuletzt bearbeitet:
temi

temi

Top Contributor
Es gibt keine Grund einen Setter für cnt zu haben. Diese Variable darf nur intern verwendet werden, sonst kann das den Zustand deiner Klasse komplett zerlegen. Der ist böse 😡. Grundregel OOP: Eine Klasse soll soviel verbergen wie möglich und nur nach außen geben was unbedingt nötig ist.

Warum setShapes()? Der ist doch im Text oben gar nicht gefordert.

Add() ist definitiv falsch. Du musst zuerst prüfen, ob dein Array noch einen freien Platz hat und ggf. ein lokales, größeres Array erstellen. Die bereits vorhandenen Elemente kopieren, das neue Element an der ersten freien Stelle hinzufügen und dann das ursprüngliche Array shapes durch das neue ersetzen.

Bei remove() musst du alle Elemente hinter dem zu löschenden Element um eine Stelle nach vorne kopieren. Dann hast du am Ende ein "freies" Element übrig. Kannst du auch lassen, dann musst du beim nächsten add() das Array nicht vergrößern.
 
Zuletzt bearbeitet:
C

clash

Mitglied
Es gibt keine Grund einen Setter für cnt zu haben. Diese Variable darf nur intern verwendet werden, sonst kann das den Zustand deiner Klasse komplett zerlegen. Der ist böse 😡. Grundregel OOP: Eine Klasse soll soviel verbergen wie möglich und nur nach außen geben was unbedingt nötig ist.

Warum setShapes()? Der ist doch im Text oben gar nicht gefordert.
Bildschirmfoto vom 2021-05-08 15-42-04.png

Weil es hier so gefordert wurde.
Add() ist definitiv falsch. Du musst zuerst prüfen, ob dein Array noch einen freien Platz hat und ggf. ein lokales, größeres Array erstellen. Die bereits vorhandenen Elemente kopieren, das neue Element an der ersten freien Stelle hinzufügen und dann das ursprüngliche Array shapes durch das neue ersetzen.

Bei remove() musst du alle Elemente hinter dem zu löschenden Element um eine Stelle nach vorne kopieren. Dann hast du am Ende ein "freies" Element übrig. Kannst du auch lassen, dann musst du beim nächsten add() das Array nicht vergrößern.
Okay, ich probiere es mal. Danke
 
C

clash

Mitglied
Ja., also was soll ich sagen. Du hast mir schon mehr beigebracht als der Dozent.

Also ich hab jetzt mal Addition nach besten Willen umgesetzt
Addition:
public int add(Figure f) {
        if (cnt<shapes.length) { // hier gucke ich ob die Anzahl der gespeicherten Figuren kleiner als die Länge des Arrays ist. Ist das so, dann erhöhe ich die Anzahl der Figuren um 1 und Speichere dann die Figur in shapes
            cnt++;
            shapes[cnt]=f;
        }
        else {
            Figure [] shape2 = new Figure[cnt+1];
            shape2 = shapes; //kopieren
            shapes[cnt] = shapes[cnt+1];// das Array erhöhen
            shapes = shape2; //zurück kopieren
            shapes[cnt+1]= f;//neue Figur einfügen
            cnt++; //counter erhöhen
        }
        return cnt;

Also beim Löschen habe ich doch das umgesetzt, was du gesagt hast?

Löschen:
if (k> shapes.length){ //wenn k größer als die Länge ist, liegt es ausserhalb des Bereichs und ich kann nichts löschen

            return false;

          
        }

        else {

            while (k< shapes.length) { //solange k kleiner ist als die länge, laufe die schleife durch

            shapes[k]=shapes[k+1]; //dann packe die Figur die in einem höhreren Array ist, in das jetzige

            k++; //erhöhe dann k um eins damit es durchläuft

            }

            cnt--; //verringere den counter um ein

            return true;

        }
 
temi

temi

Top Contributor
Beachte, dass die Indexierung eines Arrays bei 0 beginnt und damit von cnt abweicht. Enthält dein Array ein Element am Index 0, dann hat cnt den Wert 1. Angenommen dein Array hat eine Größe von 2, dann wäre die nächste freie Indexposition 1. Möchtest du nun ein Element hinzufügen, dann wird zuerst cnt erhöht (auf den Wert 2) und anschließend wird versucht das neue Element an Index 2 zuzuweisen. Den gibt es allerdings gar nicht.

Mit shape2 = shapes; überschreibst du dein neu erzeugtes Array mit dem ursprünglichen Array. Kopieren geht nur mit einer Schleife, Element für Element. Oder z. B. mit System.arraycopy(), aber ob ihr das verwenden sollt?
 
C

clash

Mitglied
Beachte, dass die Indexierung eines Arrays bei 0 beginnt und damit von cnt abweicht. Enthält dein Array ein Element am Index 0, dann hat cnt den Wert 1. Angenommen dein Array hat eine Größe von 2, dann wäre die nächste freie Indexposition 1. Möchtest du nun ein Element hinzufügen, dann wird zuerst cnt erhöht (auf den Wert 2) und anschließend wird versucht das neue Element an Index 2 zuzuweisen. Den gibt es allerdings gar nicht.

Mit shape2 = shapes; überschreibst du dein neu erzeugtes Array mit dem ursprünglichen Array. Kopieren geht nur mit einer Schleife, Element für Element. Oder z. B. mit System.arraycopy(), aber ob ihr das verwenden sollt?
Das müsste jetzt doch passen?
Addition:
public int add(Figure f) {
        if (cnt>shapes.length) { //wenn cnt größer ist, als die länge, dann muss das Array erhöht werden
            Figure [] shapes2 = new Figure[cnt+1];
            for (int i = 0; i <shapes.length; i++) { //kopierschleife
                shapes2[i] = shapes [i];
                }
            shapes[cnt] = shapes[cnt+1]; //array erhöhen
            for (int i = 0; i <shapes2.length; i++) { //rückkopieren
                shapes[i] = shapes2 [i];
                }
            shapes[cnt]= f;
            cnt++;//counter erhöhen
        }
        else {
            shapes[cnt]=f;
            cnt++;
        
        }
        return cnt;
Wille ist gut, Wissen ist besser ;)
Ja, ich bin dabei :/

Aber warum funktioniert mein remove nicht?
Löschen:
public boolean remove (int k) {
        if (k> shapes.length){ //hier stand mist
            return false;
         
        }
        else {
            while (k< shapes.length) { //alles eins nachvorne kopieren, solange die länge nicht mit k übereinstimmt
            shapes[k]=shapes[k+1];
            k++;
            }
            cnt--;
            return true;
        }
     
    }
 
Zuletzt bearbeitet:
temi

temi

Top Contributor
Ups, da hab ich was angerichtet. Zurückkopieren musst du nicht, da kannst du tatsächlich die Referenz auf das ursprüngliche Array überschreiben.

Wenn du ein Array erzeugst, dann enthält die entsprechende Variable eine Referenz auf dieses Array. Sie zeigt sozusagen dahin, wo das eigentliche Array im Speicher abgelegt ist.
Java:
int[] arr1 = new int[5]; // neues Array mit zehn Elementen
int[] arr2 = new int[10]; // neues Array mit fünf Elementen

arr1 = arr2; // arr1 enthält nun eine Referenz auf arr2,
             // die ursprüngliche Referenz auf arr1 ist damit verloren gegangen das Array wird
             // irgendwann vom GC entfernt

// aber nehmen wir an das ist nicht geschehen, wir haben also zwei Arrays mit den Längen 5 und 10.

for (int i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i];
}

// jetzt sind die fünf Elemente von arr1 ins arr2 kopiert.

arr1 = arr2;

// jetzt ist die Referenz auf arr1 mit der Referenz auf arr2 überschrieben worden.
// arr1 zeigt jetzt auf ein Array mit 10 Elementen und der Inhalt der ersten fünf entspricht dem
// ursprünglichem Inhalt.

Danach zeigen sowohl arr1 als auch arr2 auf das selbe Array.

Deine Methode vereinfacht sich etwas:
Java:
public int add(Figure f) {
    // wenn das Array zu klein ist, dann vergrößere es  
    if (cnt >= shapes.length) {
        // neues, größeres Array erzeugen
        // alten Inhalt in neues Array kopieren
        // Referenz des neuen Arrays der Instanzvariablen shapes zuweisen.
    }

    // shapes zeigt jetzt auf jeden Fall auf ein Array der passenden Größe, darum:
    shapes[cnt]=f;
    cnt++;
   
    return cnt;
}
 
Zuletzt bearbeitet:
C

clash

Mitglied
Okay, verstehe. Weil ich das 2. Array nur lokal initialisiert(bei mir) habe, kann es auch nirgends mehr verwendet werden und ich kann auf die Referenz verweisen. Richtig verstanden?
 
temi

temi

Top Contributor
Okay, verstehe. Weil ich das 2. Array nur lokal initialisiert(bei mir) habe, kann es auch nirgends mehr verwendet werden und ich kann auf die Referenz verweisen. Richtig verstanden?
Ich weiß nicht, ob ich dich verstanden habe. Ein Array kann man nachträglich nicht mehr vergrößern. Das einzige, was man tun kann ist, die Referenz auf das ursprüngliche Array durch eine Referenz auf ein neues größeres Array zu ersetzen.

Du möchtest ja erreichen, dass die Variable "shapes" auf ein größeres Array zeigt als es ursprünglich gewesen ist.

Das in der Methode erzeugte, lokale Array "shapes2" würde am Ende der Methode ungültig werden. Die Lebensdauer der lokalen Variablen endet bei der schließenden geschweiften Klammer. Du weist allerdings die Referenz auf dieses lokale Array einer Instanzvariablen zu, die ein andere Gültigkeit hat und darum bleibt sie auch nach dem Ende der Methode erhalten.
 
Zuletzt bearbeitet:
C

clash

Mitglied
Ja, genau so meinte ich das.

Okay, dann werde ich mich jetzt noch an die remove sache setzen, weil ich da nicht verstehe, warum es nicht geht, aber das wird! :)
 
temi

temi

Top Contributor
Aber warum funktioniert mein remove nicht?
Vorsicht auch hier: der Index entspricht nicht der Größe des Arrays! Wenn das Array eine Größe von 10 hat, dann hat der höchstmögliche Index den Wert 9. Dein erster Vergleich stimmt also schon nicht.

Ansonsten würde ich einfach eine normale for-Schleife verwenden, die am Index k + 1 beginnt und diesen und alle nachfolgenden Daten um eins nach vorne kopiert. Danach noch cnt entsprechend um eins erniedrigen.
 
C

clash

Mitglied
Ja, okay. Also wenn ich k-1 nehme, dann müsste es doch gehen?
Löschen:
public boolean remove (int k) {
        if (k-1>= shapes.length){
            return false;
            
        }
        else {
            while (k< shapes.length) {
            shapes[k-1]=shapes[k];
            k++;
            }
            cnt--;
            return true;
        }
        
    }
 
temi

temi

Top Contributor
Ja, okay. Also wenn ich k-1 nehme, dann müsste es doch gehen?
Nachdenken!

Angenommen dein Array hat eine Größe von 10 Elementen. Der höchstmögliche Index ist damit 9.

Der Aufrufer der Methode möchte den Index 9 löschen => k = 9.

Dein Vergleich: Wenn 8 <= 10 dann breche mit Rückgabewert "falsch" ab.

Ganz abgesehen davon: Vielleicht ist dein Array ja gar nicht gefüllt. Die Größe des Array sagt ja nicht zwangsweise etwas über die Anzahl der darin enthaltenen Elemente aus (in diesem Fall).
 
C

clash

Mitglied
Ich habs gelöst, zumindest theoretisch. Ich habs mit vielen Beispielen getestet und es hat immer funktioniert. Der VPL sagt mir zwar, dass es nicht richtig ist, aber das kläre ich mit dem Dozenten. Dankeschön :)
 
C

clash

Mitglied
Hallo :) ich hab nochmal eine Frage. Also ich soll dann das Array mit den Figuren klonen. Das haben wir so gemacht:
klonen:
public Drawing clone() {
      Drawing d = new Drawing (shapes.length);
       for (int i = 0; i < shapes.length; i++) {
           if (shapes [i]!= null) {
               Class<? extends Object> c1 = shapes [i].getClass();
               if (c1.isInstance(new Rectangle()))
                   d.shapes[i] = ((Rectangle) shapes[i]).clone();
               else if (c1.isInstance(new Ellipse()))
                   d.shapes[i]= ((Ellipse) shapes[i]).clone();
           }
           else d.shapes[i]= shapes[i];
       }
       d.setCnt(getCnt());
           return d;
So wenn ich das dann in der Main Methode aufrufe bekomme ich diese Fehlermeldung: "Exception in thread "main" java.lang.NullPointerException: Cannot read field "x" because "colors" is null" -> Ich verstehe auch, warum dieser Fehler kommt, aber wie ich ihn weg bekomme erschließt sich mir nicht. Ich habe die Figuren ohne Farbe initialisiert (sollen wir machen) und dann kommt halt der Fehler.
setColor:
public Rectangle(Tupel position, Tupel size, TupelColor colors){  
            setPosition(position.x,position.y);
            setSize(size.x,size.y);
            setColors(colors.x,colors.y); // hier kann er nicht auf x und y zugreifen
        }
setColor:
public void setColors(Color x, Color y) {
            this.colors = new TupelColor(x,y); // das könnte hier dran liegen, also muss ich event. eine schleife schreiben?
        }
clone:
public Rectangle clone() {
        return new Rectangle(getPosition(),getSize(), getColors()); // oder liegt es hier dran?
    }
-> muss ich bei dem letzten clone etwas verändern? Liegt es daran, dass ich hier getColors klone, auch wenn nichts drin ist?
 
kneitzel

kneitzel

Top Contributor
Also wenn Du den clone Weg gehen willst, dann nimm bitte Cloneable und implementiere es so, wie es vorgegeben wurde. Dann ersparst Du Dir enorm viel unnötigen Code der auch kaum lesbar ist!

Und so ein Code:
Java:
               Class<? extends Object> c1 = shapes [i].getClass();
               if (c1.isInstance(new Rectangle()))
                   d.shapes[i] = ((Rectangle) shapes[i]).clone();

ist doch kürzer etwas wie:
Java:
               if (shapes[i] instanceof Rectangle)
                   d.shapes[i] = ((Rectangle) shapes[i]).clone();

Und ab Java 14 (als Preview) bzw. 16 (final):
Java:
               if (shapes[i] instanceof Rectangle rectangle)
                   d.shapes[i] = rectangle.clone();

Edit: Zum einen fehlte einmal code-Tags und ich hatte eine Zeile vergessen heraus zu löschen.
 
C

clash

Mitglied
Ich will ihn nicht gehen, ich muss ihn gehen. Ich habe damit keine Wahl, was ich nutze. Ich habe diese Vorgaben und muss innerhalb dieser bleiben.
 
kneitzel

kneitzel

Top Contributor
Dann wäre aber wie gesagt der Aufbau ein anderer. Hintergrund ist, dass Du keine Instanz erzeugen kannst. Stell Dir vor, ich leite noch eine Klasse von Rectangle ab. Dann erzeugt dein clone() eine Instanz von Rectangle. Das ist so natürlich nicht korrekt, denn das clone() auf meiner Klasse soll natürlich auch eine Instanz von meiner Klasse haben. Rectangle kann aber Initialisierungen benötigen, auf die ich keinen Zugriff habe (weil private).

Der Aufbau ist eigentlich einfach: Es wird immer ein super.clone() aufgerufen. (Am Ende landet es in Object, welches dann die korrekte Instanz erzeugt und zurück gibt).
Die Rückgabe kannst Du zu Deiner Klasse casten um dann alles zu machen, was Du machen willst / musst.

Also so aus dem Kopf wäre das dann also etwas wie:
Java:
public Object clone()  throws CloneNotSupportedException {
    Rectangle result = (Rectangle) super.clone();
    result.setPosition(getPosition());
    result.setSize(getSize());
    result.setColors(getColors());
    return result;
}

Dazu findet sich aber auch einiges über Google.
 
C

clash

Mitglied
Dann wäre aber wie gesagt der Aufbau ein anderer. Hintergrund ist, dass Du keine Instanz erzeugen kannst. Stell Dir vor, ich leite noch eine Klasse von Rectangle ab. Dann erzeugt dein clone() eine Instanz von Rectangle. Das ist so natürlich nicht korrekt, denn das clone() auf meiner Klasse soll natürlich auch eine Instanz von meiner Klasse haben. Rectangle kann aber Initialisierungen benötigen, auf die ich keinen Zugriff habe (weil private).
Also ich sage nicht, dass ich den Code von Clone verstehe. Wir haben den so bekommen.
Die Rückgabe kannst Du zu Deiner Klasse casten um dann alles zu machen, was Du machen willst / musst.
Hm das verstehe ich so noch nicht. Also wenn ich sagen wir Ellipse und Rectangle habe, dann schreibe ich einen Code, wie du oben geschrieben hast, für Ellipse und Rectangle und ich ändere nur das vor super.clone()?
 
kneitzel

kneitzel

Top Contributor
Also ich sage nicht, dass ich den Code von Clone verstehe. Wir haben den so bekommen.
Ok, wenn das so vorgegeben wurde, dann schlucken wir einfach einmal die bittere Pille, dass es gewollt ist.

Die Tatsache, dass dies Probleme bereiten kann, wenn man weitere Klassen davon ableitet, können wir dann einfach so akzeptieren und ignorieren, da die Aufgabe sowas (hoffentlich) nicht weiter vorsehen wird.

An der Stelle tut es mir leid, dass ich Dich etwas verwirrt habe. Ich will es noch einmal etwas erläutern - wenn Du es nicht ganz verstehst, ist das nicht schlimm - du kannst es dann (für diese Aufgabe und vermutlich auch für die weiteren Unterrichtseinheiten) auch ignorieren. Aber natürlich erläutern wir es Dir auch gerne, bis Du es verstanden hast.

Das Problem mit Deiner Implementation / der vorgegebenen Implementation:

Java:
public class SuperClass {
    private int hiddenState;
    
    public Object clone() {
        SuperClass result = new SuperClass();
        result.hiddenState = hiddenState;
        return result;
    }
}

Soweit so gut. Das funktioniert nun.

Aber nun erstellen wir noch eine Klasse:
Java:
public class ChildClass extends SuperClass {
    public Object clone() {
        ChildClass result = new ChildClass();
        // Wie setzen wir das hiddenState, das ja in ChildClass auch enthalten ist?
        return result;
    }
}

An den HiddenState kommen wir nicht dran - der ist private. Clone aufrufen (mit super.clone()) bringt nichts, denn das liefert ja dann eine SuperClass Instanz. Die hilft uns aber leider auch nicht ....

Daher gibt es dafür ein Pattern.
Die Basis von clone() findet sich in Object: https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Object.html#clone()

clone() in Object stellt sicher, dass wirklich eine entsprechende Instanz erzeugt wird. Wenn also clone() von Object von einer SuperClass Instanz aufgerufen wird, dann wird eine SuperClass zurück gegeben. Bei ChildClass wird es eine ChildClass sein.

Somit wäre die Implementation dann so:

Java:
public class SuperClass {
    private int hiddenState;
    
    public Object clone() {
        SuperClass result = (SuperClass) super.clone(); // super wäre hier Object ... Und es kommt mindestens eine SuperClass bei raus. 
        result.hiddenState = hiddenState; // SuperClass kann seinen State setzen ...
        return result;
    }
}

Und das geht dann auch in der ChildClass:
Java:
public class ChildClass extends SuperClass {
    public Object clone() {
        ChildClass result = (ChildClass) super.clone(); // ruft das clone von SuperClass auf. Da dies aber ein ChildClass ist, liefert Object.clone nun eine ChildClass instanz. 
        // hiddenState, das ja in ChildClass auch enthalten ist, wurde nun in super.clone() gesetzt!
        return result;
    }
}

Mit diesem "Trick" funktioniert clone() auch bei Vererbungshierarchien.

Ich hoffe, es war nicht zu unverständlich un ich habe Dich durch meine Aussagen nicht zu sehr verwirrt. Da die Vorgaben aber ganz deutlich gegeben wurden, hast Du Dich natürlich an die Vorgaben zu halten. Unabhängig, ob hier jetzt diverse Leute in "die Tischplatte beißen" oder so :)
 
C

clash

Mitglied
Okay, vielen dank. Das habe ich soweit verstanden. Ich hab jetzt auch das Problem soweit in den Griff bekommen, dass es funktioniert. Ein neues Problem entsteht jetzt, wenn ich das auf eine ArrayList anwenden muss. Also nach meiner Recherche komme jetzt ohne "tiefes clonen" nicht weiter. Habe ich das so richtig verstanden? Dein Beispiel war ja dieses:
Java:
public Object clone()  throws CloneNotSupportedException {
    Rectangle result = (Rectangle) super.clone();
    result.setPosition(getPosition());
    result.setSize(getSize());
    result.setColors(getColors());
    return result;
}
Das setze ich in meine Klasse Rectangle und dann in die von Ellipse (angepasst) ein, oder? Wenn ich das dann gemacht habe, wie komme ich dann von der Klasse Drawing auf die Clone Methode in Rectangle? Irgendwie erschließt sich mir das nicht ganz. Und ich bekomme immer das Problem, dass mir gesagt wird, dass ich von Object nicht nach Rectangle konvertieren kann. Wenn ich es auf Object ändere kommt die Fehlermeldung mit der unbehandelten Exception.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
lougoldi Verkettung von Methoden und Konstruktoren Java Basics - Anfänger-Themen 4
J Konstruktoren und Grafik Java Basics - Anfänger-Themen 3
A Cannot find symbol mit Konstruktoren Java Basics - Anfänger-Themen 27
L Brauche Hilfe beim arbeiten mit Konstruktoren Java Basics - Anfänger-Themen 20
C Objekte und Konstruktoren Java Basics - Anfänger-Themen 2
M Methodenaufrufe im Konstruktoren Java Basics - Anfänger-Themen 31
A Konstruktoren Vererbung Java Basics - Anfänger-Themen 3
W Vererbung, abstract und Konstruktoren Java Basics - Anfänger-Themen 30
M Vererbung Konstruktoren mit festen Werte Java Basics - Anfänger-Themen 2
F Mehrere Konstruktoren? Wofür? Java Basics - Anfänger-Themen 21
J Konstruktoren in Initialisierungsblöcke Java Basics - Anfänger-Themen 6
T Konstruktoren Java Basics - Anfänger-Themen 25
D was bedeutet this. bei Konstruktoren? Java Basics - Anfänger-Themen 4
C Konstruktoren und Vererbung Java Basics - Anfänger-Themen 2
C Die Klasse Menge mit Konstruktoren und einfachen Methoden Java Basics - Anfänger-Themen 5
F Mehrere Konstruktoren Java Basics - Anfänger-Themen 10
G Was ist der Nutzen von generischen Konstruktoren? Java Basics - Anfänger-Themen 4
Q Methoden Konstruktoren anlegen Java Basics - Anfänger-Themen 5
B Objekte in Konstruktoren übergeben Java Basics - Anfänger-Themen 5
D Zähler nicht sichtbar (Thema: Konstruktoren) Java Basics - Anfänger-Themen 2
A Überladen von Konstruktoren Java Basics - Anfänger-Themen 2
V Konstruktoren Java Basics - Anfänger-Themen 15
C Klassen StackOverflow bei erster Nutzung von Klassen/Konstruktoren Java Basics - Anfänger-Themen 9
F Konstruktoren Java Basics - Anfänger-Themen 4
M Erste Schritte Verständnis Problem Konstruktoren Java Basics - Anfänger-Themen 13
Y Klassen, Vererbung, Konstruktoren Java Basics - Anfänger-Themen 13
B Klassen Unterschied Konstruktoren. Java Basics - Anfänger-Themen 3
C Erste Schritte Konstruktoren verstehen Java Basics - Anfänger-Themen 7
W OOP Konstruktoren Erklärung Java Basics - Anfänger-Themen 14
N Abarbeitungsreihenfolge von Konstruktoren Java Basics - Anfänger-Themen 12
O Klassen und Konstruktoren Java Basics - Anfänger-Themen 7
V Konstruktoren -> Funktionsaufrufe Java Basics - Anfänger-Themen 7
Q Konstruktoren und Methoden Java Basics - Anfänger-Themen 2
C Konstruktoren Java Basics - Anfänger-Themen 7
J Konstruktoren Java Basics - Anfänger-Themen 10
M Konstruktoren & Veerbung Java Basics - Anfänger-Themen 6
T Konstruktoren Java Basics - Anfänger-Themen 6
P Enum Attribut in Konstruktoren Java Basics - Anfänger-Themen 10
R Vererbung Konstruktoren nicht erkannt Java Basics - Anfänger-Themen 17
H Klassen, Konstruktoren, Instanzen etc Java Basics - Anfänger-Themen 6
J OOP Konstruktoren, setMethode, getMethode usw. Java Basics - Anfänger-Themen 7
A überladene Konstruktoren Java Basics - Anfänger-Themen 7
L Frage zu Konstruktoren und dem this Operator Java Basics - Anfänger-Themen 16
W 2 Konstruktoren Java Basics - Anfänger-Themen 8
B Vererbung und Konstruktoren Java Basics - Anfänger-Themen 33
N Vererbung von Konstruktoren mit Parametern Java Basics - Anfänger-Themen 7
S Konstruktoren verketten Java Basics - Anfänger-Themen 6
A Konstruktoren sollen sich gegenseitig aufrufen Java Basics - Anfänger-Themen 10
B Konstruktoren Sichtbarkeit Java Basics - Anfänger-Themen 2
K Kann man Private-Konstruktoren doch aurufen? Java Basics - Anfänger-Themen 8
E Konstruktoren und Methoden Java Basics - Anfänger-Themen 10
E OOP individual + standard-Konstruktoren Java Basics - Anfänger-Themen 9
S Konstruktoren? Java Basics - Anfänger-Themen 5
K Konstruktoren Java Basics - Anfänger-Themen 13
H Konstruktoren – super! Java Basics - Anfänger-Themen 3
L Geschachtelte Konstruktoren Java Basics - Anfänger-Themen 4
hdi Kleine Design/Convention Frage zu Konstruktoren Java Basics - Anfänger-Themen 4
J Vererbung und Konstruktoren Java Basics - Anfänger-Themen 14
J Problem mit Konstruktoren Java Basics - Anfänger-Themen 2
G Überladen von Konstruktoren mit unterschiedlichen Datentypen Java Basics - Anfänger-Themen 4
H Befehl mit Konstruktoren Java Basics - Anfänger-Themen 2
L Konstruktoren bei Vererbung Java Basics - Anfänger-Themen 13
Z wie kann ich überladene Konstruktoren "umleiten"? Java Basics - Anfänger-Themen 11
D Blöde(?) Frage zu Konstruktoren und set-Methoden Java Basics - Anfänger-Themen 3
G Interface und Konstruktoren Java Basics - Anfänger-Themen 3
G Frage zu Konstruktoren Java Basics - Anfänger-Themen 12
G Verständnisfrage zu Konstruktoren Java Basics - Anfänger-Themen 5
G Konstruktoren Java Basics - Anfänger-Themen 9
A Konstruktoren überladen Java Basics - Anfänger-Themen 9
H Konstruktoren + Hilfe Java Basics - Anfänger-Themen 12
H Konstruktoren werden nie geerbt Java Basics - Anfänger-Themen 3
O Vor-/Nachteile/Unterschiede von Konstruktoren und Methoden Java Basics - Anfänger-Themen 3
Bierhumpen 2 Konstruktoren Java Basics - Anfänger-Themen 15
T mehrere Konstruktoren für eine Klasse Java Basics - Anfänger-Themen 7
J Instantvariablen und Konstruktoren Java Basics - Anfänger-Themen 2
Y Vererben - Konstruktoren Java Basics - Anfänger-Themen 2
Z übergabe von string[] an konstruktoren oder methoden Java Basics - Anfänger-Themen 3
L Klassen, Vererbung und Konstruktoren Java Basics - Anfänger-Themen 10
S Frage zu Konstruktoren Java Basics - Anfänger-Themen 7
G Problem mit Gültigkeit von Variabeln und Konstruktoren Java Basics - Anfänger-Themen 4
C Konstruktoren Java Basics - Anfänger-Themen 4
G Konstruktoren (was, wozu, wieso, warum) Java Basics - Anfänger-Themen 4
F Auf Variablen eines Konstruktors zugreifen Java Basics - Anfänger-Themen 4
N Variable aus anderen Variablen in statischer Klasse berechnen/abspeichern? Java Basics - Anfänger-Themen 4
M Wie kann ich bei int-Variablen im exception handler auf bestimmte Strings reagieren? Java Basics - Anfänger-Themen 5
M Warum dürfen Objekte einer Klasse auf statische Variablen dieser Klasse referenzieren? Java Basics - Anfänger-Themen 10
B Variablen Variablen übertragen ohne Klassen Java Basics - Anfänger-Themen 5
B Methoden Methoden haben kein Zugriff auf variablen Java Basics - Anfänger-Themen 4
T Java Swing - Dreieck zeichnen mit verschiedenen Variablen Java Basics - Anfänger-Themen 8
Arif Vererbung Methodenvererbung mit finalen Variablen Java Basics - Anfänger-Themen 1
M Wie kann ich ein Objekt erstellen, wenn sich der Klassenname in einer Variablen befindet? Java Basics - Anfänger-Themen 10
S Variablen Variablen in einer Schleife erstellen lassen Java Basics - Anfänger-Themen 11
J Ich brauche Hilfe bei einem Code (Variablen speichern) Java Basics - Anfänger-Themen 29
F Variablen Werte einer Klasse überschreiben Java Basics - Anfänger-Themen 4
N Speichern von Werten in Variablen nach Schließen des Programms Java Basics - Anfänger-Themen 3
J Frage dazu Variablen klassenübergreifend zu verändern Java Basics - Anfänger-Themen 22
M Java Instanz-Variablen ? Java Basics - Anfänger-Themen 3
B Variablen von Methoden übertragen Java Basics - Anfänger-Themen 2
M Variablen umbenennen Java Basics - Anfänger-Themen 1
T Körper Brechnung - Lokale Variablen in Methoden übergeben Java Basics - Anfänger-Themen 10

Ähnliche Java Themen


Oben