Garf will Java-Programmierer werden - und schafft es nicht. Hilfe!

[GarfieldMcSnoopy]

Ja-ha, da hattet ihr recht: Das war wohl nur zum Verdeutlichen Dafür wird's langsam knüppelhart: Ich bin jetzt bei den Objekten, Methoden und Argumenten gelandet Daraufhin ist mein Kopf explodiert. Ich versteh kaum was, dabei ist das Zeug für Leute ohne jede Programmiererfahrung geschrieben. Aber da ihr ja hoffentlich nichts besseres zu tun habt, als einem Volldämlak die einfachsten Einfachheite zu erklären (vorzugsweise in Babysprache) wird auch diese Hürde genommen! Hoffe ich...

So, ich will ne Kreisberechnung, die auf die Methoden einer eigenen Klasse zugreift. Gesagt, getan:

import javax.swing.JOptionPane;

public class Kreistest {

   
    public static void main(String[] args) {
    // mit r=5 : A 78.54, U 31.416

    String getr;
    double getradius;
    
    getr = JOptionPane.showInputDialog("Bitte geben Sie den Radius ein: ");
    getradius = Double.parseDouble(getr);
            
    Kreis b = new Kreis();
    b.radius = getradius;
    b.umf(b.radius);
    b.fla(getradius); 
    b.ausgabe();
    
    
    }

} 

Und natürlich die eigene erstellte Klasse ():

public class Kreis {

   double radius, umfang, flaeche; 
        
    
   double umf(double umfang) {
       umfang = ((radius * 2) * Math.PI);
       System.out.print(" " + umfang + " ");
       return umfang;
     }
   
   void fla(double flaeche) {
       flaeche = ((radius * radius) * Math.PI); 
       System.out.print(" " + flaeche + " ");
   }
   
  void ausgabe() {
       System.out.println("Der Radius beträgt " + radius + ".");
       System.out.println("Der Umfang beträgt " + umfang + "."); 
       System.out.println("Die Fläche beträgt " + flaeche + ".");
   }


    Kreis() {
       radius = 0;
     }
} 

Die Aufgabe an sich ist ja richtig gelöst, zumindest wirft die Konsole die richtigen Ergebnisse aus. Aber ich hab Fragen und kapier so einiges nicht

1. Die Methode ausgabe klappt nicht. Liegt das an der Lebensdauer? Wie müsste ich das lösen? Generell: Warum klappt der return-Befehl bei der Methode umf nicht? Bzw. wie muss ich den umsetzen? (wenn ich umfang zurückliefern möchte, kennt das eigentliche Programm aber laut Eclipse die Variable nicht)

2. Ihr seid sicher von meinem Konstruktor begeistert, der den radius auf 0 setzt. Aber: Brauch ich den hier? Für was? Hab ich den richtig eingesetzt?

3. Das Buch schwafelt seitenweise vom Überladen. Fühl mich schon ganz überladen Welch Wortwitz! Jedenfalls: Ist das für irgendwas wichtig? Oder kann ich das einfach ignorieren?

Und - zu guter viert -

4. Ich hab im Programm die Zeile b.radius = getradius; Wenn ich sie rausnehme, geht nix mehr. Wenn ich sie drinlasse, macht es aber keinen Unterschied, ob ich als Parameter b.radius oder getradius nehme (b.umf(b.radius); oder b.fla(getradius); ) Warum? Und warum muss ich b.radius trotzdem gleich getradius setzen und kann nicht einfach gleich getradius verwenden?

Ich hoffe, ihr habt noch Geduld mit einem alten Noob

[[VK]]

Sicher? eigentlich müsste es bei N<0 genauso funktionieren.

Hätte ich jetzt auch gesagt, aber es kann sein das er meinte das es nicht ausgeführt wird wenn N<0 ist

[[VK]]

Ja-ha, da hattet ihr recht: Das war wohl nur zum Verdeutlichen Dafür wird's langsam knüppelhart: Ich bin jetzt bei den Objekten, Methoden und Argumenten gelandet Daraufhin ist mein Kopf explodiert. Ich versteh kaum was, dabei ist das Zeug für Leute ohne jede Programmiererfahrung geschrieben. Aber da ihr ja hoffentlich nichts besseres zu tun habt, als einem Volldämlak die einfachsten Einfachheite zu erklären (vorzugsweise in Babysprache) wird auch diese Hürde genommen! Hoffe ich...

