Advertisement
Guest User

Untitled

a guest
Nov 18th, 2016
98
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 29.78 KB | None | 0 0
  1. package start;
  2.  
  3. import controller.Menue;
  4. /*
  5.  * @author               Tolga Kara
  6.  * Email:                tolgakara2.0@gmail.com
  7.  * @version              Eclipse Neon, JavaSE-1.8
  8.  * Beschreibung          Die Klasse "Startet" dient zur Ausgabe der gewünschten Merhode. Im diesen Fall die Methode "auswahlMenue()" aus der Klasse "Menue"
  9.  * @since                17.10.2016
  10.  * letzte Änderung am   20.11.2016
  11.  */
  12.  
  13. public class Starter {
  14.  
  15.    
  16.     public static void main(String[] args) throws Exception {
  17.         Menue menu = new Menue();
  18.         menu.auswahlMenue();
  19.    
  20.    
  21.     }
  22.  
  23. }
  24.  
  25. package controller;
  26.  
  27. import model.*;
  28.  
  29. import java.util.Collections;
  30. import java.util.Comparator;
  31. /*
  32.  * @author               Tolga Kara
  33.  * Email:                tolgakara2.0@gmail.com
  34.  * @version              Eclipse Neon, JavaSE-1.8
  35.  * Beschreibung          Die Klasse "KontoDarstellungsFunktion" dient zur Darstellung der Kunden und Konten je nach ausgewaehlter Funktion des Benutzers.
  36.  * @since                17.10.2016
  37.  * letzte Änderung am   20.11.2016
  38.  */
  39. public class KontoDarstellungsFunktion implements Comparator<Kunde> {
  40.    
  41.     /**
  42.      * In dieser Methode werden Kunden mit Konten angezeigt durch die Eingabe der Kundennummer
  43.      */
  44.     public static void kundeMitKontoAnzeigenDurchKdnr(){
  45.        
  46.     }
  47.    
  48.     /**
  49.      * In dieser Methode werden Kunden mit Konten angezeigt durch die Eingabe des Namens
  50.      */
  51.     public static void kundeMitKontoAnzeigenDurchName() {
  52.    
  53.     }
  54.    
  55.     /**
  56.      * In dieser Methode werden Konten angezeigt durch die Eingabe der IBAN
  57.      */
  58.     public static void kontoAnzeigenDurchIBAN() {
  59.    
  60.     }
  61.    
  62.     /**
  63.      * In dieser Methode werden Kunden unsortiert angezeigt
  64.      */
  65.     public static void kundenUnsortiertAnzeigen() {
  66.    
  67.     }
  68.    
  69.     /**
  70.      * In dieser Methode wird verglichen welche Kundennummer größer ist als die anderen. Nach dem konzept (-1),(0),(1).
  71.      * Mithilfe von Comparator
  72.      */
  73.     @Override
  74.     public int compare(Kunde kunde0, Kunde kunde1) {
  75.        
  76.         return kunde0.getKundenNummer() - kunde1.getKundenNummer();
  77.     }
  78.    
  79.     /**
  80.      * In dieser Methode werden Kunden sortiert nach Aufsteigender Kundennummer angezeigt
  81.      */
  82.     public static void kundenSortiertAnzeigenNachAufsteigenderKdnr() {
  83.         Bank bank = new Bank();
  84.         Collections.sort(bank.getKundeList(), new KontoDarstellungsFunktion());
  85.     }
  86.    
  87.     /**
  88.      * In dieser Methode werden alle Konten unsortiert angezeigt
  89.      */
  90.     public static void alleKontenUnsortiertAnzeigen() {
  91.     Bank bank = new Bank();
  92.     bank.getKundeList();
  93.    
  94.     }
  95. }// end of class
  96.  
  97. package controller;
  98. import controller.KontoDarstellungsFunktion;
  99. import model.*;
  100. import io.*;
  101. /*
  102.  * @author               Tolga Kara
  103.  * Email:                tolgakara2.0@gmail.com
  104.  * @version              Eclipse Neon, JavaSE-1.8
  105.  * Beschreibung          Die Klasse "Menue" verwaltet die Menuepunkte. Ebenso erfasst die Klasse "Menue" von den jeweiligen Objekten die Werte
  106.                          der Variablen und legt Objekte an.
  107.  * @since                17.10.2016
  108.  * letzte Änderung am   20.11.2016
  109.  */
  110. public class Menue {
  111.    
  112.     /**
  113.      * Deklaration der Variable auswahl. Die Variable dient zur Auswahl des Users. Der Datentyp ist String, da wir eine fortlaufende 0 haben.
  114.      */
  115.     private String auswahl;
  116.    
  117.     /**
  118.      * In der Methode "auswahlMenue()" wird der User abgefragt , welche Menuepunkte er ausführen will, durch den Input des Users in der Variable "auswahl".
  119.      * Diese Methode steuert dann zu anderen Methoden und die Methode "auswahlMenue()" läuft in einer do/while-Schleife damit,
  120.      * wenn der User mit einen Menuepunkt fertig ist soll sich das Programm nicht beenden, sondern durch den User Input "10".
  121.      */
  122.     public void auswahlMenue() {
  123.  
  124.         do {
  125.             menuePunkte();
  126.  
  127.             auswahl = MeineEingabe.erfasseAuswahl("Auswahl: ");
  128.             switch (auswahl) {
  129.             case "01":
  130.                 liesPrivatkunde();
  131.                 System.out.println("Privatkunde wurde angelegt!");
  132.                 break;
  133.             case "02":
  134.                 liesFirmenkunde();
  135.                 System.out.println("Firmenkunde wurde angelegt!");
  136.                 break;
  137.             case "03":
  138.                 liesKontoUndKdnr();
  139.                 System.out.println("Konto und Kundennummer wurde angelegt!");
  140.                 break;
  141.             case "04":
  142.                 KontoDarstellungsFunktion.kundeMitKontoAnzeigenDurchKdnr();
  143.                 System.out.println("Kunde mit Konto durch Kundennummer wurde angezeigt!");
  144.                 break;
  145.             case "05":
  146.                 KontoDarstellungsFunktion.kundeMitKontoAnzeigenDurchName();
  147.                 System.out.println("Kunde mit Konto durch Name wurde angezeigt!");
  148.                 break;
  149.             case "06":
  150.                 KontoDarstellungsFunktion.kontoAnzeigenDurchIBAN();
  151.                 System.out.println("Kunde durch IBAN wurde angezeigt!");
  152.                 break;
  153.             case "07":
  154.                 KontoDarstellungsFunktion.kundenUnsortiertAnzeigen();
  155.                 System.out.println("Kunde wurde unsortiert angezeigt!");
  156.                 break;
  157.             case "08":
  158.                 KontoDarstellungsFunktion.kundenSortiertAnzeigenNachAufsteigenderKdnr();
  159.                 System.out.println("Kunde wurde sortiert nach aufsteigender Kundennummer angezeigt!");
  160.                 break;
  161.             case "09":
  162.                 KontoDarstellungsFunktion.alleKontenUnsortiertAnzeigen();
  163.                 System.out.println("Alle Konten wurden unsortiert angezeigt!");
  164.                 break;
  165.             case "10":
  166.                 System.out.println("Das Programm wurde Beendet!!");
  167.                 break;
  168.             }
  169.        
  170.         } while (!auswahl.equals("10"));
  171.  
  172.     }// end of Method "auswahlMenue()"
  173.    
  174.     /**
  175.      * In der Methode "liesPrivatkunde()" trägt der User Attribute der Klasse Privatkunde ein.
  176.      */
  177.     public void liesPrivatkunde() {
  178.         String vname = MeineEingabe.erfasseVorname("Vorname: ");
  179.         String nname = MeineEingabe.erfasseNachname("Nachname: ");
  180.         String telnummer = MeineEingabe.erfasseString("Telefonnummer: ");
  181.         String eMail = MeineEingabe.erfasseEmail("E-Mail: ");
  182.         String gebdat = MeineEingabe.erfasseDatum("Geburtsdatum: ");
  183.         int kndnr = MeineEingabe.erfasseInt("Kundennummer: ");
  184.         Adresse adr = liesAdresse();
  185.        
  186.         legePrivatkundeAn(vname, nname, telnummer, eMail, gebdat, kndnr, adr );
  187.  
  188.     }
  189.  
  190.     /**
  191.      * @param vname
  192.      * @param nname
  193.      * @param telnummer
  194.      * @param eMail
  195.      * @param gebdat
  196.      * @param kndnr
  197.      */
  198.     public Privatkunde legePrivatkundeAn(String vname, String nname, String telnummer, String eMail, String gebdat,
  199.             int kndnr, Adresse adr) {
  200.         Privatkunde privKunde = new Privatkunde(vname, nname, telnummer, eMail, gebdat, adr, kndnr);
  201.         privKunde.setVorname(vname);
  202.         privKunde.setNachname(nname);
  203.         privKunde.setTelefonNummer(telnummer);
  204.         privKunde.setMail(eMail);
  205.         privKunde.setGeburtsDatum(gebdat);
  206.         privKunde.setKundenNummer(kndnr);
  207.         privKunde.setAdresse(adr);
  208.        
  209.         return privKunde;
  210.     }
  211.  
  212.     public void liesFirmenkunde() {
  213.         String firmName = MeineEingabe.erfasseString("Firmennamen: ");
  214.         String telefonNummer = MeineEingabe.erfasseString("Telefonnummer: ");
  215.         String email = MeineEingabe.erfasseString("E-Mail: ");
  216.         Ansprechpartner partner = liesAnsprechpartner();
  217.         int kndnr = MeineEingabe.erfasseInt("Kundennummer: ");
  218.         Adresse adr = liesAdresse();
  219.        
  220.         legeFirmenkundeAn(firmName, telefonNummer, email, partner, adr, kndnr);
  221.     }
  222.  
  223.     /**
  224.      * @param firmName
  225.      * @param telefonNummer
  226.      * @param eMail
  227.      * @param kndnr
  228.      */
  229.     public Firmenkunde legeFirmenkundeAn(String firmName, String telefonNummer, String eMail,Ansprechpartner partner, Adresse adr, int kndnr) {
  230.         Firmenkunde firmKunde = new Firmenkunde(firmName, telefonNummer, eMail,partner, adr, kndnr);
  231.  
  232.         firmKunde.setFirmenName(firmName);
  233.         firmKunde.setTelefonNummer(telefonNummer);
  234.         firmKunde.setMail(eMail);
  235.         firmKunde.setPartner(partner);
  236.         firmKunde.setAdr(adr);
  237.         firmKunde.setKundenNummer(kndnr);
  238.  
  239.         return firmKunde;
  240.     }
  241.  
  242.     public Ansprechpartner liesAnsprechpartner() {
  243.         String vname = MeineEingabe.erfasseString("Vorname: ");
  244.         String nname = MeineEingabe.erfasseString("Nachname: ");
  245.        
  246.         return legeAnsprechpartnerAn(vname, nname);
  247.  
  248.     }
  249.  
  250.     /**
  251.      * @param vname
  252.      * @param nname
  253.      */
  254.     public Ansprechpartner legeAnsprechpartnerAn(String vname, String nname) {
  255.         Ansprechpartner partner = new Ansprechpartner(vname, nname);
  256.  
  257.         partner.setVorname(vname);
  258.         partner.setNachname(nname);
  259.         return partner;
  260.     }
  261.  
  262.     public void liesKontoUndKdnr() {
  263.         String iBAN = MeineEingabe.erfasseString("IBAN: ");
  264.         double kontoStand = MeineEingabe.erfasseDouble("Kontostand: ");
  265.         int kndnr = MeineEingabe.erfasseInt("Kundennummer: ");
  266.        
  267.         Konto konto = new Konto(iBAN, kontoStand, kndnr);
  268.        
  269.  
  270.     }
  271.  
  272.     public Adresse liesAdresse() {
  273.         String adresszeile1 = MeineEingabe.erfasseString("Adresszeile 1: ");
  274.         String adresszeile2 = MeineEingabe.erfasseString("Adresszeile 2: ");
  275.         String plz = MeineEingabe.erfassePostleitzahl("PLZ: ");
  276.         String ort = MeineEingabe.erfasseString("Ort: ");
  277.        
  278.         return legeAdresseAn(adresszeile1, adresszeile2, plz, ort);
  279.  
  280.     }
  281.  
  282.     /**
  283.      * @param adresszeile1
  284.      * @param adresszeile2
  285.      * @param plz
  286.      * @param ort
  287.      * @return
  288.      */
  289.     public Adresse legeAdresseAn(String adresszeile1, String adresszeile2, String plz, String ort) {
  290.         Adresse adr = new Adresse(adresszeile1, adresszeile2, plz, ort);
  291.  
  292.         adr.setAdresszeile1(adresszeile1);
  293.         adr.setAdresszeile2(adresszeile2);
  294.         adr.setPostleitZahl(plz);
  295.         adr.setOrt(ort);
  296.         return adr;
  297.        
  298.     }
  299.  
  300.     public void menuePunkte() {
  301.         System.out.println("(01) Privatkunde anlegen");
  302.         System.out.println("(02) Firmenkunde anlegen");
  303.         System.out.println("(03) Konto anlegen und Kundennummer zuordnen");
  304.         System.out.println("(04) Kunde mit Konten anzeigen (Auswahl durch Kundennummer)");
  305.         System.out.println("(05) Kunde mit Konten anzeigen (Auswahl durch Name)");
  306.         System.out.println("(06) Konto anzeigen (Auswahl durch IBAN)");
  307.         System.out.println("(07) Alle Kunden unsortiert anzeigen");
  308.         System.out.println("(08) Alle Kunden sortiert nach aufsteigender Kundenummer anzeigen");
  309.         System.out.println("(09) Alle Konten unsortiert anzeigen");
  310.         System.out.println("(10) Beenden");
  311.     }
  312.  
  313. }// end of class
  314.  
  315. package io;
  316.  
  317. import java.io.BufferedReader;
  318. import java.io.InputStreamReader;
  319. import java.util.regex.Matcher;
  320. import java.util.regex.Pattern;
  321.  
  322. /*
  323.  * @author               Tolga Kara
  324.  * Email:                tolgakara2.0@gmail.com
  325.  * @version              Eclipse Neon, JavaSE-1.8
  326.  * Beschreibung          Die Klasse "MeineEingabe" dient zur Überprüfung der Benutzereingabe.
  327.  * @since                17.10.2016
  328.  * letzte Aenderung am   20.11.2016
  329.  */
  330.  
  331. public class MeineEingabe {
  332.     public static final Pattern VALID_EMAIL_ADDRESS_REGEX =
  333.             Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
  334.    
  335.     public static final Pattern vorName_VALID = Pattern.compile("[A-Z][a-zA-Z]*");
  336.    
  337.     public static final Pattern nachName_VALID = Pattern.compile( "[a-zA-z]+([ '-][a-zA-Z]+)*");
  338.    
  339.     private static BufferedReader eingabe = new BufferedReader(new InputStreamReader(System.in));
  340.  
  341.     public static String erfasseText() throws Exception {
  342.         return eingabe.readLine();
  343.     }
  344.  
  345.     public static String erfasseString(String text) {
  346.         String ergebnis = "" ;
  347.  
  348.         boolean again = true;
  349.         while (again) {
  350.             System.out.print(text);
  351.             try {
  352.                 ergebnis = erfasseText();
  353.                 again = false;
  354.             }
  355.             catch (Exception e) {
  356.                 System.out.println("Leider war die Eingabe nicht korrekt. Versuchen Sie es erneut.");
  357.            
  358.             }
  359.         }
  360.         return ergebnis;
  361.     }
  362.  
  363.  
  364.     public static String erfasseAuswahl(String text) {
  365.         String ergebnis = "" ;
  366.  
  367.         boolean again = true;
  368.         while (again) {
  369.             System.out.print(text);
  370.             try {
  371.                 ergebnis = erfasseText();
  372.                 int laenge = String.valueOf(ergebnis).length();
  373.                 again = false;
  374.                 if(laenge != 2){
  375.                     again = true;
  376.                     throw new Exception();
  377.                
  378.                 }
  379.             }
  380.             catch (Exception e) {
  381.                 System.out.println("Leider war die Eingabe nicht korrekt. Versuchen Sie es erneut (01-10).");
  382.            
  383.             }
  384.         }
  385.         return ergebnis;
  386.     }
  387.    
  388.    
  389.    
  390.  
  391.     public static int erfasseInt(String text) {
  392.         int zahl = 0;
  393.  
  394.         boolean again = true;
  395.         while (again) {
  396.             System.out.print(text);
  397.            
  398.             try {
  399.                 zahl = Integer.parseInt(erfasseText());
  400.                 again = false;
  401.             } catch (Exception e) {
  402.             }
  403.             if (again) {
  404.                 System.out.println("Die Eingabe war fehlerhaft. Bitte probieren Sie es erneut.");
  405.             }
  406.         }
  407.  
  408.         return zahl;
  409.     }
  410.    
  411.     public static double erfasseDouble(String text) {
  412.         double zahl = 0;
  413.  
  414.         boolean again = true;
  415.         while (again) {
  416.             System.out.print(text);
  417.            
  418.             try {
  419.                 zahl = Double.parseDouble(erfasseText());
  420.                 if(zahl>=0){
  421.                 again = false;
  422.                 }
  423.             } catch (Exception e) {}
  424.             if (again) {
  425.                 System.out.println("Die Eingabe war fehlerhaft. Bitte probieren Sie es erneut.");
  426.             }
  427.         }
  428.  
  429.         return zahl;
  430.     }
  431.    
  432.     public static String erfasseDatum(String text) {
  433.         String datum = "";
  434.        
  435.         boolean again = true;
  436.         while (again) {
  437.             System.out.print(text);
  438.             try {
  439.                 datum = erfasseText();
  440.                 if (Pattern.matches("\\d{2}\\.\\d{2}\\.\\d{4}", datum)) {
  441.                     again = false; 
  442.                 }
  443.             } catch (Exception e) {
  444.             }
  445.             if (again) {
  446.                 System.out.println("Die Eingabe ist nicht Korrekt. Unser Datum Format ist so abgebildet DD.MM.YYYY!");
  447.             }
  448.         }
  449.        
  450.         return datum;
  451.     }
  452.    
  453.    
  454.     public static String erfassePostleitzahl(String text) {
  455.         String postleitzahl = "";
  456.        
  457.         boolean again = true;
  458.         while (again) {
  459.             System.out.print(text);
  460.             try {
  461.                 postleitzahl = erfasseText();
  462.                 if (Pattern.matches("\\d{5}", postleitzahl)) {
  463.                     again = false; 
  464.                 }
  465.             } catch (Exception e) {
  466.             }
  467.             if (again) {
  468.                 System.out.println("Die Eingabe ist nicht Korrekt. Achten Sie darauf das eine PLZ 5 Zahlen enth�lt!");
  469.             }
  470.  
  471.         }
  472.         return postleitzahl;
  473.     }
  474.    
  475.     public static String erfasseEmail(String text) {
  476.         String email = "";
  477.         boolean again = true;
  478.         while(again){
  479.             System.out.println(text);
  480.             try{
  481.             email = erfasseText();
  482.             Matcher matcher = VALID_EMAIL_ADDRESS_REGEX .matcher(email);
  483.             if(matcher.find()){
  484.                 again = false;
  485.             }
  486.         } catch (Exception e){}
  487.         if(again){
  488.             System.out.println("Die eingegebene E-Mail war nicht korrekt Probieren Sie es erneut!");
  489.         }
  490.         }
  491.         return email;
  492. }
  493.     // validate vorName
  494.        public static String erfasseVorname( String text )
  495.        {
  496.           String vorName = "";
  497.           boolean again = true;
  498.           while(again){
  499.               System.out.print(text);
  500.               try{
  501.                   vorName = erfasseText();
  502.                   Matcher matcher = vorName_VALID .matcher(vorName);
  503.                   if(matcher.find()){
  504.                       again = false;
  505.                   }
  506.               }catch(Exception e){}
  507.               if(again){
  508.                   System.out.println("Die Eingabe fuer den Vornamen war falsch. Versuchen Sie es erneut!!");
  509.               }
  510.             }
  511.           return vorName;
  512.        
  513.           } // end method erfasseVorname
  514.  
  515.        // validate nachName
  516.        public static String erfasseNachname( String text )
  517.        {
  518.           String nachName = "";
  519.           boolean again = true;
  520.           while(again){
  521.               System.out.print(text);
  522.               try{
  523.                   nachName = erfasseText();
  524.                   Matcher matcher = nachName_VALID .matcher(nachName);
  525.                   if(matcher.find()){
  526.                       again = false;
  527.                   }
  528.               }catch(Exception e){}
  529.               if(again){
  530.                   System.out.println("Die Eingabe f�r den Nachname war falsch. Versuchen Sie es erneut!!");
  531.               }
  532.             }
  533.           return nachName;
  534.        
  535.           } // end method erfasseNachname
  536.        
  537.    
  538.  
  539.    
  540. }// end of class
  541.  
  542. package model;
  543.  
  544. import java.util.Scanner;
  545.  
  546. /*
  547.  * @author               Tolga Kara
  548.  * Email:                tolgakara2.0@gmail.com
  549.  * @version              Eclipse Neon, JavaSE-1.8
  550.  * Beschreibung          Das Klasse-Model "Adresse" ist eine Schablone für das Objekt. Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  551.  *                       Diese wären:
  552.  *                       "adresszeile1", "adresszeile2", "plz", "ort".
  553.  * @since                17.10.2016
  554.  * letzte Änderung am   20.11.2016
  555.  */
  556.  
  557. public class Adresse {// start of class
  558.  
  559.     /**
  560.      * Deklaration von den Attributen adresszeile1, adresszeile2, postleitZahl und ort
  561.      */
  562.     private String adresszeile1; // Welche werte in 1 und 2 reinkommt
  563.     private String adresszeile2;
  564.     private String postleitZahl; // Fragen ob String oder Int
  565.     private String ort;
  566.  
  567.     Scanner sc = new Scanner(System.in);
  568.  
  569.     /**
  570.      * Konstruktor mit super()
  571.      *
  572.      * @param adresszeile1
  573.      * @param adresszeile2
  574.      * @param postleitZahl
  575.      * @param ort
  576.      */
  577.     public Adresse(String adresszeile1, String adresszeile2, String postleitZahl, String ort) {
  578.         super();
  579.         this.adresszeile1 = adresszeile1;
  580.         this.adresszeile2 = adresszeile2;
  581.         this.postleitZahl = postleitZahl;
  582.         this.ort = ort;
  583.     }
  584.  
  585.     /**
  586.      * @return the adresszeile1
  587.      */
  588.     public String getAdresszeile1() {
  589.         return adresszeile1;
  590.     }
  591.  
  592.     /**
  593.      * @param adresszeile1
  594.      *            the adresszeile1 to set
  595.      */
  596.     public void setAdresszeile1(String adresszeile1) {
  597.         this.adresszeile1 = adresszeile1;
  598.     }
  599.  
  600.     /**
  601.      * @return the adresszeile2
  602.      */
  603.     public String getAdresszeile2() {
  604.         return adresszeile2;
  605.     }
  606.  
  607.     /**
  608.      * @param adresszeile2
  609.      *            the adresszeile2 to set
  610.      */
  611.     public void setAdresszeile2(String adresszeile2) {
  612.     this.adresszeile2 = adresszeile2;
  613.     }
  614.  
  615.     /**
  616.      * @return the postleitZahl
  617.      */
  618.     public String getPostleitZahl() {
  619.         return postleitZahl;
  620.     }
  621.  
  622.     /**
  623.      * @param postleitZahl
  624.      *            the postleitZahl to set
  625.      */
  626.     public void setPostleitZahl(String postleitzahl) {
  627.         this.postleitZahl = postleitzahl;
  628.        
  629.     }
  630.  
  631.     /**
  632.      * @return the ort
  633.      */
  634.     public String getOrt() {
  635.         return ort;
  636.     }
  637.  
  638.     /**
  639.      * @param ort
  640.      *            the ort to set
  641.      */
  642.     public void setOrt(String ort) {
  643.         this.ort = ort;
  644.    
  645.     }
  646.     @Override
  647.     public String toString() {
  648.         return "Adresse [Adresszeile 1= " + adresszeile1 + ", Adresszeile 2= " + adresszeile2 + ", PLZ= "
  649.                 + postleitZahl + ", Ort= " + ort + " ]";
  650.     }
  651. }// end of class
  652.  
  653. package model;
  654.  
  655. /*
  656.  * @author               Tolga Kara
  657.  * Email:                tolgakara2.0@gmail.com
  658.  * @version              Eclipse Neon, JavaSE-1.8
  659.  * Beschreibung          Das Klasse-Model "Ansprechpartner" ist eine Schablone für das Objekt. Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  660.  *                       Diese wären:
  661.  *                       "vorname", "nachname".
  662.  * @since                17.10.2016
  663.  * letzte Änderung am   20.11.2016
  664.  */
  665.  
  666. public class Ansprechpartner {// start of class
  667.     /**
  668.      * Deklaration von Attribute
  669.      */
  670.     private String vorname;
  671.     private String nachname;
  672.  
  673.     /**
  674.      * Konstruktor mit super()
  675.      * @param vorname
  676.      * @param nachname
  677.      */
  678.     public Ansprechpartner(String vorname, String nachname) {
  679.         super();
  680.         this.vorname = vorname;
  681.         this.nachname = nachname;
  682.     }// end of Konstruktor
  683.  
  684.    
  685.  
  686.     /**
  687.      * @return the vorname
  688.      */
  689.     public String getVorname() {
  690.         return vorname;
  691.     }
  692.  
  693.     /**
  694.      * @param vorname
  695.      *            the vorname to set
  696.      */
  697.     public void setVorname(String vorname) {
  698.         this.vorname = vorname;
  699.     }
  700.  
  701.     /**
  702.      * @return the nachname
  703.      */
  704.     public String getNachname() {
  705.         return nachname;
  706.     }
  707.  
  708.     /**
  709.      * @param nachname
  710.      *            the nachname to set
  711.      */
  712.     public void setNachname(String nachname) {
  713.         this.nachname = nachname;
  714.     }
  715.    
  716.     @Override
  717.     public String toString() {
  718.         return "Ansprechpartner [Vorname= " + vorname + ", Nachname= " + nachname +" ]";
  719.     }
  720.  
  721. }// end of class
  722.  
  723. package model;
  724.  
  725. import java.util.ArrayList;
  726.  
  727. /*
  728.  * @author               Tolga Kara
  729.  * Email:                tolgakara2.0@gmail.com
  730.  * @version              Eclipse Neon, JavaSE-1.8
  731.  * Beschreibung          Das Klasse-Model "Bank" ist eine Schablone für das Objekt. Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  732.  *                       Diese wären:
  733.  *                       "name", "bic", "adresse". Die "Bank" verwaltet die ArrayList "Kunde".
  734.  * @since                17.10.2016
  735.  * letzte Änderung am   20.11.2016
  736.  */
  737.  
  738. public class Bank {// start of class
  739.  
  740.     /**
  741.      * Deklaration von Attribute
  742.      */
  743.     private String name;
  744.     private String bic;
  745.     private Adresse adresse;
  746.     private ArrayList<Kunde> kundeList= new ArrayList<Kunde>();
  747.  
  748.     /**
  749.      * Konstrukter mit super()
  750.      */
  751.     public Bank() {
  752.         super();
  753.  
  754.  
  755.     }// end of Konstruktor
  756.  
  757.     /**
  758.      * @return the name
  759.      */
  760.     public String getName() {
  761.         return name;
  762.     }
  763.  
  764.     /**
  765.      * @param name
  766.      *            the name to set
  767.      */
  768.     public void setName(String name) {
  769.         this.name = name;
  770.     }
  771.  
  772.     /**
  773.      * @return the bIC
  774.      */
  775.     public String getbIC() {
  776.         return bic;
  777.     }
  778.  
  779.     /**
  780.      * @param bIC
  781.      *            the bIC to set
  782.      */
  783.     public void setbIC(String bic) {
  784.         this.bic = bic;
  785.     }
  786.  
  787.     public Adresse getAdresse() {
  788.         return adresse;
  789.     }
  790.  
  791.     public void setAdresse(Adresse adresse) {
  792.         this.adresse = adresse;
  793.     }
  794.  
  795.     /**
  796.      * @return the kundeList
  797.      */
  798.     public ArrayList<Kunde> getKundeList() {
  799.         return kundeList;
  800.     }
  801.  
  802.     /**
  803.      * @param kundeList the kundeList to set
  804.      */
  805.     public Bank addKunde (Kunde kunde){
  806.         kundeList.add(kunde);
  807.         return this;
  808.        
  809.     }
  810.    
  811.     public Bank setKundeList(ArrayList<Kunde> kundeList) {
  812.         this.kundeList = kundeList;
  813.         return this;
  814.        
  815.     }
  816.  
  817.     /**
  818.      * Die Ausgabe von Bank
  819.      */
  820.    
  821.     @Override
  822.     public String toString() {
  823.         return "Bank [Name= " + name+ ", BIC= " + bic + ", Adresse= "
  824.                 + adresse + ", Kunden= " + kundeList + " ]";
  825.     }
  826.  
  827. }// end of class
  828.  
  829. package model;
  830. /*
  831.  * @author               Tolga Kara
  832.  * Email:                tolgakara2.0@gmail.com
  833.  * @version              Eclipse Neon, JavaSE-1.8
  834.  * Beschreibung          Das Klasse-Model "Firmenkunde" ist eine Schablone für das Objekt. Die Klasse "Firmenkunde" erbt von der Klasse "Kunde".
  835.  *                       Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  836.  *                       Diese wären:
  837.  *                       "firmenNamen", "telefonNummer", "email", "partner", "adr".
  838.  * @since                17.10.2016
  839.  * letzte Aenderung am   20.11.2016
  840.  */
  841. public class Firmenkunde extends Kunde {// start of class
  842.     /**
  843.      * Deklaration von Attribute
  844.      */
  845.    
  846.     private String firmenName;
  847.     private String telefonNummer;
  848.     private String email;
  849.     private Ansprechpartner partner;
  850.     private Adresse adr;
  851.    
  852.  
  853.    
  854.     /**
  855.      * Konstruktor mit super()
  856.      */
  857.     public Firmenkunde(String firmenName, String telefonNummer, String email, Ansprechpartner partner, Adresse adresse, int kundenNummer) {
  858.         super(kundenNummer, adresse);
  859.         this.firmenName = firmenName;
  860.         this.telefonNummer = telefonNummer;
  861.         this.email = email;
  862.         this.partner = partner;
  863.         this.adr = adresse;
  864.         this.kundenNummer = kundenNummer;
  865.        
  866.        
  867.        
  868.    
  869.     }// end of Konstruktor
  870.    
  871.    
  872.    
  873.    
  874.    
  875.     /**
  876.      * @return the firmenName
  877.      */
  878.     public String getFirmenName() {
  879.         return firmenName;
  880.     }
  881.    
  882.     /**
  883.      * @param firmenName the firmenName to set
  884.      */
  885.     public void setFirmenName(String firmenName) {
  886.         this.firmenName = firmenName;
  887.     }
  888.    
  889.    
  890.     /**
  891.      * @return the telefonNummer
  892.      */
  893.     public String getTelefonNummer() {
  894.         return telefonNummer;
  895.     }
  896.     /**
  897.      * @param telefonNummer the telefonNummer to set
  898.      */
  899.     public void setTelefonNummer(String telefonNummer) {
  900.         this.telefonNummer = telefonNummer;
  901.     }
  902.    
  903.    
  904.     /**
  905.      * @return the eMail
  906.      */
  907.     public String getMail() {
  908.         return email;
  909.     }
  910.     /**
  911.      * @param email the eMail to set
  912.      */
  913.     public void setMail(String email) {
  914.         this.email = email;
  915.     }
  916.    
  917.    
  918.     public Ansprechpartner getPartner() {
  919.         return partner;
  920.     }
  921.  
  922.     public void setPartner(Ansprechpartner partner) {
  923.         this.partner = partner;
  924.     }
  925.  
  926.  
  927.  
  928.  
  929.  
  930.     public Adresse getAdr() {
  931.         return adr;
  932.     }
  933.  
  934.  
  935.  
  936.  
  937.  
  938.     public void setAdr(Adresse adr) {
  939.         this.adr = adr;
  940.     }
  941.    
  942.     @Override
  943.     public String toString() {
  944.         return "Firmenkunde [Firmenname= " + firmenName + ", Telefonnummer= " + telefonNummer + ", E-Mail= "
  945.                 + email + ", Ansprechpartner= " + partner +", Adresse= "+adr+ "]";
  946.     }
  947.    
  948.    
  949.    
  950. }// end of class
  951.  
  952. package model;
  953.  
  954. /*
  955.  * @author               Tolga Kara
  956.  * Email:                tolgakara2.0@gmail.com
  957.  * @version              Eclipse Neon, JavaSE-1.8
  958.  * Beschreibung          Das Klasse-Model "Konto" ist eine Schablone für das Objekt. Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  959.  *                       Diese wären:
  960.  *                       "iban", "kontoStand", "kundennr".
  961.  * @since                17.10.2016
  962.  * letzte Änderung am   20.11.2016
  963.  */
  964.  
  965. public class Konto {// start of class
  966.     /**
  967.      * Deklaration von Attribute
  968.      */
  969.     private String iban;
  970.     private double kontoStand;
  971.     private int kundennr;
  972.    
  973.    
  974.     /**
  975.      * Konstruktor mit super()
  976.      */
  977.     public Konto(String iBAN, double kontoStand, int kndnr ) {
  978.         super();
  979.         this.iban = iBAN;
  980.         this.kontoStand = kontoStand;
  981.        
  982.     }// end of Konstruktor
  983.    
  984.  
  985.     /**
  986.      * @return the iBAN
  987.      */
  988.     public String getiBAN() {
  989.         return iban;
  990.     }
  991.     /**
  992.      * @param iBAN the iBAN to set
  993.      */
  994.     public Konto setiBAN(String iBAN) {
  995.         this.iban = iBAN;
  996.         return this;
  997.     }
  998.     /**
  999.      * @return the kontoStand
  1000.      */
  1001.     public double getKontoStand() {
  1002.         return kontoStand;
  1003.     }
  1004.     /**
  1005.      * @param kontoStand the kontoStand to set
  1006.      */
  1007.     public Konto setKontoStand(float kontoStand) {
  1008.         this.kontoStand = kontoStand;
  1009.         return this;
  1010.     }
  1011.  
  1012.  
  1013.     public int getKundennr() {
  1014.         return kundennr;
  1015.     }
  1016.  
  1017.  
  1018.     public Konto setKundennr(int kundennr) {
  1019.         this.kundennr = kundennr;
  1020.         return this;
  1021.     }
  1022.    
  1023.     public String toString() {
  1024.         return "Konto [IBAN= " + iban+ ", Kontostand= " + kontoStand+ ", Kundennummer= "
  1025.                 + kundennr + "]";
  1026.     }
  1027.    
  1028.    
  1029. }// end of class
  1030.  
  1031. package model;
  1032.  
  1033. import java.util.ArrayList;
  1034.  
  1035. /*
  1036.  * @author               Tolga Kara
  1037.  * Email:                tolgakara2.0@gmail.com
  1038.  * @version              Eclipse Neon, JavaSE-1.8
  1039.  * Beschreibung          Das Klasse-Model "Kunde" ist eine Schablone für das Objekt. Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  1040.  *                       Die Klasse "Kunde" verwaltet die Arraylist "Konto". Ein Kunde kann 10 Konten erhalten.
  1041.  *                       Diese wären:
  1042.  *                       "kundenNummer", "adresse".
  1043.  * @since                17.10.2016
  1044.  * letzte Änderung am   20.11.2016
  1045.  */
  1046.  
  1047. abstract public class Kunde {// start of class
  1048.     /**
  1049.      * Deklaration von Attribute
  1050.      */
  1051.     protected int kundenNummer;
  1052.     private Adresse adresse;
  1053.    
  1054.     private ArrayList<Konto> kontoListe = new ArrayList<Konto>(10);
  1055.    
  1056.  
  1057.     /**
  1058.      * @return the adresse
  1059.      */
  1060.     public Adresse getAdresse() {
  1061.         return adresse;
  1062.     }
  1063.  
  1064.  
  1065.  
  1066.  
  1067.     /**
  1068.      * @param adresse the adresse to set
  1069.      */
  1070.     public void setAdresse(Adresse adresse) {
  1071.         this.adresse = adresse;
  1072.     }
  1073.  
  1074.  
  1075.  
  1076.  
  1077.     /**
  1078.      * @return the kontoListe
  1079.      */
  1080.     public ArrayList<Konto> getKontoListe() {
  1081.         return kontoListe;
  1082.     }
  1083.  
  1084.  
  1085.     public Kunde addKonto(Konto konto) {
  1086.         kontoListe.add(konto);
  1087.         return this;
  1088.     }
  1089.    
  1090.  
  1091.     /**
  1092.      * @param kontoListe the kontoListe to set
  1093.      */
  1094.     public Kunde setKontoListe(ArrayList<Konto> kontoListe) {
  1095.         this.kontoListe = kontoListe;
  1096.         return this;
  1097.     }
  1098.  
  1099.  
  1100.  
  1101.  
  1102.     /**
  1103.      * Konstruktor mit super()
  1104.      */
  1105.     public Kunde(int kundenNummer, Adresse adresse) {
  1106.         super();
  1107.         this.kundenNummer = kundenNummer;
  1108.         this.adresse = adresse;
  1109.     }
  1110.    
  1111.  
  1112.  
  1113.  
  1114.     /**
  1115.      * @return the kundenNummer
  1116.      */
  1117.     public int getKundenNummer() {
  1118.         return kundenNummer;
  1119.     }
  1120.  
  1121.     /**
  1122.      * @param kundenNummer the kundenNummer to set
  1123.      */
  1124.     public Kunde setKundenNummer(int kundenNummer) {
  1125.         this.kundenNummer = kundenNummer;
  1126.         return this;
  1127.     }
  1128.    
  1129.     public String toString() {
  1130.         return "Kunde [Kundennummer= " + kundenNummer+ ", Adresse= " + adresse + ", Kontenliste= "
  1131.                 + kontoListe +"]";
  1132.     }
  1133.  
  1134. }// end of class
  1135.  
  1136. package model;
  1137.  
  1138. /*
  1139.  * @author               Tolga Kara
  1140.  * Email:                tolgakara2.0@gmail.com
  1141.  * @version              Eclipse Neon, JavaSE-1.8
  1142.  * Beschreibung          Das Klasse-Model "Privatkunde" ist eine Schablone für das Objekt. Die Klasse "Privatkunde" erbt von der Klasse "Kunde".
  1143.  *                       Es verarbeitet die Eingabe und ebenso enthält es Attribute.
  1144.  *                       Diese wären:
  1145.  *                       "vorname", "nachname", "telefonNummer", "email", "geburtsDatum", "adresse".
  1146.  * @since                17.10.2016
  1147.  * letzte Änderung am   20.11.2016
  1148.  */
  1149.  
  1150. public class Privatkunde extends Kunde {// start of class
  1151.     /**
  1152.      * Deklaration von Attribute
  1153.      */
  1154.  
  1155.     private String vorname;
  1156.     private String nachname;
  1157.     private String telefonNummer;
  1158.     private String email;
  1159.     private String geburtsDatum;
  1160.     private Adresse adresse;
  1161.  
  1162.     /**
  1163.      * Konstruktor mit super()
  1164.      */
  1165.     public Privatkunde(String vorname, String nachname, String telefonNummer, String eMail, String geburtsDatum, Adresse adresse, int kundenNummer) {
  1166.         super(kundenNummer, adresse);
  1167.         this.vorname = vorname;
  1168.         this.nachname = nachname;
  1169.         this.telefonNummer = telefonNummer;
  1170.         this.email = eMail;
  1171.         this.geburtsDatum = geburtsDatum;
  1172.         this.adresse = adresse;
  1173.         this.kundenNummer = kundenNummer;
  1174.  
  1175.     } // end of Konstruktor
  1176.  
  1177.     /**
  1178.      * @return the vorname
  1179.      */
  1180.     public String getVorname() {
  1181.         return vorname;
  1182.     }
  1183.  
  1184.     /**
  1185.      * @param vorname
  1186.      *            the vorname to set
  1187.      */
  1188.     public void setVorname(String vorname) {
  1189.         this.vorname = vorname;
  1190.     }
  1191.  
  1192.     /**
  1193.      * @return the nachname
  1194.      */
  1195.     public String getNachname() {
  1196.         return nachname;
  1197.     }
  1198.  
  1199.     /**
  1200.      * @param nachname
  1201.      *            the nachname to set
  1202.      */
  1203.     public void setNachname(String nachname) {
  1204.         this.nachname = nachname;
  1205.     }
  1206.  
  1207.     /**
  1208.      * @return the telefonNummer
  1209.      */
  1210.     public String getTelefonNummer() {
  1211.         return telefonNummer;
  1212.     }
  1213.  
  1214.     /**
  1215.      * @param telefonNummer
  1216.      *            the telefonNummer to set
  1217.      */
  1218.     public void setTelefonNummer(String telefonNummer) {
  1219.         this.telefonNummer = telefonNummer;
  1220.     }
  1221.  
  1222.     /**
  1223.      * @return the eMail
  1224.      */
  1225.     public String getMail() {
  1226.         return email;
  1227.     }
  1228.  
  1229.     /**
  1230.      * @param eMail
  1231.      *            the eMail to set
  1232.      */
  1233.     public void setMail(String eMail) {
  1234.         this.email = eMail;
  1235.     }
  1236.  
  1237.     /**
  1238.      * @return the geburtsDatum
  1239.      */
  1240.     public String getGeburtsDatum() {
  1241.         return geburtsDatum;
  1242.     }
  1243.  
  1244.     /**
  1245.      * @param geburtsDatum
  1246.      *            the geburtsDatum to set
  1247.      */
  1248.     public void setGeburtsDatum(String geburtsDatum) {
  1249.         this.geburtsDatum = geburtsDatum;
  1250.     }
  1251.  
  1252.     public Adresse getAdresse() {
  1253.         return adresse;
  1254.     }
  1255.  
  1256.     public void setAdresse(Adresse adresse) {
  1257.         this.adresse = adresse;
  1258.     }
  1259.    
  1260.     public String toString() {
  1261.         return "Privatkunde [Vorname= " + vorname+ ", Nachname= " + nachname+ ", Telefonnummer= " + telefonNummer + ", E-Mail= "
  1262.                 + email + ", Geburtsdatum= " + geburtsDatum+", Adresse= "+adresse+ ", Kundennummer= " + kundenNummer + "]";
  1263.     }
  1264.  
  1265. }// end of class
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement