Java Programmierung Klassen?

 - (Programmieren, Informatik, Java)

4 Antworten

(...) vllt kann mir irgendwer, falls existent, eine deutsche wenn nicht auch englische seite mit erklärung für soviel wie möglich von java verlinken (...)
Ich habe noch nicht so ganz verstanden wofür es Klassen gibt wenn man alles in eine schreiben kann, (...)

Die objektorientierte Programmierung ist der Ansatz, ein System mit Objekten zu beschreiben. Das heißt, jede Komponente im System nimmt eine eigene Rolle ein und letzten Endes agieren die Objekte miteinander.

Das ist schon einfach bei Swing ersichtlich: Es gibt Button-Komponenten, es gibt Labels, Frames, etc.. Jedes Objekt hat seine eigenen Zustände (Eigenschaften) und eigene Verhaltensweisen (Methoden). Würdest du es als sinnvoll erachten, die Beschreibung von JLabel, JButton und z.B. einem FlowLayout in einer Klasse vorzunehmen?

Du hast dann schnell ein Chaos an verschiedenen Elementen, die eigentlich nicht zusammengehören. Die Klasse wird größer und größer, du als Programmierer wirst also immer mehr die Übersicht verlieren, mehr scrollen müssen und dich irgendwann auch über die Ladezeiten ärgern, weil dein Editor die x-Tausend Zeilen nicht mehr gut laden kann. Grundsätzlich gehört also auch jede Klasse in eine eigene Datei.

Auf den Punkt mit dem Zustand möchte ich dabei ebenfalls nochmal eingehen. Ich wähle dazu ein anderes Beispiel - halte es folgend aber auch bewusst kurz (verzichte bspw. auf Kapselung):

public class Person {
  public int age;
  public String name;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

// main:
Person max = new Person("Max", 21);
Person tom = new Person("Tom", 39);
System.out.printf("%s is %d.%n", max.name, max.age);
System.out.printf("%s is %d.%n", tom.name, tom.age);

Wie du siehst, hat jedes Objekt seinen eigenen Zustand. Die Person Max kann Max heißen und 21 Jahre alt sein, ohne dass es mit Tom kollidiert. Die Eigenschaften sind zudem logisch zuordbar. Das heißt, es ist logisch, dass eine Person einen Namen und ein Alter haben kann.

Wenn wir das nun einmal folgendermaßen erweitern:

public class PersonCar {
  public int age;
  public String name;
  public String brand;
  public int numberOfWheels;
    
  public PersonCar(String name, int age, String brand, int numberOfWheels) {
    this.name = name;
    this.age = age;
    this.brand = brand;
    this.numberOfWheels = numberOfWheels;
  }
}

// main:
PersonCar maxMercedes = new Person("Max", 21, "Mercedes", 4);
PersonCar tomToyota = new Person("Tom", 39, "Toyota", 4);

zerstören wir uns dieses Zustandsmodell schon effektiv, denn plötzlich kann ein Objekt Zustände aus verschiedenen Kontexten aufnehmen.

Hier habe ich noch einen Namen für die Klasse gewählt, damit man zumindest erahnen kann, um was es geht. Es gibt aber auch Programmierer, die nennen so eine Klasse einfach Utils und stopfen alles rein, was geht. Das ist mehr als unschön.

Durch die Aufteilung in sinnvolle Objekte, wird das Programm nicht nur lesbarer, sondern auch flexibler.

Ein Beispiel:

Person max = new Person("Max", 42);
Vehicle car = new Car("Mercedes");
car.setOwner(max);
car.drive();

Der Code ist einfach lesbar und könnte sogar leicht abgeändert werden. In diesem Beispiel durch Polymorphie.

Vehicle car = new Bycycle(); // change line 2

Wenn alles in einer Klasse liegt, kann man solche Vorteile nicht nutzen.

Also ich kann mir denken das es vllt etwas auch besser läuft (von der Performance) (...)?

Die Performance ist hierbei nicht von Relevanz. Eine gute Wartbarkeit eines Projekts ist wichtiger. Performance-Optimierungen kann man an anderer Stelle vornehmen.

Woher weiß ich was ich nicht in die Mainklasse schreiben muss bzw. was ich in eine andere Klasse schreiben kann ?

Wenn du dein Programm logisch aufteilst, wirst du das Problem nicht so sehr haben.

Wenn du eine Anwendung mit grafischer Oberfläche entwickelst und du hast bspw. einen Settings-Dialog, dann wäre es günstig, für diesen eine eigene Klasse anzulegen. Die Komponenten, die der Dialog benötigt sowie diverse Listener, etc. kommen dann in diese Klasse.

Ein anderes Beispiel: Du hast ein Fenster, welches sich in verschiedene Bereiche unterteilt (so wie bei Eclipse: Projektfenster, Code-Editor, usw.), läuft es ebenso:

public class MainWindow extends JFrame {
  private ProjectExplorer projectExplorer;
  private CodeEditor codeEditor;
  // ...

