# Grundlage für "App" und Strukturierung



## Schlagdraufunschluss_124 (21. Aug 2017)

Hallo! Ich versuche eine App zu programmieren, die mir meinen Notendurchschnitt ausrechnet und das alles etwas grafisch umzusetzen . Hierbei soll man seine Schulfächer und seine Noten in eine Tabelle eingeben können( Am besten  wäre es wenn ich es vielleicht wie in Excel lösen könnte, sprich dass man vielleicht jedes Feld anklicken kann; Andernfalls müsste ich dann die Eingabe eben anders regeln...)  Allerdings bin ich mir unsicher, wie ich das ganze Projekt strukturieren soll. Meine Idee war es eine Boot-Klasse zu erstellen, die die Hauptklasse aufruft. Hier sollte dann alles "zusammenlaufen". Vielleicht kann man die "Eingabe", sowie die Grafik in eine andere Klasse auch separieren.Und wie sollte ich die Tabelle mit den Feldern angehen (Etwa für jedes einzelne Feld ein TextField?-Das würde doch keinen Sinn machen oder ?)

Danke für eure Antworten!


----------



## Flown (22. Aug 2017)

Ich würde mal sagen, du fängst an die Funktionlität deines Models abzubilden und dann fügst du die UI hinzu. Überlege dir gut, welche UI Widgets für deine Anzeige geeignet sind und zeichne es evtl. für dich auf. Wenn du dann zufrieden bist, machen.


----------



## Schlagdraufunschluss_124 (22. Aug 2017)

OK, danke für die Antwort! Wenn ich es richtig verstanden habe, dann soll ich also meine Struktur in ein Schaublid zeichnen?


----------



## mrBrown (22. Aug 2017)

Ein Überblick über die Struktur schadet nie, aber er meinte eher ein Bild deiner GUI


----------



## JuKu (22. Aug 2017)

Am besten solltest du dir erstmal ein UI Mookup erstellen, wie es aussehen soll.
Dann eine Activity, die die Daten eingibt, vllt. noch eine, die am Ende das Ergebnis präsentiert.
Wozu brauchst du eine Boot Klasse?


----------



## Schlagdraufunschluss_124 (22. Aug 2017)

Eine Boot-Klasse zum die App zu starten.... aber hast recht ist eigentlich überflüssig.
Danke für deine Antwort!


----------



## mrBrown (22. Aug 2017)

Soll es eine Android-App werden?


----------



## Schlagdraufunschluss_124 (22. Aug 2017)

Nein eigentlich nicht. Die App programmiere ich auch eher zum lernen und zum sinnvollen strukturieren eines Programms.


----------



## mrBrown (22. Aug 2017)

Also ein ganz normales Java-Programm?


----------



## Schlagdraufunschluss_124 (23. Aug 2017)

Im Prinzip ja...
Ich bin hier gerade aber schon auf das erste Problem gestoßen:
1) Ich versuche, dass meine Tabelle, wo man später alles einträgt, eine variable Zeilenzahl hat-sodass der Benutzer auf Knopfdruck eine weitere Zeile hinzufügen/entfernen kann.
2)Ich hab versucht den Inhalt der Zeilen per Variablen abzugreifen, allerdings ist der String im Sysout dauernd "null"- warum??

Hier der Code:

```
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.Scanner;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableModel;

public class Tabelle extends JFrame {  
    JTable table;    
    String column2;
    static String column1;  

    public Tabelle() {    
        setLayout(new FlowLayout());      
        String[] spaltenName = {"Fach","Note"};      
        String [][] data = {
                {column1,column2}  
        };
          
        table = new JTable (data,spaltenName);
        table.setPreferredScrollableViewportSize(new Dimension(500,50));
        table.setFillsViewportHeight(true);
      
        JScrollPane scrollPane = new JScrollPane(table);
        add(scrollPane);
    }
    public static void main (String [] args){
        Tabelle gui = new Tabelle();
        gui.setDefaultCloseOperation(gui.EXIT_ON_CLOSE);
        gui.setVisible(true);
        gui.setSize(600,200);      
        while(true)
            System.out.println("Zeilen"+column1);      
    }
}
```

