Klassenentwurf, Implementation und Arrays am Beispiel einer Banksoftware

1. 
2. Individuelle Lösungen

  public class Konto
  {
      private String kontoinhaber;
      private String iban;
      private double kapital;
      private double zinssatz;
      private double dispozinssatz;

      public Konto(String kontoinhaber, String iban)
      {
          this.kontoinhaber = kontoinhaber;
          kapital = 0.0;
          this.iban = iban;
      }

      public void einzahlen(double betrag){
          kapital += betrag;
      }

      public void abheben(double betrag){
          kapital -= betrag;
      }

      public void setzeZinssatz(double zinssatz){
          this.zinssatz = zinssatz;
      }

      public void setzeDispoZinssatz(double dispoZinssatz){
          this.dispozinssatz = dispozinssatz;
      }

      public String toString(){
          String antwort = String.format("IBAN: %10s, Kontoinhaber: %15s, kapital: %,15.2f €",kontoinhaber, iban, kapital);
          return antwort;
      }
  }

public double zins(){
    double zins = 0.0;
    if(kapital > 0){
        zins = kapital * zinssatz / 100.0;
    }else{
        zins = kapital * dispozinssatz / 100.0;
    }
    return zins;
}

public void verzinsen(){
    kapital += zins();
}

  /**
  * Die Klasse Bank verwaltet Konten.
  * 
  * @author Tim Schellartz
  * @version 30.01.2021
  */
 public class Bank
 {
     Konto[] konten;
     
     /**
      * Konstruktor der Klasse Bank. Hier werden einige Objekte angelegt
      */
     public Bank(){
         konten = new Konto[8];
         
         konten[0] = new Konto("Jana Türlich", "DE1001");
         konten[0].setzeZinssatz(0.1);
         konten[0].setzeDispoZinssatz(4);
         
         konten[1] = new Konto("Ellen Bogen", "DE1002");
         konten[2] = new Konto("Clara Fall", "DE1003");
         konten[3] = new Konto("Han Dschuh", "DE1004");
         konten[4] = new Konto("Peter Silie", "DE1005");
         konten[5] = new Konto("Moe Tief", "DE1006");
         konten[6] = new Konto("Tie Reks", "DE1007");
         konten[7] = new Konto("Ali Gator", "DE1008");
     }
     
     /**
      * Suche ein Konto anhand der IBAN. 
      * @param gesuchte Iban Diese Iban wird in dem konten-Array gesucht.
      * @return Das gesuchte Konto-Objekt bzw. null falls die IBAN nicht gefunden wird. 
      */
     public Konto sucheKonto(String gesuchteIban){
         for(int i=0;i < konten.length;i++){
             Konto aktuell = konten[i]; 
             if(gesuchteIban.equals(aktuell.getIBAN())){
                 return aktuell;
             }
         }
         return null;
     }
 }
 

  /**
  * Die Klasse Bank verwaltet Konten.
  * 
  * @author Tim Schellartz
  * @version 30.01.2021
  */
 public class Bank
 {
     Konto[] konten;
     
     /**
      * Konstruktor der Klasse Bank. Hier werden einige Objekte angelegt.
      */
     public Bank(){
         konten = new Konto[8];
         
         konten[0] = new Konto("Jana Türlich", "DE1001");
         konten[0].setzeZinssatz(0.1);
         konten[0].setzeDispoZinssatz(4);
         konten[0].einzahlen(1000);
         
         konten[1] = new Konto("Ellen Bogen", "DE1002");
         konten[1].einzahlen(2000);
         konten[2] = new Konto("Clara Fall", "DE1003");
         konten[2].einzahlen(1234.56);
         konten[3] = new Konto("Han Dschuh", "DE1004");
         konten[3].einzahlen(3.14159);
         konten[4] = new Konto("Peter Silie", "DE1005");
         konten[4].einzahlen(2507.19);
         konten[5] = new Konto("Moe Tief", "DE1006");
         konten[5].einzahlen(-1803.87);
         konten[6] = new Konto("Tie Reks", "DE1007");
         konten[6].einzahlen(-20.11);
         konten[7] = new Konto("Ali Gator", "DE1008");
         
     }
     
     /**
      * Suche ein Konto anhand der IBAN und gib dies zurück. 
      * Gib null zurück falls es nicht gefunden wird. 
      * @param gesuchte Iban Diese Iban wird in dem konten-Array gesucht.
      * @return Das gesuchte Konto-Objekt bzw. null falls die IBAN nicht gefunden wird. 
      */
     public Konto sucheKonto(String gesuchteIban){
         for(int i=0;i < konten.length;i++){
             Konto aktuell = konten[i]; 
             if(gesuchteIban.equals(aktuell.getIBAN())){
                 return aktuell;
             }
         }
         return null;
     }
     
     /**
      * Überweist den Betrag von dem Konto mit der IBAN vonIBAN
      * auf das Konto mit IBAN zuIBAN. 
      * Ist der Betrag negativ, so soll nichts passieren und 
      * eine Fehlermeldung ausgegeben werden (in der Konsole)
      * um möglich Fehleingaben zu vermeiden.
      * @param vonIBAN IBAN des Kontos, welches das Geld versendet.
      * @param zuIBAN IBAN des Kontos, welches das Geld erhält. 
      * @param betrag Der Betrag. 
      */
     public void überweisen(String vonIBAN, String zuIBAN, double betrag){
         if(betrag>=0){
             Konto von = sucheKonto(vonIBAN);
             Konto zu = sucheKonto(zuIBAN);
             von.abheben(betrag);
             zu.einzahlen(betrag);
         }else{
             System.err.println("Betrag negativ. Überweisung gestoppt!");
         }
     }
     
     /**
      * Zum Jahresende wird das Kapital bzw. die Schulden jedes Kontos verzinst. 
      * Dabei werden die jeweils passenden Konditionen verwendet.
      */
     public void jahreswechsel(){
         for(Konto k : konten){
             k.verzinsen();
         }
     }
     
     /** 
      * Berechnet die Summe aller Kontostände im konten Array
      */
     public double kontoständeSumme(){
         double sum = 0;
         for(Konto k : konten){
             sum += k.getKapital();
         }
         return sum;
     }
     
     /**
      * Berechnet den Durschnitt aller Kontostände im konten Array
      */
     public double kontoständeDurchschnitt(){
         return kontoständeSumme()/konten.length;
     }
     
     /**
      * Liefert als Rückgabe das Konto mit dem höchsten Kontostand
      */
     public Konto kontoMax(){
         Konto currentMax = konten[0]; // Setze ein beliebige Konto als aktuelle Maximum
         // Überprüfe nun jedes Konto und ersetze das aktuelle Maximum bei Bedarf
         for(Konto k : konten){
             if(k.getKapital() > currentMax.getKapital()){
                 currentMax = k;
             }
         }
         // Nun ist das aktuelle Maximum das gesamte Maximum. 
         return currentMax;
     }
     
     /**
      * Liefert als Rückgabe das Konto mit dem kleinsten Kontostand
      */
     public Konto kontoMin(){
         Konto currentMin = konten[0]; // Setze ein beliebige Konto als aktuelle Minimum
         // Überprüfe nun jedes Konto und ersetze das aktuelle Minimum bei Bedarf
         for(Konto k : konten){
             if(k.getKapital() < currentMin.getKapital()){
                 currentMin = k;
             }
         }
         // Nun ist das aktuelle Minimum das gesamte Minimum. 
         return currentMin;
     }
     
     /**
      * Liefert die Anzahl der Konten mit Schulden zurück. 
      * Gibt es also 2 Konten, die einen Kontostand unter 0 haben, 
      * so wird 2 zurück geliefert. 
      */
     public int getAnzahlKontenMitSchulden(){
         int anzahl = 0;
         for(Konto k : konten){
             if(k.getKapital() < 0){
                 anzahl++;
             }
         }
         return anzahl;
     }
     
     /**
      * Liefert als Antwort eine Array, welches nur die Konten mit Schulden enthält. 
      * Hinweis: Verwende die Methode getAnzahlKontenMitSchulden() als Hilfe.
      */
     public Konto[] getKontenMitSchulden(){
         Konto[] schuldner = new Konto[getAnzahlKontenMitSchulden()];
         int i = 0;
         for(Konto k : konten){
             if(k.getKapital() < 0){
                 schuldner[i] = k;
                 i++;
             }
         }
         return schuldner;
     }
 }  

