Problem mit Klassenverständnis und Button

[mxm_d1]

Hallo, ich schreibe momentan an einem kleinem Programm das zuerst nichts weiter
tun soll als die eingegebene Körper Größe in cm, in m ausgeben soll ( kein sehr ernstzunehmendes Programm )
als zweiten schritt würde ich es cool finden wenn das Ergebnis in einem neuem kleinen Fenster aufgeht.

Mein Problem ist, das ich nicht ganz verstehe was alles in eine Klasse rein gehört wenn ich beispielsweise nur die Größe
ausgeben will, brauch ich immer ein Konstruktor ? wann brauch ich die seit Methode usw.

mein zweites Problem ist, das ich es nicht schaffe den Button berechnen funktionsfähig zu machen.



[CODE lang="java" title="Gui"]import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.awt.Color;



public class Gui extends JFrame {


JButton berechnen, abbruch;
JTextField eingabe;

public Gui() {

setLayout(new GridLayout(3, 1 ));
setTitle("Größen Rechner");



// Zeile 1

JPanel jp_z1 = new JPanel();

JLabel lb_Ueberschrift = new JLabel("Berechnen sie ihre Größe");
lb_Ueberschrift.setFont( new Font("COURIER", Font.BOLD+Font.ITALIC,30));
jp_z1.add(lb_Ueberschrift);
add(jp_z1);


// Zeile 2

JPanel jp_z2 = new JPanel();

JLabel lb_info = new JLabel("Geben sie ihr Größe in cm an: ");
jp_z2.add(lb_info);


eingabe = new JTextField(10);
jp_z2.add(eingabe);

eingabe.addActionListener(new f_Berechnen());

add(jp_z2);




JPanel jp_z3 = new JPanel();

berechnen = new JButton("Berechnen");
jp_z3.add(berechnen);


abbruch = new JButton("Abbrechen");
jp_z3.add(abbruch);

abbruch.addActionListener(new f_abbrechen());

add(jp_z3);

pack();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);





}

// Abbrech Button Funktion

class f_abbrechen implements ActionListener{
@Override
public void actionPerformed(ActionEvent e){


System.exit(0);


}
}

// Berechnen Funktion

class f_Berechnen implements ActionListener{

@Override
public void actionPerformed(ActionEvent e) {



if (berechnen.isEnabled()){


new GrEingabe().setGr(Integer.parseInt(eingabe.getText()));
}





}
}











public static void main(String[] args) {
new Gui();
}

}[/CODE]






[CODE lang="java" title="GrEingabe"]public class GrEingabe {

private int gr;

public void setGr(int gr) {

this.gr = gr;
System.out.println(gr);
}




}
[/CODE]

 

[LouCyphre]

Mein Problem ist, das ich nicht ganz verstehe was alles in eine Klasse

In eine Klasse sollten alle Daten rein die zusammen gehören. Wenn du jetzt eine Klasse Mensch hast, dann sollten da alle Attribute rein die ein Mensch hat und explizit natürlich nur die die du auch für dein Programm brauchst. Also eine Klasse sollte Daten bündeln/kapseln.

Du solltest auf deine Bezeichner achten, die sind sehr unleserlich.

brauch ich immer ein Konstruktor ?

nicht zwingend.
Er dient zur Initialisiereung der Instanz.

Und weil ich es hier oft gelesen habe und es auch stimmt. Man sollte nicht mit GUIs anfangen, wenn die Grundlagen nicht sitzen.
Ich weiß ich bin auch so jemand der dann ein Erfolgserlebnis will und nicht mit öden Konsolen Programmen rummacht, aber es wird schnell zu komplex wenn du die Grundlagen nicht raffst.

 

[kneitzel]

Also erst einmal möchte ich @LouCyphre Recht geben, wenn er anrät:

Man sollte nicht mit GUIs anfangen, wenn die Grundlagen nicht sitzen.

Man sollte immer ein Thema nach dem anderen angehen und gerade bei grafischen Oberflächen kommen einige Konzepte mit rein - so man es richtig machen will.

Aber kommen wir zurück zu dem generellen Problem:
Ob und was es als Konstruktor gibt, kann man nicht so pauschal sagen. Ein wichtiges Kriterium ist dabei, dass nach der Erstellung die Instanz in einem sinnvollen Zustand sein sollte. Dazu gehört dann eine Initialisierung. Dabei ist es sinnvoll, dass z.B. alle wichtigen Daten, ohne die eben die Instanz keinen Sinn macht, angegeben worden sind. Ein Student hat immer einen Namen. Es macht also wenig Sinn, einen Studenten zu erzeugen ohne den Namen zu übergeben.
Aber selbst so eine pauschale Aussage gilt nicht generell. Es kann gute Gründe geben, dass z.B. ein Student ohne Name angelegt wird. (z.B. weil Studenten geladen werden und dabei wird immer erst ein Student ohne Daten angelegt um dann alle Attribute nacheinander zu setzen.)