PS: Achja, und warum muss ich column1 zu "static" machen-Gibts da auch ne andere Lösung?


----------



## JStein52 (23. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Achja, und warum muss ich column1 zu "static" machen-Gibts da auch ne andere Lösung?


weil du es in main benutzt. Schreibe dort gui.column1  oder besser noch mach dir getter-Funktionen


----------



## JStein52 (23. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Ich hab versucht den Inhalt der Zeilen per Variablen abzugreifen


welchen Inhalt denn ? deine Table hat doch gar keinen Inhalt


----------



## JuKu (23. Aug 2017)

Ich dachte bisher auch, es geht um eine Android App...
Was steht denn in der Tabelle drin? Die Noten? Eier? Werde mal bitte konkreter.


----------



## Schlagdraufunschluss_124 (23. Aug 2017)

In der Tabelle sollen die Fächer und Noten selbst eingetragen werden. Ich hab schonmal am Anfang die Tabelle halt mit irgendwas befüllt, allerdings ändert sich nichts im Sysout, wenn ich selbe in der Tabelle etwas eingetragen. Sprich es kommt immer der selbe Sysout.
@JStein52 Danke für den Tipp mit der getter-Methode, die Ausgabe an sich funtioniert jetzt.


```
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.Scanner;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableModel;

public class Tabelle extends JFrame {

    JTable table;

    String column2="g";
    private String column1="f";

    public Tabelle() {

        setLayout(new FlowLayout());

        String[] spaltenName = { "Fach", "Note" };

        String[][] data = { { column1, column2 }, { "hallo", "hallo" }

        };

        table = new JTable(data, spaltenName);
        table.setPreferredScrollableViewportSize(new Dimension(500, 50));
        table.setFillsViewportHeight(true);

        JScrollPane scrollPane = new JScrollPane(table);
        add(scrollPane);

    }

    public static void main (String [] args){
        Tabelle gui = new Tabelle();
        gui.setDefaultCloseOperation(gui.EXIT_ON_CLOSE);
        gui.setVisible(true);
        gui.setSize(600,200);
        while(true)
        System.out.println("Zeile"+gui.getColumn());
       
       
   
   

   
}
    public String getColumn(){
        return column1;
    }
}
```


----------



## Harry Kane (23. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Sprich es kommt immer der selbe Sysout.


Du gibst den Wert für "column1" aus. Der wird im gezeigten Code aber nie geändert bzw. neu zugewiesen. Was soll sich da also ändern?
Entweder du enthältst uns wichtige Teile deines Codes vor, oder du hast ein großes Verständnisproblem.


----------



## JStein52 (23. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> allerdings ändert sich nichts im Sysout, wenn ich selbe in der Tabelle etwas eingetragen


Ja, du holst es dir ja auch nicht von der JTable wieder sondern aus dem Attribut deiner Klasse. Und das ändert sich natürlich nicht. Schau dir mal JTable und zugehörige TableModels an: http://openbook.rheinwerk-verlag.de...19_019.htm#mj4d8b3bc0b550304f97713fa1788ff0f6

Edit: uups, zu langsam


----------



## Schlagdraufunschluss_124 (23. Aug 2017)

Ich habe irgendwie immernoch dasselbe Problem
Bin ich zu einfach zu blöd oder woran liegt es diesmal..
Ich dachte nämlich mit "getValueAt" greife ich nicht mehr aud das Attribut zu...

