Grundlage für "App" und Strukturierung

[Schlagdraufunschluss_124]

Cool es funktioniert, aber was macht "this" bzw. vorauf verweist es im genauen?Und warum muss ich jetzt dem Eingabe Konstruktor keine daten-Instanz mehr übergeben?
Und gibt eigentlich eine Möglichkeit ein Array über einen Getter auszugeben, z.B. so "daten.getFach()"?

 

[JStein52]

Und warum muss ich jetzt dem Eingabe Konstruktor keine daten-Instanz mehr übergeben?

Du übergibst ihm ja eine Daten-Instanz, das ist ja genau "this" . This ist eine Referenz auf die Instanz in deren Kontext du dich gerade befindest. Und das ist bei dir der Konstruktor einer Instanz von Daten

 

[JStein52]

Und gibt eigentlich eine Möglichkeit ein Array über einen Getter auszugeben, z.B. so "daten.getFach()"?

Du meinst sicher als Returnwert zurückzugeben. Ja:

public String[] getFach() {
.
.
        return einArray;
}

Edit: und der Aufruf könnte dann so aussehen:

String[] fach = daten.getFach();

 

[Schlagdraufunschluss_124]

Edit: und der Aufruf könnte dann so aussehen:

String[] fach = daten.getFach();

Des heißt ich muss in der Klasse oder Methode wo ichs ausgeben will, zB. ein lokales Stringarray erstellen, das ich wiederum durch ne For-Schleifen ausgeben kann oder?

 

[Robat]

Kommt auf die Ausgabe drauf an. Du kannst ein Array auch mit Arrays.toString(..) ausgeben lassen.

 

[Schlagdraufunschluss_124]

Code (Text): public String[] getFach() {
.
.
return einArray;
}

Leider liefert mir aber mein getter nichts mehr zurück, obwohl ich das Array befüllt hab-> Folge wieder eine NPE

    public int getFachanz(){
        return fachanz;
    }
    public String []getFach(){
        return fach;
    }
    public boolean[] getHauptfach(){
        return hauptfach;
    }

public boolean[] hauptFachFilling() {
        String fach[]= new String[daten.getFachanz()];
        fach=daten.getFach();
        int temp = 0;
        int hauptfachanz = 5;
        String hauptfachYN;
        boolean hauptfach[] = new boolean[daten.getFachanz()];
        Scanner scr = new Scanner(System.in);
    
        for (int i = 0; i < daten.getFachanz(); i++) {
            System.out.println(fach[i] + " -> Hauptfach (ja/nein)?: ");// Hier kommt die NPE, weil mein getter getFach nichts zurückliefert. Aber warum? Mein anderer getter von getFachanz funktioniert nämlich einwandfrei....
            hauptfachYN = scr.next();
            if (hauptfachYN.equals("ja")) {
                hauptfach[i] = true;
                temp++;
                if (temp == hauptfachanz) {
                    return hauptfach;
                }
            } else if (hauptfachYN.equals("nein")) {
                hauptfach[i] = false;
            } else {
                System.out.println("Falsche Eingabe. Programm wurde beendet!");
                System.exit(0);
            }
        }
        return hauptfach;

    }

 

[JStein52]

Das kannst du in einem Zug schreiben, die erste Zeile ist überflüssig:

        String[] fach = daten.getFach();

und in deinem Code sieht man leider nicht wo du jetzt das was die getFach() zurückliefert mal anlegst und füllst

 

[mrBrown]

Was ich initial meinte, was eher sowas.

psv main(...) {
    Daten daten = new Daten();
    Eingabe eingabe = new Eingabe(
}

 

[Schlagdraufunschluss_124]

1) @JStein52 Ich fülle mein Array wieder in der Hauptfachfilling Methode direkt ganz oben

public boolean[] hauptFachFilling() {
        String fach[]= new String[daten.getFachanz()];
        fach=daten.getFach();
        int temp = 0;
        int hauptfachanz = 5;
.
.

2)@mrBrown Was würde das verändern ?

Was ich initial meinte, was eher sowas.