1. 
2. Individuelle Lösungen

  /**
  * Ein Kredit
  *
  * @author Tim Schellartz
  * @version 16.02.2021
  */
 public class Kredit
 {
     private String kreditnehmer;
     private double betrag;
     private double zinssatz;
     private double rate;
 
     /**
      * Konstruktor
      * Zinsatz ist standardmäßig 1.5%
      */
     public Kredit(String pKreditnehmer, double pBetrag, double pRate)
     {
         kreditnehmer = pKreditnehmer;
         betrag = pBetrag;
         zinssatz = 1.5;
         rate = pRate;
     }
     
     /**
      * Setzt die jährliche Rate
      */
     public void setzeRate(double pRate){
         rate = pRate;
     }
     
     /**
      * Setzt den Zinssatz
      */
     public void setzeZinssatz(double pZinssatz){
         zinssatz = pZinssatz;
     }
     
     /**
      * Berechnet den aktuellen Jahreszins
      */
     public double berechneZins(){
         return betrag * zinssatz/100.0;
     }
     
     /**
      * Der Kredit wird verzinst. Dieser Zins wird von der Jahresrate abgezogen. 
      * Der Rest, die Tilgung, wird von der Kreditsumme abgezogen. 
      */
     public void verzinsenUndTilgen(){
         double zins = berechneZins();
         double tilgung = rate - zins;
         betrag = betrag-tilgung;
     }
 
     /**
      * Als Vorschau gedacht. 
      * Die Kreditentwicklung über die Jahre bis zur Abzahlung werden übersichtlich in der 
      * Konsole ausgegeben. 
      */
     public void printTilgungsplan(){
         double tempBetrag = betrag;
         int jahr = 0;
         double zinsGesamt=0, tilgungGesamt=0;
         System.out.println(this);
         System.out.printf("%4s %16s %16s %17s\n","Jahr", "Zins", "Tilgung", "Neuer Betrag");
         while(tempBetrag > 0){
             jahr++;
             double zins = tempBetrag * zinssatz/100.0;
             double tilgung = rate - zins;
             if(rate < zins){
                 System.out.println("Tilgungsrate zu gering! Kreditvolumen wird zunehmen!");
                 break;
             }
             if(tempBetrag < tilgung){
                 tilgung = tempBetrag;
             }
             tempBetrag -= tilgung;
             tilgungGesamt += tilgung;
             zinsGesamt += zins;
             System.out.printf("%4d %,15.2f€ %,15.2f€ %,16.2f€\n",jahr, zins, tilgung, tempBetrag);
         }
         System.out.println("--------------------------------------------------------");
         System.out.printf("%4d %,15.2f€ %,15.2f€",jahr, zinsGesamt, tilgungGesamt);
     }
     
     /**
      * Der Kredit wird mit den wesentlichen Daten in der Konsole ausgegeben.
      */
     public String toString(){
         String antwort = String.format("Kreditnehmer: %15s, Kredit: %,15.2f €", kreditnehmer, betrag);
         return antwort;
     }
 }
 

  /**
  * Die Klasse Bank verwaltet Konten.
  * 
  * @author Tim Schellartz
  * @version 16.02.2021
  */
 public class Bank
 {
     Konto[] konten;
     Kredit[] kredite;
     
     /**
      * Konstruktor der Klasse Bank. Hier werden einige Objekte angelegt.
      */
     public Bank(){
         konten = new Konto[8];
         
         konten[0] = new Konto("Jana Türlich", "DE1001");
         konten[0].setzeZinssatz(0.1);
         konten[0].setzeDispoZinssatz(4);
         konten[0].einzahlen(1000);
         
         //... (gekürzt)
         
         kredite = new Kredit[5];
         kredite[0] = new Kredit("Andreas Kreuz", 150000,20000);
         kredite[1] = new Kredit("Ted Tanus", 325000,50000);
         kredite[2] = new Kredit("Tom Bola", 400000,30000);
         kredite[2].setzeZinssatz(0.5);
         kredite[3] = new Kredit("Stan Dard", 25000,5000);
         kredite[4] = new Kredit("Roy Bär", 70000,15000);
         
     }
     //... (gekürzt)
}
     

  /**
  * Die Klasse Bank verwaltet Konten.
  * 
  * @author Tim Schellartz
  * @version 16.02.2021
  */
 public class Bank
 {
     private Konto[] konten;
     private Kredit[] kredite;
 
     /**
      * Konstruktor der Klasse Bank. Hier werden einige Objekte angelegt.
      */
     public Bank(){
         konten = new Konto[1000];
 
         addKonto("Jana Türlich", "DE1001");
         konten[0].setzeZinssatz(0.1);
         konten[0].setzeDispoZinssatz(4);
         konten[0].einzahlen(1000);
 
         addKonto("Ellen Bogen", "DE1002");
         konten[1].einzahlen(2000);
         addKonto("Clara Fall", "DE1003");
         konten[2].einzahlen(1234.56);
         addKonto("Han Dschuh", "DE1004");
         konten[3].einzahlen(3.14159);
         addKonto("Peter Silie", "DE1005");
         konten[4].einzahlen(2507.19);
         addKonto("Moe Tief", "DE1006");
         konten[5].einzahlen(-1803.87);
         addKonto("Tie Reks", "DE1007");
         konten[6].einzahlen(-20.11);
         addKonto("Ali Gator", "DE1008");
 
         kredite = new Kredit[5];
         kredite[0] = new Kredit("Andreas Kreuz", 150000,20000);
         kredite[1] = new Kredit("Ted Tanus", 325000,50000);
         kredite[2] = new Kredit("Tom Bola", 400000,30000);
         kredite[2].setzeZinssatz(0.5);
         kredite[3] = new Kredit("Stan Dard", 25000,5000);
         kredite[4] = new Kredit("Roy Bär", 70000,15000);
 
     }
 
     /**
      * Suche ein Konto anhand der IBAN und gib dies zurück. 
      * Gib null zurück falls es nicht gefunden wird. 
      * @param gesuchte Iban Diese Iban wird in dem konten-Array gesucht.
      * @return Das gesuchte Konto-Objekt bzw. null falls die IBAN nicht gefunden wird. 
      */
     public Konto sucheKonto(String gesuchteIban){
         for(Konto aktuell:konten){ 
             if(aktuell != null && gesuchteIban.equals(aktuell.getIBAN())){
                 return aktuell;
             }
         }
         return null;
     }
 
     /**
      * Überweist den Betrag von dem Konto mit der IBAN vonIBAN
      * auf das Konto mit IBAN zuIBAN. 
      * Ist der Betrag negativ, so soll nichts passieren und 
      * eine Fehlermeldung ausgegeben werden (in der Konsole)
      * um möglich Fehleingaben zu vermeiden.
      * @param vonIBAN IBAN des Kontos, welches das Geld versendet.
      * @param zuIBAN IBAN des Kontos, welches das Geld erhält. 
      * @param betrag Der Betrag. 
      */
     public void überweisen(String vonIBAN, String zuIBAN, double betrag){
         if(betrag>=0){
             Konto von = sucheKonto(vonIBAN);
             Konto zu = sucheKonto(zuIBAN);
             von.abheben(betrag);
             zu.einzahlen(betrag);
         }else{
             System.err.println("Betrag negativ. Überweisung gestoppt!");
         }
     }
 
     /**
      * Zum Jahresende wird das Kapital bzw. die Schulden jedes Kontos verzinst. 
      * Dabei werden die jeweils passenden Konditionen verwendet.
      */
     public void jahreswechsel(){
         for(Konto k:konten){ 
             if(k!=null){
                 k.verzinsen();
             }
         }
     }
 
     /** 
      * Berechnet die Summe aller Kontostände im konten Array
      */
     public double kontoständeSumme(){
         double sum = 0;
         for(Konto k:konten){
             if(k!=null){
                 sum += k.getKapital();
             }
         }
         return sum;
     }
 
     /**
      * Berechnet den Durschnitt aller Kontostände im konten Array
      */
     public double kontoständeDurchschnitt(){
         int n = 0;
         for(Konto k:konten){
             if(k!=null){
                 n++;
             }
         }
         return kontoständeSumme()/n;
     }
 
     /**
      * Liefert als Rückgabe das Konto mit dem höchsten Kontostand
      */
     public Konto kontoMax(){
         Konto currentMax = konten[0]; // Setze ein beliebige Konto als aktuelle Maximum
         // Überprüfe nun jedes Konto und ersetze das aktuelle Maximum bei Bedarf
         for(Konto k:konten){
             if(k!=null && k.getKapital() > currentMax.getKapital()){
                 currentMax = k;
             }
         }
         // Nun ist das aktuelle Maximum das gesamte Maximum. 
         return currentMax;
     }
 
     /**
      * Liefert als Rückgabe das Konto mit dem kleinsten Kontostand
      */
     public Konto kontoMin(){
         Konto currentMin = konten[0]; // Setze ein beliebige Konto als aktuelle Minimum
         // Überprüfe nun jedes Konto und ersetze das aktuelle Minimum bei Bedarf
         for(Konto k:konten){
             if(k!=null && k.getKapital() < currentMin.getKapital()){
                 currentMin = k;
             }
         }
         // Nun ist das aktuelle Minimum das gesamte Minimum. 
         return currentMin;
     }
 
     /**
      * Liefert die Anzahl der Konten mit Schulden zurück. 
      * Gibt es also 2 Konten, die einen Kontostand unter 0 haben, 
      * so wird 2 zurück geliefert. 
      */
     public int getAnzahlKontenMitSchulden(){
         int anzahl = 0;
         for(Konto k:konten){
             if(k!=null && k.getKapital() < 0){
                 anzahl++;
             }
         }
         return anzahl;
     }
 
     /**
      * Liefert als Antwort eine Array, welches nur die Konten mit Schulden enthält. 
      * Hinweis: Verwende die Methode getAnzahlKontenMitSchulden() als Hilfe.
      */
     public Konto[] getKontenMitSchulden(){
         Konto[] schuldner = new Konto[getAnzahlKontenMitSchulden()];
         int j = 0;
         for(Konto k:konten){
             if(k!=null && k.getKapital() < 0){
                 schuldner[j] = k;
                 j++;
             }
         }
         return schuldner;
     }
 
     /**
      * Fügt ein Konto an die erste freie Stelle hinzu
      * Parameter sind der Name des Kontoinhaber sowie eine IBAN
      */
     public void addKonto(String inhaber, String iban){
         if(sucheKonto(iban)!=null){
             System.err.println("IBAN wird schon verwendet. Bitte erneut mit neuer IBAN versuchen!");
         }else{
             for(int i=0;i < konten.length;i++){
                 if(konten[i]==null){
                     konten[i] = new Konto(inhaber, iban);
                     return;
                 }
             }
             System.err.println("Array ist voll! Bitte Programmierer anrufen ;)");
         }
     }
 }
 
 

  public void removeKonto(String iban){
    for(int i=0;i < konten.length;i++){
        if(konten[i]!=null && konten[i].getIBAN().equals(iban)){
            konten[i] = null;
            return;
        }
    }
  }

  import java.util.Scanner;
  /**
   * Write a description of class UI here.
   *
   * @author Tim Schellartz
   * @version 17.02.2021
   */
  public class UI
  {
      Bank bank;
      Scanner sc = new Scanner(System.in);
      public UI(){
          bank = new Bank();
      }
      
      public void hauptmenü(){
          int eingabe = 0;
          while(eingabe != -1){
              System.out.println("---=== Hauptmenü ===---");
              System.out.println("(1) Kontenübersicht");
              System.out.println("(2) Kontodetails");
              System.out.println("(3) Einzahlung");
              System.out.println("(4) Auszahlung");
              System.out.println("(5) Überweisung");
              System.out.println("(6) Konto hinzufügen");
              System.out.println("(7) Konto löschen");
              System.out.println("(-1) Ende");
              System.out.print("Eingabe : ");
              eingabe = Integer.parseInt(sc.nextLine());
              if(eingabe == 1){
                  kontenübersicht();
              }else if (eingabe ==2){
                  kontodetails();
              }else if(eingabe == 3){
                  einzahlung();
              }else if(eingabe == 4){
                  abhebung();
              }else if(eingabe == 5){
                  uberweisung();
              }else if(eingabe == 6){
                  hinzufügen();
              }else if(eingabe == 7){
                  löschen();
              }else if(eingabe == -1){
                  System.out.println("Ende");
              }else{
                  System.out.println("Eingabe nicht korrekt! Bitte erneut eingeben.");
              }
          }
      }
      
      /**
       * Eine Kontenübersicht wird ausgegeben
       */
      public void kontenübersicht(){
          System.out.println(bank);
      }
      
      public void kontodetails(){
          System.out.print("Geben Sie die IBAN ein: ");
          String iban = sc.nextLine();
          Konto k = bank.sucheKonto(iban);
          if(k!=null){
              System.out.println(k);
          }else{
              System.out.println("IBAN nicht vorhanden");
          }
      }
      
      /**
       * Eine Einzahlung wird vorgenommen
       */
      public void einzahlung(){
          System.out.print("Geben Sie die IBAN ein: ");
          String iban = sc.nextLine();
          Konto k = bank.sucheKonto(iban);
          System.out.print("Geben Sie den Einzahlungsbetrag ein: ");
          double betrag =  Double.parseDouble(sc.nextLine());
          if(k!=null && betrag>0){
              k.einzahlen(betrag);
          }else{
              System.out.println("Einzahlung nicht möglich. Die IBAN wurde nicht gefunden oder der Betrag ist negativ.");
          }
      }
      
      /**
       * Geld abheben
       */
      public void abhebung(){
          System.out.print("Geben Sie die IBAN ein: ");
          String iban = sc.nextLine();
          Konto k = bank.sucheKonto(iban);
          System.out.print("Geben Sie den abzuhebenden Betrag ein: ");
          double betrag =  Double.parseDouble(sc.nextLine());
          if(k!=null && betrag>0){
              k.abheben(betrag);
          }else{
              System.out.println("Abhebung nicht möglich. Die IBAN wurde nicht gefunden oder der Betrag ist negativ.");
          }
      }
      
      /**
       * Eine Überweisung innerhalb einer Bank. Daher können die internen Kontonummer, also die Indizes des Arrays verwendet werden. 
       */
      public void uberweisung(){
          System.out.print("Geben Sie die IBAN des Absenders ein: ");
          String vonIBAN = sc.nextLine();
          Konto vonKonto = bank.sucheKonto(vonIBAN);
          System.out.print("Geben Sie die IBAN des Empfängers ein: ");
          String zuIBAN = sc.nextLine();
          Konto zuKonto = bank.sucheKonto(zuIBAN);
          System.out.print("Geben Sie den Überweisungsbetrag ein: ");
          double betrag =  Double.parseDouble(sc.nextLine());
          if(vonKonto!=null && zuKonto!=null && betrag>0){
              bank.überweisen(vonIBAN,zuIBAN, betrag);
          }else{
              System.out.println("Überweisung nicht möglich. Die IBAN wurde nicht gefunden oder der Betrag ist negativ.");
          }
      }
      
      public void hinzufügen(){
          System.out.print("Geben Sie die IBAN des neuen Kontos ein: ");
          String iban = sc.nextLine();
          System.out.print("Geben Sie den Namen des Kontoinhabers ein: ");
          String name = sc.nextLine();
          bank.addKonto(name, iban);
      }
      
      public void löschen(){
          System.out.print("Geben Sie die IBAN des zu löschenden Kontos ein: ");
          String iban = sc.nextLine();
          bank.removeKonto(iban);
      }
      
      public static void main(String[] args){
          UI ui = new UI();
          ui.hauptmenü();
      }
  }