```
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.Scanner;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;

public class Tabelle extends JFrame implements TableModel {

   JTable table;

   private int col = 2;
   private int row = 1;
   private Object name;
   private static Object value;

   String column2 = "g";
   private String column1 = "f";

   public Tabelle() {

       setLayout(new FlowLayout());

       String[] spaltenName = { "Fach", "Note" };

       String[][] data = { { column1, column2 }, { "hallo", "hallo" }

       };

       table = new JTable(data, spaltenName);
       table.setPreferredScrollableViewportSize(new Dimension(500, 50));
       table.setFillsViewportHeight(true);

       JScrollPane scrollPane = new JScrollPane(table);
       add(scrollPane);

   }

   public static void main(String[] args) {
       Tabelle gui = new Tabelle();
       gui.setDefaultCloseOperation(gui.EXIT_ON_CLOSE);
       gui.setVisible(true);
       gui.setSize(600, 200);
       System.out.println("Col"+gui.getColumnCount());
       System.out.println("Row"+gui.getRowCount());
       gui.ausgabe();

   }

   
   public void ausgabe() {

           System.out.println("Value" + name);
   }

   @Override
   public int getColumnCount() {
       return col;
   }


   @Override
   public int getRowCount() {
       return row;
   }

   @Override
   public Object getValueAt(int col, int row) {       // Greife ich hier immer noch auf ein Attribut zu?
       return name;
   }

   
   
   @Override
   public void addTableModelListener(TableModelListener l) {
       // TODO Auto-generated method stub
       
   }

   @Override
   public Class<?> getColumnClass(int columnIndex) {
       // TODO Auto-generated method stub
       return null;
   }

   @Override
   public String getColumnName(int columnIndex) {
       // TODO Auto-generated method stub
       return null;
   }

   @Override
   public boolean isCellEditable(int rowIndex, int columnIndex) {
       // TODO Auto-generated method stub
       return false;
   }

   @Override
   public void removeTableModelListener(TableModelListener l) {
       // TODO Auto-generated method stub
       
   }

   @Override
   public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
       // TODO Auto-generated method stub
       
   }

}
```


----------



## mrBrown (23. Aug 2017)

Ich würde dir stark raten, erstmal auf GUI zu verzichten - da scheinen noch wesentlich Grundlagen zu fehlen.


----------



## Harry Kane (23. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Ich habe irgendwie immernoch dasselbe Problem


Was auch immer das genau sein mag...
1. Deine "Tabelle" Klasse ist sowohl ein TableModel als auch ein JFrame bzw. sowohl ein Model als auch eine View. Fang damit gar nicht erst an.
2. Dein Tabelle-Klasse ist zwar ein TableModel, wird aber nie als solches verwendet.
3. Du hast zwei Instanzen von Object, nämlich "name" und "value". Beide werden nirgendwo instanziiert. Was also sollen sie anders sein als null?
Stimme @mrBrown zu: Es fehlt dir noch zu viel Verstehen, um sinnvoll eine Gui anzufangen.


----------



## Schlagdraufunschluss_124 (23. Aug 2017)

Ok, des hab ich jetzt auch eingesehen
Ich find halt mit GI machts mehr Spaß...

Also, ich hab nochmal ganz von vorne Angefangen
Warum meckert er, dass ich es die Methode bei der Eingabe-Klasse nicht gibt?

```
public class Main {

    public static void main(String[]args) {
      
        System.out.println("Fachanzahl: ");
        System.out.println("Anz:"+Eingabe.class.getFachanz());//<- Ich hab doch getFachanz in der EingabeKlasse erstellt
        new Eingabe();
  
      
    }
  
  

}
```


```
import java.util.Scanner;

public class Eingabe {

   public int fachanz;
   String[] fach = new String[fachanz];

   public Eingabe() {

       Scanner scr = new Scanner(System.in);
       fachanz=Integer.parseInt(scr.next());
      

   }
  
   public int getFachanz(){
       return fachanz;
   }

}
```


----------



## JStein52 (23. Aug 2017)

drehe es mal um:

```
Eingabe meineEingabe = new Eingabe();
System.out.println("Fachanzahl: ");
        System.out.println("Anz:"+meineEingabe.getFachanz());//<- Ich hab doch getFachanz in der EingabeKlasse erstellt
```
getFachanz war ja keine Klassenmethode (static)


----------



## Harry Kane (23. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Ich find halt mit GI machts mehr Spaß


Das ist primär auch keine Frage von Gui oder nicht Gui, sondern zunächst die Frage von "planvollem Vorgehen" oder "wildem rumprobieren".