  public MainWindow() {
    projectExplorer = new ProjectExplorer();
    codeEditor = new codeEditor();

    add(projectExplorer, BorderLayout.LINE_START);
    add(codeEditor, BorderLayout.CENTER);

    // ...
  }

  // ...
}

public class ProjectExplorer extends JPanel {
  // ...
}

public class CodeEditor extends JPanel {
  // ...
}

Welche Komponenten im Fenster / Panel / ... angezeigt werden, muss man selbst regeln, indem man die Elemente anhängt. Eine Komponente könnte auch von einer anderen Klasse kommen:

class Window extends JFrame {
  public Window() {
    OtherWindow otherWindow = new OtherWindow();
    add(otherWindow.getLabel());
    // ...
  }
}

class OtherWindow extends JFrame {
  private JLabel someLabel;

  public OtherWindow() {
    someLabel = new JLabel("Some label");
  }

  public JLabel getLabel() {
    return someLabel;
  }
}   

Inwiefern das Sinn macht, ist fallabhängig.

Ein Zugriff auf das Objekt muss in jedem Fall bestehen.

Und wie mache ich zb. das ein Button eine, nennen wir es neue Seite (kein dialog) aufmacht (...)

Schau dir das CardLayout an.

Und kleine Randfrage, was genau bringt eine Private Klasse? vllt ein kleines bsp parat?

Nur Elemente einer Klasse dürfen privat (nach außen hin nicht sichtbar sein). Das bedeutet, dass eine Klasse nur dann privat sein kann, wenn sie innerhalb einer anderen Klasse steht. Äußere private Klassen würden auch keinen Sinn machen.

Ein einfach gehaltenes Beispiel:

public class List<T> {
  private Node<T> start;

  public void add(T data) {
    if (start == null) {
      start = new Node(data);
      return;
    }

    Node<T> end = start;

    while (end.next != null) {
      end = end.next;
    }

    end.next = new Node(data);
  }

  private class Node<T> {
    public T data;

    public Node next;

    public Node(T data) {
      this.data = data;
    }
  }
}

Die Klasse beschreibt eine Liste. Eine Liste besteht aus mehreren Knoten, die einfach nur aneinandergehängt werden. Jeder Knoten kennt seinen Nachfolger und das Datenobjekt, welches gespeichert werden soll. Die Liste selbst muss nur den Startknoten kennen, um später noch Zugriff auf alle Elemente wieder erhalten zu können.

Die Klasse Node ist für den Anwender der Liste allerdings von keinerlei Relevanz. Wie die List-Klasse ihre Daten strukturiert / handhabt, ist ganz allein ihr überlassen (vgl. Lichtschalter-Beispiel: Den Anwender interessiert nur der Schalter, wie das Stromkabelgewirr dahinter die Lampe zum Glühen bringt, ist für ihn irrelevant). Daher kann die Node-Klasse auch ruhig nach außen hin unsichtbar sein.

Das wird jetzt etwas ausführlicher.

Java ist eine OOP (objektorientierte Programmiersprache).
Dafür benötigt man Klassen und entsprechende Objekte dieser Klassen.
Sprachen wie bspw. C haben keine Objektorientierung und haben deshalb auch keine Klassen oder Objekte.

Ein kleines Beispiel zum Verständnis:
Du hast die Klasse "Brief", die dir genau sagt was ein Brief ist und wie er aufgebaut ist. Wenn du nun einen Brief schreiben willst, musst du von der Klasse "Brief" ein Objekt erzeugen, das den Aufbau und die Funktion der Klasse entspricht, wo dieses Mal aber was drin steht. Deine Nachricht.

Eine Klasse ist demnach eine Art Bauplan und ein Objekt ist das fertige Produkt dieses Plans.

Schreibt man jetzt alles in eine Klasse, kann man keine Objekte mehr erzeugen (und natürlich leidet die Übersicht extrem darunter. Es ist einfach kein guter Stil in Java).

Mehr Infos dazu kannst du hier nachlesen: http://openbook.rheinwerk-verlag.de/javainsel9/javainsel_03_002.htm#mj5b619d9f15dfdb8c74f6dd581e8ae52e

Was bringen private Klassen?
Das ist situationsabhängig. Java hat die Zugriffsmodifikatoren public, private und protected.
Public bedeutet, dass jede Klasse auf die (public) Methoden und (globalen) Variablen dieser Klasse zugreifen darf.
Private "schützt" Methoden und Variablen vor einem Zugriff einer anderen Klasse.
Protected "schützt" ebenfalls wie private vor Zugriffen, jedoch nur vor Zugriffen, die außerhalb des Packages liegen (ist für den Anfang unwichtig!)

Genaueres hier (die weiteren modifier braucht man anfangs eher selten): https://java-tutorial.org/modifikatoren.html

Ich hoffe, ich konnte dir einigermaßen helfen, wobei ich es ja nur kurz angerissen habe. Solltest du noch weitere Fragen haben, dann sag Bescheid!

Woher ich das weiß:Studium / Ausbildung – 3. Fachsemester Informatik B.Sc.

Zu deinen Fragen mit Swing kann ich leider nicht all zu viel sagen, was ich dir aber sagen kann ist was es mit dem Konzept der Objektorientierten Programmierung auf sich hat.

Klassen sorgen zum einen für eine Gliederung des Programms und zum einen ermöglichen sie eine Problemabstraktion, die sehr Nahe an die Wirklichkeit angelehnt ist.

Denken wir zB an ein Auto. Wir können Gas geben wodurch sich die Geschwindigkeit erhöht und wir können Bremsen mit dem anderen Effekt.

Die Objektorientierte Programmierung lässt es jetzt zu, dass wir das Objekt Auto auch in unserem Code erfassen.

class Auto
  int geschwindigkeit = 0;
  public void Gas()
    geschwindigkeit++;

