Objektorientierung - wie konsequent sollte man sein ?

[Destiny1985]

Um die Objektorientierung in den Griff zu bekommen, will ich zur Übung ein größeres Programm schreiben, das die kompletten Abläufe innerhalb einer Bank darstellen soll.

Mein Grundgerüst sieht so aus, das ich die statische Klasse "Sparkasse" habe, in der sich die main-Methode befindet, und die Klasse "Bankkonto", aus der ich die verschiedenen Konten erzeuge.

Wie ich mir das denke, packe ich alle Methoden, die irgendwas mit dem Konto zu tun haben als Instanzmethoden in die Bankkonto-Klasse.

Wie handhabe ich aber zB das Menü, wo ich meine Auswahl treffe. Muss ich das auch als eine eigene Klasse schreiben, oder ist das übertrieben / unsinnig. Ich dachte mir, ich packe das als normale Methode mit in meine statische Klasse (direkt in main nicht, das ist klar).

Was könnt ihr mir dazu sagen, welche Tipps habt ihr für mich ?

 

[Beni]

Für jeden Eintrag in das Menü eine eigene Klasse. Da kannst du alles was zu einem Thema ("Datei öffnen"...) gehört praktisch zusammenfassen.
Schau die mal "Action" in der API an :wink:

Und benutz sowenig static wie möglich*, static ist sozusagen das Gegenkonzept zur OOP :wink:

(* static ist gut für Dinge die wirklich nur einmal in einem Programm vorkommen, z.B. die Icons für Buttons, Standard-Farbeinstellungen, etc.)

 

[Destiny1985]

Aber das Menü selber, wo der User also seine 1, 2 oder was auch immer eingibt, kann ich mit in die statische Klasse packen ?

 

[Destiny1985]

Hier mal mein aktueller Code, ist halt noch nicht viel. aber ist dieser Grundaufbau OK oder weisst er fehler auf ?

[EDIT]

schaut mal in die switch-Anweisung:

case 1 : Bankkonto(); break;

das geht nicht, weil es ja keine Methode ist. Wie rufe ich an dieser Stelle die Klasse auf ?

[/EDIT]

import java.io.*;
import java.text.*;

public class Sparkasse
{
  public static void main(String[] args)
  {
    hauptMenue();
  }
  
  public static void hauptMenue()
  {
    BufferedReader userIn =
      new BufferedReader(new InputStreamReader(System.in));

    String inData;
    int menueWahl;

    System.out.println("[1] - Neues Konto erstellen");
    System.out.println("[2] - Bankkonto anzeigen");
    System.out.println("[3] - Status Sparkasse");
    System.out.println("[0] - Programm beenden");
    
    inData = userIn.readLine();
    menueWahl = Integer.parseInt( inData );
    
    switch (menueWahl)
    {
      case 1 : Bankkonto(); break;
      case 2 : System.out.println("Funktion Bankkonto anzeigen"); break;
      case 3 : System.out.println("Funktion Status Sparkasse"); break;
      case 4 : System.exit(0);
    }
  }
}

class Bankkonto
{
  // Variablen
  
  private static int kontoZaehler = 0;
  private String kontoInhaber, kontoNummer = "1042000";
  private int /* moeglicherKredit, */ ktoNR;
  private double guthaben = 0.0;
  final private int bankLeitZahl = 52052362;
    
  // private int[] vergebeneKontoNummern = new int[100];

  // Konstruktoren
  
  public Bankkonto(String kontoInhaber)
  {
    this.kontoInhaber = kontoInhaber;
    this.guthaben = 0;
    this.kontoNummer = getNewKontoNummer();
  }
  
  // Methoden
  
  public void kontoAusgeben()
  {
    NumberFormat n = NumberFormat.getInstance();
    n.setMaximumFractionDigits(2);

    System.out.println("Kontoinhaber: " + this.kontoInhaber);
    System.out.println("Kontonummer: " + this.kontoNummer);
    System.out.println("Aktuelles Guthaben: " + n.format(guthaben));
  }
  
  private String getNewKontoNummer()
  {
    this.ktoNR = 100 + kontoZaehler;

    this.kontoNummer = kontoNummer + String.valueOf(ktoNR);
    kontoZaehler++;
    
    return kontoNummer;
  }
}

 

[Destiny1985]

Keiner Lust da eben rüberzugucken bzw mir zu sagen die ich von der switch-Methode aus die Klasse aufrufen kann ?

 

[AlArenal]

Wenn du ein neues Konto anlegen willst, dann musst du schon irgendwan in Richtung "new Bankkonto()" machen. Da du beliebig viele Konton haben kannst, solltest du diese zentral irgendwo speichern, in einem Vector oder einer ArrayList, o.ä. Dann würdest du an der Stelle in etwa sowas machen:

Vector konten = new Vector();

...

Bankkonto konto = new Bankkonto();
konten.addElement(konto);

 

[KSG9|sebastian]

du solltest bei'm switch noch nen default festlegen

 

[bygones]

ich würde das ganze noch weiter trennen.

Ich würde mindestens mit 3 Klassen arbeiten:

Sparkasse
Bankkonto
Main

Main Klasse ist dafür da das ganze Programm zu managen. Also zu starten und die Eingaben zu lesen. Sie erstellt ein Sparkasse und fügt dieser Sparkasse immer wieder ein Bankkonto hinzu.

Bankkonto speichert einfach die Daten die für ein Konto notwendig sind.
Die Sparkassen Klasse hat ein Collection (ArrayList z.b.) die alle Bankkonto darstellen. Möglichweise hat sie noch mehr Felder bzw. Methoden.

Die MainKlasse ist hierbei dann nur der Dirigent der die Inputs bekommt und Instanzen erschafft und diese dann weitergibt

 

[Destiny1985]

Vector und ArrayList hört sich sehr interessant an, leider habe ich damit noch keine Erfahrungen.

Was ist Vorteil und Nachteil der beiden, und was wäre hier sinnvoller ?

Ich werde es mal ausprobieren und bei Fragen auf euch zurückkommen.

Die Unterteilung in die Klassen

Sparkasse
Bankkonto
Main

finde ich im nachinein auch besser.

Allerdings die Frage: main muss doch in einer Klasse sein, kann ich dann direkt die Klasse auch Main nennen, also