Schlagdraufunschluss_124 hat gesagt.:


> Warum meckert er, dass ich es die Methode bei der Eingabe-Klasse nicht gibt?


Der Rückgabewert von Eingabe.class ist Class, und die Klasse Class hat keine Methode "getFachanz".
Entweder: mache getFachanz statisch und rufe sie über "Eingabe.getFachanz()" (geht, hat aber nix mit OOP zu tun)
oder (besser): Erzeuge eine Instanz von Eingabe() und rufe auf der Instanz "getFachanz()" auf.


----------



## Schlagdraufunschluss_124 (23. Aug 2017)

Cool Danke
Es funktioniert!


```
public class Main {

    public static void main(String[]args) {
        System.out.println("Fachanzahl: ");
       
        Eingabe eingabe = new Eingabe();
        System.out.println("Anz:"+eingabe.getFachanz());
       
       
       
    }
   
   

}
```


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

So hallo mal wieder... Ich hab wieder ein Problem
Wie kann ich es schaffen, dass nur "Teile" vom Konstruktor aufrufe:
Ich hab nämlich mein Programm in 3 Klasse aufgeteilt: Main, Eingabe und Ausgabe.
Allerdings muss ich die ganze jetzt die ganze Zeit zwischen Ein- und Ausgabe hin-und her "switchen", damit am Ende die Konsolenausgabe stimmt
1. Mach es überhaupt Sinn, so einen Aufwand zu betreiben damit alle Klassen schön "clean" bleiben und sich nichts vermischt?(Ich könnte ja auch meine Ausgabeklasse wegwerfen und die Ausgabe zur EingabeKlasse hinzufügen)
2. Wenn es doch Sinn machen sollte, wie kann ich es dann lösen, dass nicht immer der ganze Konstrukor von z.B der EingabeKlasse aufgerufen wird, sodass meine Sysouts überhaupt nicht mehr stimmen?

Die Main:

```
public class Main {

    public static void main(String[]args) {
        new Ausgabe();
    }
}
```
Die Eingabe:

```
import java.util.Scanner;

public class Eingabe {

    Scanner scr;
    Eingabe ver;
    public boolean goOn;
    public int fachanz;
    String fach[];
  

    public Eingabe() {
        scr = new Scanner(System.in);
        fachanz = Integer.parseInt(scr.next());
      
        String fach[]= new String[fachanz];
        for(int i=0; i<fachanz;i++){
            fach[i]= scr.next();
            System.out.println("Fachbelegung: "+fach[i]);
        }
    }

    public int getFachanz() {
        return this.fachanz;
    }
}
```
Die Ausgabe:

```
public class Ausgabe {

   public Ausgabe() {
      
       System.out.println("Fachanzahl: ");
      
       Eingabe eingabe = new Eingabe(); // Hier wird ja ein neues Objekt erstellt und wenn ich es richtig verstanden habe ruft das Programm jetzt den Konstruktor von der Eingabe Klasse auf, arbeitet diesen ab und erst wenn er fertig ist, macht er wieder mit der Ausgabe Klasse weiter, wobei glaube ich der Fehler liegt
       System.out.println("Anz:"+eingabe.getFachanz());
       System.out.println("Fächer:");      
   }
}
```
Meine bisherige Konsolenausgabe:

```
Fachanzahl:
1//<- Hier sollte eigentlich jetzt"Anz:1" kommen
Informatik//<- Hier sollte erstmal "Fächer" kommen, damit der User weiß was er überhaupt eingeben soll.
Fachbelegung: Informatik
Anz:1
Fächer:
```


----------



## mrBrown (24. Aug 2017)

1. Ja, kann Sinn machen.

2. sowas gehört nicht in den Konstruktor, der soll nur das Objekt erstellen, und auf dem rufst du dann entsprechende Methoden auf


----------



## JStein52 (24. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Mach es überhaupt Sinn, so einen Aufwand zu betreiben damit ...