  public void Bremsen()
    geschwindigkeit--;

  public int GetGeschwindigkeit()
    return geschwindigkeit;

(Es handelt sich hier nicht um Java Code sondern nur um einen Pseudocode der die Wirkungsweise zeigen soll)

Anderswo in unserem Code können wir das Objekt Auto jetzt verwenden.

Auto meinAuto = new Auto();
meinAuto.Gas();
meinAuto.Bremsen();

Wir haben also das Modell des Autos durch diese Klasse abstrahiert und wir müssen uns von ausen betrachtet keine Gedanken mehr machen was da genau in diesem Programmteil passiert.

Jetzt können wir zB eine Person implementieren die das Auto fährt:

class Person
  string name;
  string Geburtsdatum;
  .....

In die Klasse Auto geben wir jetzt noch die Variable Person mit der Funktion GetPerson() und nennen diese Variable Besitzer und wir setzen sie im Konstruktor der Klasse.

class Auto
  int geschwindigkeit = 0;
  Person besitzer;
  public Auto(Person besitzer)
    this.besitzer = besitzer;
  public void Gas()
    geschwindigkeit++;

  public void Bremsen()
    geschwindigkeit--;

  public int GetGeschwindigkeit()
    return geschwindigkeit;
  public Person GetBesitzer()

Weiters erzeugen wir eine Klasse Namens Polizist. Da ein Polizist eine Person ist können wir die Klasse Person als Basis nehmen:

class Polizist extends Person
  RadarMessung(Auto auto)
    if auto.GetGeschwindigkeit() > 50
      Stelle einen Strafzettel an die Person auto.GetBesizer aus

Das können wir jetzt so verwenden:

Person ich = new Person();
Auto meinAuto = new Auto(ich);
Polizist polizist = new Polizist();

meinAuto.Gas();
polizist.RadarMessung(meinAuto);
  Wenn die Geschwindigkeit größer als die 50km/h sind bekommt die Person "ich" einen Strafzettel.

Man kann natürlich dann auch noch eine Klasse Strafzettel machen usw. aber das soll nur mal das Konzept zeigen und wozu diese Abstraktion da ist.

Der Sinn einer Privaten Klasse ist es eine Klasse zu erstellen die von ausen nicht sichtbar ist. Das erlaubt es dem Programmierer bestimmte intern genutze Dinge die er selbst benötigt vor der Außenwelt zu verbergen. Dadurch können diese internen Dinge von anderen Programmierer im Projekt nicht fälschlicherweise verwendet werden. Das selbe gilt auch für die anderen Stufen protected und package private

Nett beschrieben, schau dir aber noch mal die Java Konventionen an

0
@Simon221585

Lies dir bitte meine Antwort ganz durch dann wirst du diese Bemerkung sehen:

(Es handelt sich hier nicht um Java Code sondern nur um einen Pseudocode der die Wirkungsweise zeigen soll)
1

Was möchtest Du wissen?