So, ich will ne Kreisberechnung, die auf die Methoden einer eigenen Klasse zugreift. Gesagt, getan:

import javax.swing.JOptionPane;

public class Kreistest {

   
    public static void main(String[] args) {
    // mit r=5 : A 78.54, U 31.416

    String getr;
    double getradius;
    
    getr = JOptionPane.showInputDialog("Bitte geben Sie den Radius ein: ");
    getradius = Double.parseDouble(getr);
            
    Kreis b = new Kreis();
    b.radius = getradius;
    b.umf(b.radius);
    b.fla(getradius); 
    b.ausgabe();
    
    
    }

} 

Und natürlich die eigene erstellte Klasse ():

public class Kreis {

   double radius, umfang, flaeche; 
        
    
   double umf(double umfang) {
       umfang = ((radius * 2) * Math.PI);
       System.out.print(" " + umfang + " ");
       return umfang;
     }
   
   void fla(double flaeche) {
       flaeche = ((radius * radius) * Math.PI); 
       System.out.print(" " + flaeche + " ");
   }
   
  void ausgabe() {
       System.out.println("Der Radius beträgt " + radius + ".");
       System.out.println("Der Umfang beträgt " + umfang + "."); 
       System.out.println("Die Fläche beträgt " + flaeche + ".");
   }


    Kreis() {
       radius = 0;
     }
} 

Die Aufgabe an sich ist ja richtig gelöst, zumindest wirft die Konsole die richtigen Ergebnisse aus. Aber ich hab Fragen und kapier so einiges nicht

1. Die Methode ausgabe klappt nicht. Liegt das an der Lebensdauer? Wie müsste ich das lösen? Generell: Warum klappt der return-Befehl bei der Methode umf nicht? Bzw. wie muss ich den umsetzen? (wenn ich umfang zurückliefern möchte, kennt das eigentliche Programm aber laut Eclipse die Variable nicht)

2. Ihr seid sicher von meinem Konstruktor begeistert, der den radius auf 0 setzt. Aber: Brauch ich den hier? Für was? Hab ich den richtig eingesetzt?

3. Das Buch schwafelt seitenweise vom Überladen. Fühl mich schon ganz überladen Welch Wortwitz! Jedenfalls: Ist das für irgendwas wichtig? Oder kann ich das einfach ignorieren?

Und - zu guter viert -

4. Ich hab im Programm die Zeile b.radius = getradius; Wenn ich sie rausnehme, geht nix mehr. Wenn ich sie drinlasse, macht es aber keinen Unterschied, ob ich als Parameter b.radius oder getradius nehme (b.umf(b.radius); oder b.fla(getradius); ) Warum? Und warum muss ich b.radius trotzdem gleich getradius setzen und kann nicht einfach gleich getradius verwenden?

Ich hoffe, ihr habt noch Geduld mit einem alten Noob

Was bei dir glaub überall falsch ist:

this.umfang greift auf das Attribut in der Klasse zu. umfang alleine auf die lokale Variable die du grad in der Methode definiert hast...

dadurch spiecherst du nie in der klassenvariable

[Peregrin_Tooc]

Ja-ha, da hattet ihr recht: Das war wohl nur zum Verdeutlichen Dafür wird's langsam knüppelhart: Ich bin jetzt bei den Objekten, Methoden und Argumenten gelandet Daraufhin ist mein Kopf explodiert. Ich versteh kaum was, dabei ist das Zeug für Leute ohne jede Programmiererfahrung geschrieben. Aber da ihr ja hoffentlich nichts besseres zu tun habt, als einem Volldämlak die einfachsten Einfachheite zu erklären (vorzugsweise in Babysprache) wird auch diese Hürde genommen! Hoffe ich...

So, ich will ne Kreisberechnung, die auf die Methoden einer eigenen Klasse zugreift. Gesagt, getan:

import javax.swing.JOptionPane;