Aber in der Form wie du es hier hast macht es keinen Sinn. Die Prompts für die Eingabe gehören auf jeden Fall ein die Eingabeklasse.
Wenn du schon aufteilen willst dann alles was mit dem Einlesen von Daten zu tun hat in einer Klasse/Methode, alles was mit dem Ausgeben der Ergebnisse zu tun hat in eine andere Klasse/Methode.


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

Ok, etwa so?

```
import java.util.Scanner;

public class Eingabe {

    Scanner scr;
    Eingabe string;
    public boolean goOn;
    public int fachanz;
    String fach[];
   

    public Eingabe() {
   
        }

    public int getFachanz() {
        return this.fachanz;
    }
   
    public int fachanz(){
        scr = new Scanner(System.in);
        fachanz = Integer.parseInt(scr.next());
        return fachanz;
    }
   
    public void StringFilling(){
        int i;
        String fach[]= new String[getFachanz()];
        for(i=0; i<fachanz;i++){
            fach[i]= scr.next();
        }
        for (i=0;i<fachanz;i++){
            System.out.println("Fachbelegung:"+ fach[i]);
        }
    }


}
```

PS: Wie bekomme den Rückgabetyp für den String fach[] hin?
denn wenn ich es so mache:

```
public String[] StringFilling(){
        int i;
        String fach[]= new String[getFachanz()];
        for(i=0; i<fachanz;i++){
            fach[i]= scr.next();
        }
        for (i=0;i<fachanz;i++){
            System.out.println("Fachbelegung:"+ fach[i]);
        }
        return fach[];
    }


}
```
 dann gits einen Error(
Multiple markers at this line
   - Class<fach[]> cannot be resolved to a type
   - fach cannot be resolved to a type
   - Syntax error, insert ". class" to complete
    Expression
). So hab ich's aber im Internet gelesen - Liegt also mein Fehler?


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