Diese Thematik würde ich aber jetzt an dieser Stelle einfach einmal verlassen und mehr zu dem Finden von Klassen und deren Eigenschaften zu kommen.

Dabei ist aus meiner Sicht wichtig, die "natürlichen Grenzen" zu erkennen. Das kann dann z.B. eine Größe sein.

Aber es muss an einer Stelle immer eine Entscheidung geben, ob es eine eigene Klasse werden soll oder ob es ein normaler Typ auch tut.

Und das kann man relativ einfach fest machen:
- Besteht die Klasse aus mehreren Werten, die zusammen gehören?
- Gibt es ein spezifisches Verhalten?
Wenn beides mit Nein beantwortet wird, dann braucht man keine eigene Klasse,

Beispiel:

public class Personalausweis {
    // ....
    private int groesseInCm;
    // ...
}

Die Körpergröße ist nur ein Wert. Da steht dann auf dem Personalausweis: 182 und fertig. Da wird nie mehr erwartet. Damit wird auch nichts gemacht.

Die eigene Klasse wird wichtig, wenn man mehrere Werte hat, die zusammen gehören. Also z.B. bauen wir eine Klasse, die eine Länge beinhalten kann. Die Länge besteht auf einem Wert und einer Einheit. Also sowas wie 1,82 und m
Da dies zusammen gehört, hat man dann eine Klasse:

public class Laenge {
    private double wert;
    private Einheit einheit;
    // ...
}

Und Einheit wäre dann etwas, das die Einheit wiederspiegeln kann. Evtl. mit weiteren Details wie eine Gewichtung. Bei mm ist die Gewichtung 1, bei m ist die Gewichtung 1.000 und so ... -> Kann kann immer umrechnen.

Spezifisches Verhalten wäre, dass Du auf dem Wert Dinge aufrufen können willst.

public class Groesse {
    private int groesseInCm;
    
    public double getGroesseInM() {
        return groesseInCm / 100.0;
    }

    public Groesse groesseVonStapel(Groesse andereGroesse) {
        Groesse ergebnis = new Groesse();
        ergebnis.groesseInCm = groesseInCm + andereGroesse.groesseInCm;
        return ergebnis;
    }
}

Zu dem Gewicht gehören Methoden und die Methoden muss man natürlich irgendwo unter bringen -> Klasse für Gewicht.

Das sind einfach nur ein paar Dinge, die man bei der Erstellung von Klassen bedenken könnte. Groesse als eigene Klasse kann also Sinn machen, da Du dort dann Umrechnungen machen kannst. Du kannst aber auch noch etwas mehr Abstrahieren, denn streng genommen rechnest Du ja keine Größen um sondern es geht um Einheiten. Die Umrechnung ist ja gleich, egal ob Du Größe, Abstand, Länge, Breite, ... umrechnest.

Das war der Ausflug zu der Erstellung von Klassen - fehlt noch die Oberfläche:

Die Oberfläche solltest Du unabhängig von der Logik haben. Du beschreibst in der Klasse für die Oberfläche lediglich die Oberfläche. Sprich; Du hast eine Klasse Gui. Die kennt keine Logik für Größen.
- Die Gui kann aber etwas haben, das sich "Model" nennt. Das sind einfach ein paar Instanzen, die Du benötigst in deinem Fenster. Das kann z.B. eine Instanz von Größe sein.
- Weiterhin hat die Gui etwas, das oft als "Binding" bezeichnet wird. Es gibt ein Zusammenhang zwischen Elementen er Oberfläche und den Werten im Model. Bei Dir kann es also sein, dass Du ein Textfeld hast, in dem der Wert der Groeße angezeigt wird. Und Du hast dann ggf. Code, der den Wert aus dem Model lesen und anzeigen kann als auch umgekehrt.
- Wenn Du einen Knopf hast, dann führt der Code aus. Das ist dann in der Regel einfach ein Aufruf auf dem Model.