psv main(...) {
    Daten daten = new Daten();
    Eingabe eingabe = new Eingabe(
}

 

[Harry Kane]

Ich habe mal versucht, hier produktiv mitzulesen, aber es war mir zuviel Aufwand, aus dem Klassenkontext gerissene Methoden zusammenzupuzzlen. Meine Vermutung ist, das du beim Zusammensetzen der Teile irgendwas falsch gemacht hast, aber solange du nur einzelnen Teile zeigst, ist es schwierig zu sagen, was und wo.

 

[Schlagdraufunschluss_124]

Ok:
Main

public class Main {
    public static void main(String[]args) {
        Daten daten = new Daten();
       
       
       
       
       
       
    }
   
   

}

Eingabe

import java.util.Scanner;

public class Eingabe {
    Daten daten;

    public Eingabe(Daten daten) {
        this.daten=daten;
    }

    public int fachanz() {
        int fachanz;
        Scanner scr;
        System.out.println("Fachanzahl: ");
        scr = new Scanner(System.in);
        fachanz = Integer.parseInt(scr.next());return fachanz;
    }

    public String[] StringFilling() {
        int i;
        Scanner scr;
        String fach[] = new String[daten.getFachanz()];
        scr = new Scanner(System.in);

        System.out.println("Fächer:");
        for (i = 0; i < daten.getFachanz(); i++) {
            fach[i] = scr.next();
        }
        return fach;
    }

    public boolean[] hauptFachFilling() {
        String fach[]= new String[daten.getFachanz()];
        fach=daten.getFach();
        int temp = 0;
        int hauptfachanz = 5;
        String hauptfachYN;
        boolean hauptfach[] = new boolean[daten.getFachanz()];
        Scanner scr = new Scanner(System.in);
       
        for (int i = 0; i < daten.getFachanz(); i++) {
            System.out.println(fach[i] + " -> Hauptfach (ja/nein)?: ");
            hauptfachYN = scr.next();
            if (hauptfachYN.equals("ja")) {
                hauptfach[i] = true;
                temp++;
                if (temp == hauptfachanz) {
                    return hauptfach;
                }
            } else if (hauptfachYN.equals("nein")) {
                hauptfach[i] = false;
            } else {
                System.out.println("Falsche Eingabe. Programm wurde beendet!");
                System.exit(0);
            }
        }
        return hauptfach;

    }

}

Ausgabe:

public class Ausgabe {
   Daten daten;

   public Ausgabe(Daten daten) {
       this.daten=daten;
       // Fachanzahl
       System.out.println("Fachanzahl:" +daten.getFachanz());
       
       // StringFilling
       for (String i : daten.getFach()) {
           System.out.println("Fachbelegung:" + i);
       }
       //HauptfachFilling
       for (int i=0; i<daten.getFachanz();i++){
           System.out.println(daten.getFach()+" -> Hauptfach: "+daten.getHauptfach());
       }

   }

}

Daten

public class Daten {
    Daten daten;
    int fachanz;
    String fach[];
    boolean[] hauptfach;

    public Daten() {
        //Instanz auf Eingabe
        Eingabe eingabe = new Eingabe(this);
       
        //Fachanzahl
        fachanz=eingabe.fachanz();
       
        //StringFilling
        String fach[] = new String[fachanz];
        fach = eingabe.StringFilling();
           
        //HauptfachFilling
        boolean[] hauptfach = new boolean[fachanz];
        hauptfach= eingabe.hauptFachFilling();
    }
   
    public int getFachanz(){
        return fachanz;
    }
    public String []getFach(){
        return fach;
    }
    public boolean[] getHauptfach(){
        return hauptfach;
    }

}

 

[JStein52]

//StringFilling
String fach[] = new String[fachanz];
fach = eingabe.StringFilling();

Das ist falsch. Damit erzeugst du eine neue lokale Variable namens fach und weist ihr den Rückgabewert von StringFilling zu. Lass einfach die zeile mit dem new ersatzlos weg !

Edit: ein Stück weiter unten hast du den gleichen Fehler mit hauptfach

 

[mrBrown]

2)@mrBrown Was würde das verändern ?

Eine vernünftige Trennung der Verantwortlichkeiten

 

[Schlagdraufunschluss_124]

@JStein52 Ist das so besser? (trifft das auch auf meine DatenKlasse oben zu?)