public class Kreistest {

   
    public static void main(String[] args) {
    // mit r=5 : A 78.54, U 31.416

    String getr;
    double getradius;
    
    getr = JOptionPane.showInputDialog("Bitte geben Sie den Radius ein: ");
    getradius = Double.parseDouble(getr);
            
    Kreis b = new Kreis();
    b.radius = getradius;
    b.umf(b.radius);
    b.fla(getradius); 
    b.ausgabe();
    
    
    }

} 

Und natürlich die eigene erstellte Klasse ():

public class Kreis {

   double radius, umfang, flaeche; 
        
    
   double umf(double umfang) { 
//das ergibt keinen Sinn: Der Umfang berechnet sich aus dem Radius, der ja bei jedem Kreis bekannt ist (er ist 0, wenn er nicht auf einen anderen Wert gesetzt wird, dafür sorgt dein Konstruktor
       umfang = ((radius * 2) * Math.PI);
       System.out.print(" " + umfang + " ");
       return umfang; // das hatte VK ja schon erklärt: Du hast hier einen lokalen Parameter umfang und ein Objektattribut Umfang, auf das Du mit this.umfang referenzieren kannst
     }
   
   void fla(double flaeche) { //hier genau das selbe wie oben. Außerdem: eine void Methode, die die Fläche berechnet und ausgibt? Das ist ... unschön. 
       flaeche = ((radius * radius) * Math.PI); //auch hier: das Attribut bekommst Du mit this.flaeche. Grundsätzlich ist code sehr viel besser lesbar, wenn man alle Objektattribute immer mit this aufruft
       System.out.print(" " + flaeche + " ");
   }
   
  void ausgabe() {
       System.out.println("Der Radius beträgt " + radius + ".");
       System.out.println("Der Umfang beträgt " + umfang + "."); 
       System.out.println("Die Fläche beträgt " + flaeche + ".");
   }

// die Methode macht nichts, weil umfang und flaeche nie befüllt werden


    Kreis() {
       radius = 0;
     }
} 

Die Aufgabe an sich ist ja richtig gelöst, zumindest wirft die Konsole die richtigen Ergebnisse aus. Aber ich hab Fragen und kapier so einiges nicht

1. Die Methode ausgabe klappt nicht. Liegt das an der Lebensdauer? Wie müsste ich das lösen? Generell: Warum klappt der return-Befehl bei der Methode umf nicht? Bzw. wie muss ich den umsetzen? (wenn ich umfang zurückliefern möchte, kennt das eigentliche Programm aber laut Eclipse die Variable nicht)

2. Ihr seid sicher von meinem Konstruktor begeistert, der den radius auf 0 setzt. Aber: Brauch ich den hier? Für was? Hab ich den richtig eingesetzt?
den brauchst Du nicht. Viel schöner wäre, den Kreisradius dem Konstruktor als Parameter mitzugeben...
3. Das Buch schwafelt seitenweise vom Überladen. Fühl mich schon ganz überladen Welch Wortwitz! Jedenfalls: Ist das für irgendwas wichtig? Oder kann ich das einfach ignorieren?
überladen von Methoden: Das bedeutet schlicht nur, dass zwei verschiedene Methoden gleich heißen können, solange sie andere Parameter erwarten oder andere Rückgabewerte haben - z.B. kann die Klasse Kreis eine statische Methode "flaeche" haben, die man mit dem Radius füttert und die dann die Fläche ausgibt und eine Instanzmethode "Fläche", die die Fläche des Kreisobjektes, das sie ruft zurückgibt.
Und - zu guter viert -

4. Ich hab im Programm die Zeile b.radius = getradius; Wenn ich sie rausnehme, geht nix mehr. Wenn ich sie drinlasse, macht es aber keinen Unterschied, ob ich als Parameter b.radius oder getradius nehme (b.umf(b.radius); oder b.fla(getradius); ) Warum? Und warum muss ich b.radius trotzdem gleich getradius setzen und kann nicht einfach gleich getradius verwenden?
getradius und b.radius haben den gleichen Wert, daher macht es keinen Unterschied welche der beiden Variablen Du als Parameter übergibst, aber die Zeile

 b.radius = getraius

sorgt dafür, dass der Kreisradius auch befüllt wird
Ich hoffe, ihr habt noch Geduld mit einem alten Noob

Ich hab mal den Quellcode kommentiert

[[VK]]

Ich hab mal den Quellcode kommentiert

Schau mal seinen obigen Code in der Main an. Er hat zwar "richtig" Programmiert aber zbs das Geheimnisprinzip verletzt. Dadurch macht die Klasse auch wieder Sinn, und das erklärt warum der Code funktioniert...

[Tzu Iop]

Erstmal zu deinen Fragen:

1. Wie VK schon sagte, du setzt die Objektattribute nicht, sondern lokale Variablen, die durch die Methodenparameter entstanden sind. Deshalb kennt die Methode ausgabe Umfang und Flaeche gar nicht.

2. Den Konstruktor brauchst du auf jeden Fall, denn ohne Konstruktor kein Objekt, allerdings hat erstmal jede Klasse den Default-Konstruktor, wenn man dagegen nichts explizit unternimmt.

3. Kann man nicht ignorieren. Überladen heißt, dass Methoden den gleichen Namen haben, sich aber in den Parametern unterscheiden.

4. Am Beispiel:

double umf(double UMFANG) {
       UMFANG = ((radius * 2) * Math.PI);
       System.out.print(" " + UMFANG + " ");
       return UMFANG;
     } 

Bei Aufruf der Methode mit b.umf(b.radius) wird die Variable UMFANG auf b.radius gesetzt. In der ersten Zeile wird dieser Wert mit ((radius * 2) * Math.PI) überschrieben. Du musst b.radius setzen, damit deine Methode überhaupt was anderes als den Umfang vom Kreis mit Radius 0 berechnet. Was du wolltest ist vermutlich:

double umf(double radius) {
       UMFANG = ((radius * 2) * Math.PI);
       System.out.print(" " + UMFANG + " ");
       return UMFANG;
     } 

Jetzt könntest du auch einfach getradius übergeben.


Allgemein:
Die Aufgabe ist leider überhaupt nicht richtig gelöst. Was am grundsätzlichen Verständnis liegt. Eine Klasse hat Attribute, bei dir sind das radius, umfang und flaeche. Jede Methode einer Klasse hat Zugriff auf alle Attribute. In den runden Klammern hinter dem Methodennamen werden die Parameter übergeben. Die Parameter sind Variablen, die die Methode braucht um Berechnungen durchzuführen, aber nicht andereweitig darauf Zugriff hat. Bei deiner Umfangsfunktion brauchst du zB keine Parameter, weil der Kreis seinen radius schon kennt, Pi aus der Math-Klasse kennt und sonst nichts braucht. Wenn du einer Methode einen Parameter gibts, der genauso wie ein Attribut heißt, dann wird immer der Parameter benutzt, wenn du nicht this.Variablenname schreibst. Das hat was mit Sichtbarkeiten und Überdeckung zu tun.

Also:

public class Kreis {

   double radius, umfang, flaeche; // Grundsaetzlich nicht so gut, dass die Attribute ohne Methodenaufruf aenderbar sind. Wenn dir aber Sichtbarkeiten nichts sagen, dann ignorier das hier.
        
    
   double umf() { // 1. Fehler: Du uebergibts den Umfang in deinem Code gar nicht als Variable sonderen den Radius. 2. Fehler: Du brauchst den Radius gar nicht uebergeben, den hast du ja schon im Objekt gespeichert.
       umfang = ((radius * 2) * Math.PI);
       System.out.print(" " + umfang + " ");
       return umfang;
     }
   
   void fla() { //Fehler wie beim Umfang.
       flaeche = ((radius * radius) * Math.PI); 
       System.out.print(" " + flaeche + " ");
   }
   
  void ausgabe() {
       System.out.println("Der Radius beträgt " + radius + ".");
       System.out.println("Der Umfang beträgt " + umfang + "."); 
       System.out.println("Die Fläche beträgt " + flaeche + ".");
   }


    Kreis() {
       radius = 0; //Koennte man glaube ich auch weglassen, weiß aber nicht ob dann der Compiler meckert.
     }

    Kreis(double radius) { //Man kann die Berechnungen auch alle im Konstruktor durchfuehren. Außerdem ist es ein Beispiel fuer Ueberladen von Methoden.
       this.radius = radius;
       umfang = ((radius * 2) * Math.PI);
       flaeche = ((radius * radius) * Math.PI); 
     }
} 

[v33l3dn3M]

Etwas Verwirrend finde ich getradius - die Variable in der Main-Methode, die den Wert aus der Abfrage erhält und an den Kreis b gibt. Normalerweise wäre getradius eine Methode in der Klasse Kreis, die den Wert der Variable Radius des Objekts, auf das sie angewandt wirdzurückgibt und sonst eigentlich gar nichts tut, sprich:
public double getRadius(){
return this.radius;
}
Solche Methoden ("getter") und Methoden, die den Wert einer Variable ändern/festlegen ("setter") braucht man ziemlich oft (und standardmäßig heißen sie halt getVariable bzw setVariable, deswegen irritiert mich auch der Variablenname) - bis zu dem Punkt, dass man die sich in Entwicklungsumgebungen generieren lassen kann.



... hunterprozentig sicher, dass es doch nicht soooo schlimm ist, eine Variable so zu nennen, bin ich mir allerdings nicht...

[Quietsch]

die Methode macht nichts, weil umfang und flaeche nie befüllt werden

Das stimmt übrigens nicht, weil primitive Datentypen (wobei genauer wäre Klassenvariablen, die primitive Datentypen sind) automatisch initialisiert werden mit 'nem entsprechenden Standardwert. (false für boolean, 0 für int/long/short/byte, 0.0 für double/float, Leerzeichen für char) (Was übrigens nie verwendet werden sollte. Und bei nicht-primitiven Typen 'ne NullPointerException schmeißt)
Nur lokale Variablen, die ein primitiver Datentyp sind, musst du explizit initialisieren.

Warum klappt der return-Befehl bei der Methode umf nicht?

Du meinst schon nicht klappen im Sinne von gibt den "falschen" Wert zurück, oder? (Also das, was PT & VK oben erklärt haben) Ansonsten wäre ich jetzt sehr irritiert.

Das Buch schwafelt seitenweise vom Überladen. Fühl mich schon ganz überladen Welch Wortwitz! Jedenfalls: Ist das für irgendwas wichtig? Oder kann ich das einfach ignorieren?

Das "klassische" Beispiel dafür wäre etwas in der Art einer Klasse, die 2 Konstruktoren hat, die unterschiedliche Parameter übergeben bekommen können, also bspw:

public Kreis(double umfang, double radius){
//bla
}

public Kreis(double umfang){
//blubb
} 

Das bedeutet schlicht nur, dass zwei verschiedene Methoden gleich heißen können, [...]oder andere Rückgabewerte haben

Nein, der Rückgabetyp muss(!) gleich sein, nur die Parameter dürfen unterschiedlich sein. Hat simpel den Grund, dass der Rückgabetyp nirgendwo geprüft wird und dementsprechend anhand davon die Methoden nicht unterschieden werden können. (Wobei, ich glaube, ich hab' dich da gerade falsch verstanden. )

Bin ich lahm.

[Peregrin_Tooc]

Nein, der Rückgabetyp muss(!) gleich sein, nur die Parameter dürfen unterschiedlich sein. Hat simpel den Grund, dass der Rückgabetyp nirgendwo geprüft wird und dementsprechend anhand davon die Methoden nicht unterschieden werden können. (Wobei, ich glaube, ich hab' dich da gerade falsch verstanden. )

Ich hbs ungenau ausgedrückt, Du hast natürlich recht

[[VK]]

Mal was komplett anderes: Gewöhne dir an Namen voll auszuschreiben, und wenn eine Variable aus mehreren Wörtern besteht, schreibe jedes Wort groß, das hilft beim lesen. Guter Code braucht keine Kommentare...

[[VK]]

... hunterprozentig sicher, dass es doch nicht soooo schlimm ist, eine Variable so zu nennen, bin ich mir allerdings nicht...

Macht bei Java glaub nichts aus, weil du die Methoden selber schreiben musst. Könnte aber vielleicht bei irgendwelchen Bibliotheken zu Problemen führen.

[Tzu Iop]

Macht bei Java glaub nichts aus, weil du die Methoden selber schreiben musst. Könnte aber vielleicht bei irgendwelchen Bibliotheken zu Problemen führen.

Da kann von der Synthax her gar nichts passieren, weil ohne runde Klammern am Wortende wird es nicht als Methode erkannt werden. Das gibt die Sprachdefinition nicht her. Wenn man nicht irgendwelche komischen Makros einführt, die vor dem Compilieren nochmal den Quelltext ändern passiert da gar nichts.

Man sollte es aber nicht machen, weil es furchtbar fehleranfällig ist.

[[VK]]

Da kann von der Synthax her gar nichts passieren, weil ohne runde Klammern am Wortende wird es nicht als Methode erkannt werden. Das gibt die Sprachdefinition nicht her. Wenn man nicht irgendwelche komischen Makros einführt, die vor dem Compilieren nochmal den Quelltext ändern passiert da gar nichts.

Man sollte es aber nicht machen, weil es furchtbar fehleranfällig ist.

Achso, es geht um Variablen, dachte es geht um Methoden. Ja dann ist es relativ egal, wenn man da nicht selbst rumhackt...

[GarfieldMcSnoopy]

Natürlich wieder ein großes Danke



Es war mein allersters selbsterschaffenes Objekt, ich stehe noch ganz am Anfang und habe leider kein Talent im Gepäck Hab heute die erste Woche von "ich will programmieren lernen" hinter mir, und da ist mein Problem, dass das Lehrbuch Fachbegriffe einmal abstrakt erklärt und dann verwendet - und ich das Zeugs natürlich noch lange nicht verinnerlicht habe Eure netten Erklärungen helfen mir dann, meine Fehler zu verstehen und nach einigem rumprobieren und ein paarmal drüber schlafen irgendwann den Sinn zu kapieren Ein paar meiner grundlegenden Denkfehler sind mir jetzt schon mal klar, dank euch.

Bei Aufruf der Methode mit b.umf(b.radius) wird die Variable UMFANG auf b.radius gesetzt. In der ersten Zeile wird dieser Wert mit ((radius * 2) * Math.PI) überschrieben. Du musst b.radius setzen, damit deine Methode überhaupt was anderes als den Umfang vom Kreis mit Radius 0 berechnet. Was du wolltest ist vermutlich:

PHP-Code:
double umf(double radius) {
       UMFANG = ((radius * 2) * Math.PI);
       System.out.print(" " + UMFANG + " ");
       return UMFANG;
     } 

Jepp, so klappt's irgendwie besser Aber ne Frage zu "return UMFANG" (ich meine natürlich wirklich, dass ich nicht den gewünschten Wert erhalte ): Wohin returned es den Umfang denn? Ich brauch das return nicht innerhalb der Klasse, da klappt's ja auch ohne. Aber wenn ich dann im eigentlichen Programm UMFANG ausgeben will, muss ich natürlich erst im Hauptprogramm eine double UMFANG definieren (zb double UMFANG = 123. Da wird dann wieder 123 ausgegeben. Wie kann ich ohne großen Aufwand diesen return-Wert im Hauptprogramm abrufen?

So Dinge wie Geheimnisprinzip, Sichtbarkeit etc. hat das Buch noch gar nicht erwähnt Ich kämpfe derzeit wirklich noch mit den Grundlagen

[Tzu Iop]

double radius = 1;
Kreis k = Kreis(radius);
double umfang = k.umf(radius) // in der Variable umfang wird dann das Ergebniss gespeichert
k.umf(radius) //geht auch, dann geht der return-Wert aber direkt verloren. 

Man kann sich das salopper so vorstellen, dass das Programm läuft, dann kommt eine Methode. Das Programm springt also in die Methode, führt diese aus und wenn die Methode zu einem return kommt, dann springt das Programm mit dem return-Wert zurück zur Stelle, wo der Methodenaufruf war und ersetzt den Methodenaufruf durch den return-Wert.