Das wäre eine erste Aufspaltung. Aber oft ist hinter einem Knopfdruck mehr als nur ein Aufruf im Model. Das ist dann der Moment, wo meist noch eine weitere Klasse dazu kommt: Der Controller. Der bietet dann gewisse Funktionalität an:
- Laden / Verändern des Models
- Aktionen auf dem Model.
Die Code der Gui Klasse beschränkt sich dann wirklich zu 100% auf:
- Erstellung der Oberfläche (Also JFrame erzeugen mit den ganzen Controls)
- Daten vom Model in die Controls übertragen
- Daten der Controls in das Model übertragen
- Aktionen im Controller aufrufen.

Das als schneller Überblick zu den GUIs.

 

[mxm_d1]

In eine Klasse sollten alle Daten rein die zusammen gehören. Wenn du jetzt eine Klasse Mensch hast, dann sollten da alle Attribute rein die ein Mensch hat und explizit natürlich nur die die du auch für dein Programm brauchst. Also eine Klasse sollte Daten bündeln/kapseln.

Du solltest auf deine Bezeichner achten, die sind sehr unleserlich.


nicht zwingend.
Er dient zur Initialisiereung der Instanz.

Und weil ich es hier oft gelesen habe und es auch stimmt. Man sollte nicht mit GUIs anfangen, wenn die Grundlagen nicht sitzen.
Ich weiß ich bin auch so jemand der dann ein Erfolgserlebnis will und nicht mit öden Konsolen Programmen rummacht, aber es wird schnell zu komplex wenn du die Grundlagen nicht raffst.

Die Sache ist die, das ich für die Schule und für Prüfungen auch Gui können muss, tue mir mit programmieren schon etwas schwer, jedoch fange ich an mehr interesse zu entwickeln.
Guis haben mir etwas mehr motivation gegeben mehr sinn dahinter zu sehen

 

[mihe7]

Die Sache ist die, das ich für die Schule und für Prüfungen auch Gui können muss

Was jetzt an

Mein Problem ist, das ich nicht ganz verstehe was alles in eine Klasse rein gehört wenn ich beispielsweise nur die Größe
ausgeben will, brauch ich immer ein Konstruktor ? wann brauch ich die seit Methode usw.

nichts ändert, oder?

 

[LouCyphre]

Die Sache ist die, das ich für die Schule und für Prüfungen auch Gui können muss, tue mir mit programmieren schon etwas schwer, jedoch fange ich an mehr interesse zu entwickeln.
Guis haben mir etwas mehr motivation gegeben mehr sinn dahinter zu sehen

Das kann ich voll verstehen. Aber leider ist es auch so, dass die Frustration dann nicht abnimmt, wenn plötzlich zu viele Themen auf einen einprasseln. Deswegen kann ich nur raten, über die Bemerkungen der erfahrenen Mitglieder hier nachzudenken (damit mein ich mich übrigens nicht).

Und wenn du dann in der Prüfung bist, musst du ja sicher auch Konzepte wie Klassen beherrschen.
Versuch dir vorerst für was Kleines das Konzept hinter Klassen zu verstehen, da gehören auch Sachen wie Konstruktoren mit rein.

Keine Ahung sowas wie Klasse Mensch ist ein oft benutztes Beispiel. Dann gibst du Name aus und Größe, Geschlecht etc. Dann kann man auch verschiedene Dinge automatisch mitlernen. Datentypen, Enums etc. . Das macht auf jeden Fall auch Spaß.

Wenn dir Kneitzels Post nicht ausreicht, gibts auch zig Quellen im Netz, auch Videos( YT etc.)

Und wenn du das dann besser drin hast, kannst du ja auch mit einer kleinen GUI weiter machen, wo es auch zig Tutorials gibt.

Aber versuch auf jeden Fall alles an Code in Beispielen was du nicht verstehst herzuleiten. Da kannst du auch hier fragen, dir hilft auf jeden Fall jemand weiter.

 

[M.L.]

Zwecks eines oder mehrerer Erfolgserlebnisse kann man sich die Artikel unter http://www.java2s.com/Tutorials/Java/Java_Swing/index.htm betrachten und selbstständig modifizieren. Die genannten Grundlagen (-Interfaces, wenn hohe Änderungsraten zu erwarten sind, -Konstruktoren, ...) setzt das nicht ausser Kraft.

 

[mxm_d1]

danke für die Antworten, waren natürlich sehr hilfreich. Aber leider habe ich keine Hilfe für mein eigentliches anliegen bekommen :/

 

[mihe7]

Aber leider habe ich keine Hilfe für mein eigentliches anliegen bekommen :/

Du musst den ActionListener dem Button hinzufügen.