import java.util.Scanner;

public class Eingabe {
   Daten daten;

   public Eingabe(Daten daten) {
       this.daten=daten;
   }

   public int fachanz() {
       System.out.println("Fachanzahl: ");
       Scanner scr = new Scanner(System.in);
       int fachanz = Integer.parseInt(scr.next());
       return fachanz;
   }

   public String[] StringFilling() {
       String fach[] = new String[daten.getFachanz()];
       Scanner scr = new Scanner(System.in);

       System.out.println("Fächer:");
       for (int i = 0; i < daten.getFachanz(); i++) {
           fach[i] = scr.next();
       }
       return fach;
   }

   public boolean[] hauptFachFilling() {
       String fach[]=daten.getFach();
       int temp = 0;
       int hauptfachanz = 5;
       String hauptfachYN;
       boolean hauptfach[] = new boolean[daten.getFachanz()];
       Scanner scr = new Scanner(System.in);
     
       for (int i = 0; i < daten.getFachanz(); i++) {
           System.out.println(fach[i] + " -> Hauptfach (ja/nein)?: ");
           hauptfachYN = scr.next();
           if (hauptfachYN.equals("ja")) {
               hauptfach[i] = true;
               temp++;
               if (temp == hauptfachanz) {
                   return hauptfach;
               }
           } else if (hauptfachYN.equals("nein")) {
               hauptfach[i] = false;
           } else {
               System.out.println("Falsche Eingabe. Programm wurde beendet!");
               System.exit(0);
           }
       }
       return hauptfach;

   }

}

@mrBrown Dann würde ich ja die Eingabe Klasse ja 2 mal instanzieren, da ich ja nochmal eine Instanz in der DatenKlasse habe. Und kann auch nicht die Instanz in der Eingabe Klasse löschen, da ich die ja brauche, um auf die Methoden der EingabeKlasse zuzugreifen.

 

[mrBrown]

@mrBrown Dann würde ich ja die Eingabe Klasse ja 2 mal instanzieren, da ich ja nochmal eine Instanz in der DatenKlasse habe. Und kann auch nicht die Instanz in der Eingabe Klasse löschen, da ich die ja brauche, um auf die Methoden der EingabeKlasse zuzugreifen.

Du erzeugst *nur* in der Main die Eingabe-Instanz, die gibst du an die Stellen weiter, an denen du sie brauchst

 

[JStein52]

trifft das auch auf meine DatenKlasse oben zu?

Der Fehler war eigentlich in der Daten-Klasse !

 

[Schlagdraufunschluss_124]

@mrBrown Und wie und wo gebe ich sie weiter? Im Konstruktor?
@JStein52 Achso! Dann ja aber wieder in der Daten Klasse meine Getters wegwwerfen, oder?

 

[Schlagdraufunschluss_124]

public class Daten {

   public Daten() {
       
       //Instanz auf Eingabe
       
       //Fachanzahl
       int fachanz=eingabe.fachanz();
       
       //StringFilling
       String fach[]=fach = eingabe.StringFilling();
           
       //HauptfachFilling
       boolean[] hauptfach = eingabe.hauptFachFilling();
   }
   
   public int getFachanz(){
       return fachanz;
   }
   public String []getFach(){
       return fach;
   }
   public boolean[] getHauptfach(){
       return hauptfach;
   }

}

 

[mrBrown]

@mrBrown Und wie und wo gebe ich sie weiter? Im Konstruktor?

Ja genau

 

[JStein52]

War doch fast schon richtig. aus dem:

//StringFilling
String fach[] = new String[fachanz];
fach = eingabe.StringFilling();

wird

//StringFilling
fach = eingabe.StringFilling();

 

[Schlagdraufunschluss_124]

@mrBrown Wenn ich es so im Konstruktor übergebe:

public class Main {
   public static void main(String[]args) {
       Daten daten = new Daten(eingabe);
       Eingabe eingabe = new Eingabe (daten);  
      
   }

}

kennt er ja die Instanz "eingabe" ja noch gar nicht

 

[mrBrown]

Da reicht im Normalfall eine Unidirektionale Beziehung, entweder kennen die Daten die Eingabe, die die Eingabe die Daten

 

[Schlagdraufunschluss_124]

Mmh, und was soll ich der DatenKlasse übergeben? Denn dort brauch ich ja eine Instanz von der EingabeKlasse

public class Daten {
  

   public Daten(Eingabe eingabe) {
       //Instanz auf Eingabe
       //Eingabe eingabe = new Eingabe(this);
      
       //Fachanzahl
       int fachanz=eingabe.fachanz();
      
       //StringFilling
       String fach[] = eingabe.StringFilling();
          
       //HauptfachFilling
       boolean hauptfach[]= eingabe.hauptFachFilling();
   }
  
   public int getFachanz(){
       return fachanz;
   }
   public String []getFach(){
       return fach;
   }
   public boolean[] getHauptfach(){
       return hauptfach;
   }

}

Und was soll ich mit meinen Getters machen? Die kann ich wieder löschen, oder?
Womit eigentlich die ganze Idee der DatenKlasse hinfällig geworden wäre....

 

[mrBrown]

Brauchen die Daten wirklich eine Instanz der Eingabe oder kann man das vielleicht auch anders lösen?

 

[Schlagdraufunschluss_124]

Vielleicht... aber mir fällts gerade! nicht ein wie es gehen sollte.

 

[Schlagdraufunschluss_124]

Ok, ich komm leider echt nicht drauf Wie kann ich denn Methoden einer fremden Klasse aufrufen, ohne, dass ich eine Instanz von ihr habe?

 

[mrBrown]

Muss denn Daten irgendwelche Methode aus Eingabe aufrufen, oder reicht es vllt, wenn main Methoden auf Eingabe und Eingabe Methoden auf Daten aufruft?

 

[Schlagdraufunschluss_124]

Danke für die Antwort ! Jetzt verstehe ich was Du mit unidirektional gemeint hast.

Muss denn Daten irgendwelche Methode aus Eingabe aufrufen,

Warum hab ich dann überhaupt noch eine Daten Klasse? Nur zu Deklaration? Wäre dass dann nicht eine Gottklasse?

 

[mrBrown]

Die Datenklasse stellt die Daten da - irgendwo brauchst du die ja.

GottKlasse wäre das Gegenteil von dieser Trennung

 

[Joose]

Es ist unsinnig das die Klassen Daten ein Eingabe-Objekt instanziert bzw. überhaupt kennt.
Für eine "halbwegs" saubere Trennung brauchst du min drei Klassen -> eine Klasse für die Daten, eine Eingabe Klasse um Daten zu lesen, eine Ausgabe Klasse um Daten zu schreiben.
In der main-Methode schreibst du dann nur noch hin was der Reihe nach ausgeführt/passieren soll.

In diesem Beispiel habe ich bewusst darauf geachtet dass die Eingabe die Datenklasse nicht kennt um umgekehrt. Aber die Ausgabeklasse sehr wohl das Datenobjekt im Konstruktor übergeben bekommt.
(auch habe ich die Methodennamen etwas angepasst -> versuche nicht English und Deutsch zu mischen bzw. gib den Variablen auch logisch richtige Namen. Ein String[] enthält die Namen mehrere Faecher -> also ist der Name faecher besser geeignet als fach)

public class Main {
   public static void main(String[]args) {
       Daten daten = new Daten();
       Eingabe eingabe = new Eingabe();
       Ausgabe ausgabe = new Ausgabe(daten);
     
       int faecherAnzahl = eingabe.leseFaecherAnzahl()
       daten.setzeFachanz(faecherAnzahl);
     
       String[] faecher = eingabe.leseFaecher(daten.gibFaecherAnzahl());
       daten.setzeFaecher(faecher);
     
       boolean[] istHauptfach = eingabe.leseHauptfaecher(daten.gibFaecher());     
       daten.setzeHauptfach(istHauptfach);
     
       ausgabe.gibDatenAus();
   }
}

public class Eingabe {
   public Eingabe() {
       ....
   } 
   ....
}

public class Ausgabe {
   Daten daten;

   public Ausgabe(Daten daten) {
       this.daten = daten;
   }
 