@JStein52 
Du meinst also ich soll Eingabeanweisungen für den User auch in die Eingabe Klasse mitdazu packen?(Wie z.B "System.out.println("Fachanzahl: ");"


----------



## JStein52 (24. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Du meinst also ich soll Eingabeanweisungen für den User auch in die Eingabe Klasse mitdazu packen


Richtig


----------



## JStein52 (24. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> Wie bekomme den Rückgabetyp ....




```
return fach;
```


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

Wie kann man denn einen Beitrag komplett löschen?
(Siehe folgende..)


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

Also ich habs jetzt nochmal umstrukturiert:

```
import java.util.Scanner;

public class Eingabe {

    Scanner scr;
    Eingabe string;
    public boolean goOn;
    public int fachanz;
    String fach[];

    public Eingabe() {

    }

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

    public String[] StringFilling() {
        System.out.println("Fächer:");
        String fach[] = new String[getFachanz()];
        return fach;
    }

    public String[] getFach() {
        return this.fach;

    }

    public int getFachanz() {
        return this.fachanz;
    }

}
```


```
public class Ausgabe {

    public Ausgabe() {
        Eingabe eingabe = new Eingabe();
        eingabe.fachanz();
        System.out.println("Anz:" + eingabe.getFachanz());
        eingabe.StringFilling();
        for (String i: eingabe.getFach()) {
            System.out.println("Fachbelegung:" + i);
        }

    }

}
```
Wie kann ich jetzt allerdings das Array ausgeben lassen? Wenn ich so wie oben mache, dann wirft es eine Exception.
PS: Danke für die bisherigen Antworten. Verstehe jetzt einiges mehr


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

Also irgendwie spinnt gerade mein Browser... Kann sein dass ich es 2mal gepostet hab...


----------



## JStein52 (24. Aug 2017)

Das dürfte daran liegen dass stringFilling() nirgends aufgerufen wird.

Edit: stop zurück, wird ja aufgerufen


----------



## JStein52 (24. Aug 2017)

Aber die ist falsch. Du legst da drin ja ein neues lokales Stringarray namens fach an !!


----------



## Schlagdraufunschluss_124 (24. Aug 2017)

Ja ok, aber wenn ich es einfach "extern" anlege, dann gibts eine IndexOfBoundsException, was daran liegt, dass zu dem Zeitpunkt wo meine Eingabeklasse aufgerufen wird fachanz noch kein wert "besitz".


----------



## mrBrown (24. Aug 2017)

Deutlich einfacher machst du es dir, wenn Eingabe keine Instanzvariablen hat, sondern die alle nur Lokal sind


----------



## Schlagdraufunschluss_124 (25. Aug 2017)

Mmh, du meinst also ich soll alle Vars in den einzelnen Methoden deklarieren?
Dann bekomm ich ja aber Probleme mit meiner "fachanz" und mit meinem Stringarray "fach". Oder soll ich des dann einfach in der anderen Methode nochmal anlegen?


----------



## mrBrown (25. Aug 2017)

Du kannst die Methoden, die einlesen, einfach die entsprechenden Dinge zurückgeben lassen, wie es deine `StringFilling` auch schon macht.
Die Getter sind in dem Fall überflüssig


----------



## Schlagdraufunschluss_124 (25. Aug 2017)

Perfekt, danke, es funzt. Aber was mach ich wenn ich z.B. auf "fachanz" zugreifen möchte, ohne den ganzen Rattenschwanz hintendran zu haben?


----------



## mrBrown (25. Aug 2017)

Welchen "Rattenschwanz"?
Entweder du willst es einlesen - dann über die Funktion, oder eben nicht.
Es spricht nichts dagegen, das eingelesene in deiner anderen Klasse zu speichern


----------



## Schlagdraufunschluss_124 (25. Aug 2017)

Mit Rattenschwanz meinte ich eigentlich, dass wenn ich die methode nochmals aufrufen würde, würden ja alle sysouts und Deklarationen usw. mitkommen obwohl ich ja nur das Ergebnis will.


mrBrown hat gesagt.:


> Es spricht nichts dagegen, das eingelesene in deiner anderen Klasse zu speichern


Das habe ich gemacht - dadurch funktioniert die AusgabeKlasse prima, aber für meine Eingabe trifft das doch nicht zu. Es würde ja keinen Sinn machen, wenn ich alle Variablen lokal in die einzelnen Methoden verfrachte, sie dann aber wieder versuch aufzurufen und in den anderen Methoden wieder abzuspeichern- Soll ich deshalb meine Vars nicht doch "extern" anlegen?
Ich hab nämlich folgendes Problem. In meiner neuen Methode HauptfachFilling(schaut, ob die eingegeben Fächer Neben oder Hauptfächer sind-> wichtig für die spätere Notengewichtung) will ich auf mein Stringarray "fach" zugreifen, allerdings kennt HauptfachFilling diese Var natürlich nicht - Wie soll ich vorgehen?


----------



## mrBrown (25. Aug 2017)

Mit einer Klasse, die "Daten" deines Programms enthält - Daten sind ja weder Teil der Aus-, noch der Eingabe.
Die Ein und Ausgabe kann dann auf die Daten zugreifen.

z.B. mit einer Klasse Fächer, die eine Liste (oder Array) der Haupt- und Nebenfächern enthält.


----------



## Schlagdraufunschluss_124 (25. Aug 2017)

Ok, den Kern deiner Aussage hab ich eigentlich verstanden. Ich bin jetzt so vorgegangen:
meine Main ruft die Ausg.Klasse auf. Die Erstellt im Konstrukor eine Instanz von der DatenKlasse - Hier will eigentlich die Daten der Eingabe Klasse speichern und per GetterMethode "verfügbar" machen. Die DatenKlasse erstellt im Konstruktor dann wieder eine Instanz, die auf die EingabeKlasse verweist, aber um in der Eingabe Klasse auf die Daten der DatenKlasse zugreifen zu können, muss ich ja wieder eine Instanz in der Eingabe Klasse erstellen, was ja bedeuten würde, dass der Konstruktor der DatenKlasse 2mal aufgerufen wird- Wo liegt also jetzt mein Fehler?


----------



## mrBrown (25. Aug 2017)

Du kannst in der Main die Instanz der Daten-Klasse erstellen und die an Eingabe und Ausgabe weiter geben


----------



## Schlagdraufunschluss_124 (25. Aug 2017)

Weißt du warum es jetzt eine NullPointerExcetption bei Zeile 23 wirft?

```
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()]; //<- NullPointerException
        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() {
        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(daten.getFach() + " -> 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;

    }

}
```

PS: Es hat anscheinend irgendwas mit getFachanz() zu tun....


----------



## Robat (25. Aug 2017)

Liegt daran, dass deine Variable `daten` null ist und du versuchst darüber eine Methode aufzurufen. Wie rufst du denn den Konstruktor der Klasse `Eingabe` auf? Ist dort das `Daten` - Objekt (welches du dem Konstruktor übergibst)  initialisiert?


----------



## mrBrown (25. Aug 2017)

Wenn du noch verrätst, was Zeile 23 ist


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

mrBrown hat gesagt.:


> Wenn du noch verrätst, was Zeile 23 ist


Oh sorry, ich dachte ich hätte es markiert
Zeile 23 ist in der StringFilling- methode : "String fach[] = new String[daten.getFachanz()];", dort wo, wie @Robat schon gesagt hat, das erste mal die Instanz Daten "ins Spiel" kommt.

@Robat: Ich rufe den Konstruktor in der DatenKlasse so auf:


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

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

}
```


Edit: Oh, ich hab die Zeile doch markiert Und ich hab gerade gemerkt, dass es noch nicht initialisiert wurde-> Mit was muss ichs denn initialisieren?
Edit2: Ich habs jetzt mal so initialisiert:

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

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

Aber was soll ich jetzt eigentlich in der Main dem Konstruktor von Eingabe übergeben? Ich hab doch dort schon eine Instanz von Daten erstellt:

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

Ich kann wohl nicht der Instanz "daten" ja nicht die Instanz "daten" mitgeben...


----------



## JStein52 (26. Aug 2017)

Vermutlich so:

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

public Daten() {

//Instanz auf Eingabe
Eingabe eingabe = new Eingabe(this);
.
.
```


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> 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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> 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 (26. Aug 2017)