class Main
{
  public static void main(String[] args)
  {
   ...

?

Und der Aufruf einer Klasse würde dann mittels des new-Operators gehen ( new Klassenname(); ) ?

Das default beim switch sollte die leichteste Übung werden Hätte ich noch geschrieben, aber das "grundgerüst" geht auch erstmal ohne...

danke für die zahlreichen antworten

 

[Destiny1985]

Jetzt mal Butter bei die Fische: was bringt mir ein Vector und wie setze ich ihn ein ?

Für mich sieht das so aus als ob das ein schlichter Zähler wäre!

 

[Destiny1985]

Hier ein Auszug aus der main-Methode, in der ich ein neues Bank-Objekt erstelle...

case 4 :
      {
        System.out.print("\nName der neuen Bank: ");
        bankName = userIn.readLine();
        System.out.print("Bankleitzahl der neuen Bank: ");
        bankLeitZahl = userIn.readLine();
        
        Bank bankName = new Bank(bankName, bankLeitZahl);
        
        break;
      }

Er meckert mir beim Name der Referenzvariable rum. Ich hätte das halt gerne so, das das Objekt auch so heisst, wie die Bank an sich (also das was der Nutzer eingibt). Oder ist das nicht sinnvoll - wie wäre es dann besser ?

Das Problem ist halt, das ich keinen Schimmer habe wie ich es machen kann, das er automatisch immer den Objekten vernünftige namen gibt, wenn er sie erstellt....hoffe ihr versteht mein Problem!

 

[bygones]

Jetzt mal Butter bei die Fische: was bringt mir ein Vector und wie setze ich ihn ein ?

Für mich sieht das so aus als ob das ein schlichter Zähler wäre!

schau in ein JavaBuch deines Vertrauens

Vector wie ArrayList zählt zu den Collection und sind Container die mehrere Objekte aufnehmen können...

Er meckert mir beim Name der Referenzvariable rum. Ich hätte das halt gerne so, das das Objekt auch so heisst, wie die Bank an sich (also das was der Nutzer eingibt)

das ist nicht möglich ! die variable bankName ist vom Typ String. den du einliest.

Du musst eine neue Variable vom Typ Bank hernehmen, um ein Bank objekt zu erstellen....

 

[Destiny1985]

das ist nicht möglich ! die variable bankName ist vom Typ String. den du einliest.

Du musst eine neue Variable vom Typ Bank hernehmen, um ein Bank objekt zu erstellen....

Joa, aber wie kann ich es erreichen, das er mir die Objekte sinnvoll benennt ?

[EDIT] oder ist genau das der clou so eines vectors ? [/EDIT]

 

[bygones]

das ist nicht möglich ! die variable bankName ist vom Typ String. den du einliest.

Du musst eine neue Variable vom Typ Bank hernehmen, um ein Bank objekt zu erstellen....

Joa, aber wie kann ich es erreichen, das er mir die Objekte sinnvoll benennt ?

[EDIT] oder ist genau das der clou so eines vectors ? [/EDIT]

wie du die benennst ist schnuppe....

bsp mit einer ArrayList:

List<Bank> banken = new ArrayList<Bank>();

while(true) {
   // einlesen

  Bank neueBank = new Bank(.....);
  banken.add(neueBank);
}

d.h. du fügst einfach das neu generierte Objekt in deine Collection (in dem Fall eine ArrayList) ein.

später kannst du dann übers iterieren über die Liste wieder an alle banken gelangen:

for(int i = 0; i < banken.size(); i++) {
   Bank bank = banken.get(i);
}

 

[Destiny1985]

ah ok, hab mir gerade den vector angesehen und werd das dann wohl damit machen...

Wenn ich jetzt zb diesen Code hätte

Vector banken = new Vector();

for (int i = 0; i <= 5; i++)
{
  Bank bank = new Bank("Sparkasse", "1041000123");
  banken.addElement(bank);
}

wäre der korrekt und hab ich das so richtig verstanden ? Und ran käme ich dann über den Index... ?!

Wären dann zwar 5 mal diesselben Banken, aber nur so als Bsp...

 

[Wildcard]

Wenn du nicht synchronisieren musst nimm ArrayList statt Vector weil ArrayLists schneller sind.
Wenn du Java 5 hast benutz Generics.
Greif auf die Collection nur über das List Interface zu:

List list = new ArrayList();

 

[Destiny1985]

Mir ist noch nicht ganz klar, welchen Vorteil mir das ganze bringt. Ich erstelle meine Konten-Objekte und füge sie in die ArrayListe ein...irgendwann hab ich dann meinetwegen 7 Konten da drin stehen....und ?

Was bringt mir das ?

 

[mic_checker]

Hä ? Wo ist dein Problem ?

Weisst du nicht wie ArrayList funktioniert, weisst du nicht warum vorne List steht und nicht ArrayList oder was genau ist dir nicht klar ?

 

[Destiny1985]

Mir ist klar wie ich eine Array-Liste erzeuge, die Elemente darin abrufe etc (funzt ja wie ein normales Array).

Abe was ist der Sinn einer Array-List ? Ich sehe da momentan keinen nutzen drin...was habe ich für Vorteile wenn ich alle meine Objektreferenzen in eine ArrayList packe ?

 

[stev.glasow]

Wie willst du die denn sonst halten? Für jedes Object eine Variable?

 

[Destiny1985]

Ah stevg das wusst ich doch nicht das sowas damit geht

Hab gerade bissel mit rumgespielt und das auch gerade rausgefunden...super Sache das

Was lässt sich denn damit noch feines anstellen, das ich noch nicht weiss ?

mfg

 

[mic_checker]

Liste = dynamisch + einfach in anwendung, sollte als argument reichen oder ?

edit: zu spät - ArrayList rules - mehr musst net wissen

 

[Destiny1985]

So, ich habe jetzt folgendes vor (was für mich noch eine relativ schwere Aufgabe darstellt).

Ich will ein Programm machen, in welchem zuerst ein menü kommt zur Auswahl der Bank.

Dort kann man:

- Eine neue Bank anlegen
- Zu einer bestehen Bank wechseln

Wenn ich zu der bestehendes Bank wechsele, kommt ein Untermenü, in dem ich dann die Bankkonten verwalten kann.

- Neues Konto anlegen
(...)

Später sollen dann die Konten noch zusammenarbeiten, sprich Überweisungn tätigen etc...aber erstmal dieses Grundgerüst!

Wie baue ich diese Struktur am besten auf?

Ich stelle mir das so vor:

Klasse Main
-> ArrayList banken

Klasse Bank
-> ArrayList konten (für jede Bank eine eigene Liste)

Klasse Konto

Was für Tipps könnt ihr mir geben ?

[edit] Wie implementiere ich am besten das Menü ? Kann ich doch als in die main-Klasse mit packen, als statische Methode oder ? [/edit]

 

[KSG9|sebastian]

es geht darum, dass du während der laufzeit von deinem programm mehrere konten erzeugen kannst und auch wieder drauf zugriff hast

bei dir ist es bisher so gewesen, dass mein ein Konto (Konto1) erzeugt, und wenn man ein neues Konto erstellt ist Konto1 (=das alte) wieder weg.

mit ner arraylist könntest du die konten immer schön speichern und später wieder bearbeiten.,..


//EDIT: grmpf viiiel zu spät

 

[KSG9|sebastian]

Also...ich hab mal so was ähnliches gemahc.t.zum bissl rumspielen. überleg dir einfach was du brauchst..methoden z.b.


- anzeigeUebersicht
- anzeigeBanken
- anzeigeKonten
- diverse andere menüs zum anzeigen von daten

von der logik her ist das ganze einfach, ist nur viiel schreibarbeit wg. den ganzen menus

Ach ja...für eine bessere/einfachere Steuerung würd ich dir noch empfehlen, dass du ne Klasse "Kunde" schreibst, dann sind nämlich die Konten an nen Kunde gebunden und ein Kunde ist an eine Bank gebunden.

 

[Destiny1985]

Das mit dem Kunde ist wohl eine ganze Ecke realistischer

Ich poste jetzt ab und an mal meinen Code, wär nett wenn ihr mal rüberschaut !

 

[Destiny1985]

Eine andere (vllt würde sie sich von selbst lösen, wenn ich programmiere, ich will aber lieber vorher fragen)

Wie mache ich es, das ein Objekt Teil eines anderen Objektes ist ? Also ein Konto an einen Kunden, und dieser Kunde wiederrum an eine Bank gebunden ist ?

 

[byte]

einfach in der entsprechenden klasse eine referenz auf die jeweilige andere klasse setzen.

also in Konto -> Referenz auf einen Kunden und in Kunde -> Referenz auf eine Bank bzw. bei bedarf auch umgekehrt

 

[Destiny1985]

Ok, bin im Code etwas weiter. ich weiss immer noch nicht wie ich zu einem anderen Objekt verzweigen kann. Schaut euch mal den Code an, wenn ich den Punkt 2 im Menue anwaehle - wie komme ich dann ich das Untermenü zu dieser Bank, das auch echt zu dieser bank gehört

import java.io.*;
import java.text.*;
import java.util.*;

public class Main
{
  public static void main(String[] args) throws IOException
  {
    int bankMenueWahl;

    List banken = new ArrayList();
    
    do
    {
      bankMenueWahl = bankMenue();

      switch (bankMenueWahl)
      {
        case 1 :
        {
          BufferedReader userIn =
            new BufferedReader(new InputStreamReader(System.in));

          String bankName, bankLeitZahl;

          System.out.print("\nName der Bank: ");
          bankName = userIn.readLine();
          System.out.print("Bankleitzahl: ");
          bankLeitZahl = userIn.readLine();

          Bank bank = new Bank(bankName, bankLeitZahl);
          banken.add(bank);

          break;
        }
        case 2 :
        {
          for (int i = 0; i <= banken.size() - 1; i++)
          {
            System.out.println("[" + ( i+1 ) + "] - " + banken.get(i));
          }
        }
        case 0 : System.exit(0);
      }

    } while (bankMenueWahl != 0);
  }
  
  public static int bankMenue() throws IOException
  {
    BufferedReader userIn =
      new BufferedReader(new InputStreamReader(System.in));
      
    String inData;
    int bankMenueWahl;

    System.out.println("[1] - Bank anlegen");
    System.out.println("[2] - Zu einer Bank verzweigen");
    System.out.println("[0] - Programm beenden");
    System.out.print("\nIhre Wahl: ");
    
    inData = userIn.readLine();
    bankMenueWahl = Integer.parseInt( inData );
    
    return bankMenueWahl;
  }
}

class Bank
{
  // Variablen
  
  String bankName, bankLeitZahl;

  // Konstruktoren
  
  public Bank(String bankName, String bankLeitZahl)
  {
    this.bankName = bankName;
    this.bankLeitZahl = bankLeitZahl;
  }
  
  // Methoden
  
  public String toString()
  {
    return "Bank: " + bankName + " BLZ: " + bankLeitZahl;
  }
}

class Kunde
{
  // Variablen
  
  String kundenName;
  
  // Konstruktoren
  
  public Kunde(String kundenName)
  {
    this.kundenName = kundenName;
  }
  
  // Methoden
  
  public String toString()
  {
    return "Kundenname: " + kundenName;
  }
}

class Konto
{
  // Variablen
  
  String kontoInhaber;

  // Konstruktoren
  
  public Konto(String kontoInhaber)
  {
    this.kontoInhaber = kontoInhaber;
  }
  
  // Methoden
  
  public String toString()
  {
    return "Kontoinhaber: " + kontoInhaber;
  }
}

 

[Destiny1985]

...

 

[byte]

was hast du denn nicht verstanden?

nochmal:

ein kunde soll (wenn ich richtig verstanden habe) ein konto haben. dann setzt du in klasse kunde eine referenz auf ein konto:

Konto myAccount;

dazu schreibst du am besten noch getter und setter. letzterer setzt dann das konto z.b. beim initialisieren des kunden im konstruktor von Kunde oder wo immer du möchtest.