   public void gibDatenAus() {
       // Fachanzahl
       System.out.println("Fachanzahl:" + daten.gibFaecherAnzahl());

       // StringFilling
       for (String i : daten.gibFaecher()) {
           System.out.println("Fachbelegung:" + i);
       }
       //HauptfachFilling
       for (int i = 0; i < daten.gibFaecherAnzahl(); i++) {
           System.out.println(daten.gibFaecher()[i] + " -> Hauptfach: " + daten.istHauptfach()[i]);
       }
   }
}

 

[Schlagdraufunschluss_124]

@mrBrown und @Joose Nice!! Vielen, vielen Dank für eure Hilfe und Unterstützung. Das hat mir wirklich sehr geholfen.
Edit: Dann behalte ich aber schon noch meine getters in Daten?So fände ich's eigentlich logisch.

 

[Schlagdraufunschluss_124]

Noch eine letzte Frage: Wie kann ich in meiner Eingabe Klasse jetzt ohne eine Instanz von der Daten Klasse auf so sachen wie zum Beispiel "fächeranz" zugreifen -> Hier zum Beispiel: String fächer = new String[(eigentlich)daten.getFächeranz]. Aber das geht ja jetzt nicht mehr. Wie soll ich's lösen?

import java.util.Scanner;

public class Eingabe {

   public Eingabe() {
   }

   public int leseFächeranz() {
       System.out.println("Fachanzahl: ");
       Scanner scr = new Scanner(System.in);
       int fächeranz = Integer.parseInt(scr.next());
       return fächeranz;
   }

   public String[] leseFächer() {
       String fächer[] = new String[];//Hier muss ich ja irgendwie die Arraygröße bestimmen ohne Instanz von "Daten".Aber wie ?
       Scanner scr = new Scanner(System.in);

       System.out.println("Fächer:");
       for (int i = 0; i < daten.getFächeranz(); i++) {
           fächer[i] = scr.next();
       }
       return fächer;
   }

   public boolean[] leseHauptfächer() {
       String fach[]=daten.getFächer();
       int temp = 0;
       int hauptfachanz = 5;
       String hauptfachYN;
       boolean hauptfächer[] = new boolean[daten.getFächeranz()];
       Scanner scr = new Scanner(System.in);
      
       for (int i = 0; i < daten.getFächeranz(); i++) {
           System.out.println(fach[i] + " -> Hauptfach (ja/nein)?: ");
           hauptfachYN = scr.next();
           if (hauptfachYN.equals("ja")) {
               hauptfächer[i] = true;
               temp++;
               if (temp == hauptfachanz) {
                   return hauptfächer;
               }
           } else if (hauptfachYN.equals("nein")) {
               hauptfächer[i] = false;
           } else {
               System.out.println("Falsche Eingabe. Programm wurde beendet!");
               System.exit(0);
           }
       }
       return hauptfächer;

   }

}

 

[Joose]

Noch eine letzte Frage: Wie kann ich in meiner Eingabe Klasse jetzt ohne eine Instanz von der Daten Klasse auf so sachen wie zum Beispiel "fächeranz" zugreifen -> Hier zum Beispiel: String fächer = new String[(eigentlich)daten.getFächeranz]. Aber das geht ja jetzt nicht mehr. Wie soll ich's lösen?

Tipp: Parameter
Schau dir doch mein Beispiel an was ich an die Methoden übergebe.

public class Main {
   public static void main(String[]args) {
       Daten daten = new Daten();
       Eingabe eingabe = new Eingabe();
       Ausgabe ausgabe = new Ausgabe(daten);
    
       int faecherAnzahl = eingabe.leseFaecherAnzahl()
       daten.setzeFachanz(faecherAnzahl);
    
       String[] faecher = eingabe.leseFaecher(daten.gibFaecherAnzahl());
       daten.setzeFaecher(faecher);
    
       boolean[] istHauptfach = eingabe.leseHauptfaecher(daten.gibFaecher());     
       daten.setzeHauptfach(istHauptfach);
    
       ausgabe.gibDatenAus();
   }
}

 

[Schlagdraufunschluss_124]

Ah natürlich. Sorry für die Frage. Irgendwie war ich zu blöd gescheit zu lesen
Danke für die Antwort!!