JStein52 hat gesagt.:


> 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 (26. Aug 2017)

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


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

JStein52 hat gesagt.:


> 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 (26. Aug 2017)

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 (26. Aug 2017)

Was ich initial meinte, was eher sowas.

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


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

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 ? 


mrBrown hat gesagt.:


> Was ich initial meinte, was eher sowas.
> 
> ```
> psv main(...) {
> ...


----------



## Harry Kane (26. Aug 2017)

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 (26. Aug 2017)

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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> _//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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


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


Eine vernünftige Trennung der Verantwortlichkeiten


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

@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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> @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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> trifft das auch auf meine DatenKlasse oben zu?


Der Fehler war eigentlich in der Daten-Klasse !


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

@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 (26. Aug 2017)

```
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 (26. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


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



Ja genau


----------



## JStein52 (26. Aug 2017)

War doch fast schon richtig. aus dem:

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

```
//StringFilling
fach = eingabe.StringFilling();
```


----------



## Schlagdraufunschluss_124 (26. Aug 2017)

@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 (26. Aug 2017)

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


----------



## Schlagdraufunschluss_124 (27. Aug 2017)

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 (27. Aug 2017)

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


----------



## Schlagdraufunschluss_124 (27. Aug 2017)

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


----------



## Schlagdraufunschluss_124 (27. Aug 2017)

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 (27. Aug 2017)

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 (28. Aug 2017)

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


mrBrown hat gesagt.:


> 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 (28. Aug 2017)

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

GottKlasse wäre das Gegenteil von dieser Trennung


----------



## Joose (28. Aug 2017)

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 (28. Aug 2017)

@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 (28. Aug 2017)

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 (29. Aug 2017)

Schlagdraufunschluss_124 hat gesagt.:


> 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.


Joose hat gesagt.:


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


----------



## Schlagdraufunschluss_124 (29. Aug 2017)

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


----------

