# Problem beim Wochenplan (Datum,Wochentag)



## robotic (6. Okt 2015)

Hallo zusammen,
erst einmal möchte ich sagen, dass das mein erster Post hier ist und ich noch ein Anfänger bin was Programmieren angeht. Seit einigen wochen sitze ich nun an meinem Programm und komme mit kleinen Schritten voran 

Nun hänge ich an einer Stelle fest. Ich möchte gerne die Tage (mit Datum) für jeweils eine Woche anzeigen lassen.
In etwa so: 
Montag 
2015-10-5

Dienstag 
2015-10-6
  bis
Sonntag
2015-10-11  

Der wichtige Punkt für mich ist jetzt, die Tage der aktuellen Woche sollen solange angezeigt werden bis die nächste Woche startet, sprich jeden Montag um 0:00 Uhr.

Was ich probiert habe bis jetzt, ist die LocalDate funktion:

```
LocalDate Monday = ldt.with(TemporalAdjusters.nextOrSame(DayOfWeek.MONDAY));
    LocalDate Tuesday = ldt.with(TemporalAdjusters.nextOrSame(DayOfWeek.TUESDAY));
    LocalDate Wednesday = ldt.with(TemporalAdjusters.nextOrSame(DayOfWeek.WEDNESDAY));
    LocalDate Thursday = ldt.with(TemporalAdjusters.nextOrSame(DayOfWeek.THURSDAY));
    LocalDate Friday = ldt.with(TemporalAdjusters.nextOrSame(DayOfWeek.FRIDAY));
   
    System.out.println(Monday + "\n" + Tuesday + "\n" + Wednesday + "\n" + Thursday + "\n" + Friday);
```

Hier habe ich allerdings das Problem das wenn ein Tag vorbei ist z.B. der Montag er mir bereits den Montag für die nächste Woche anzeigt. Dies soll er aber erst tun wenn die Woche vorbei ist.

Ich hoffe ich konnte mein Problem richtig schildern  
Für erfahrene Programmierer ist das bestimmt ziemlich einfach...
Über Lösungsvorschläge freue ich mich sehr.

MfG


----------



## Joose (6. Okt 2015)

Es gibt auch die Alternative "previousOrSame" statt "nextOrSame".
Dann musst du nur noch rausfinden welche Tage sind bisher vergangen und für diese führst du dann eben "previousOrSame" statt "nextOrSame" aus.


----------



## robotic (6. Okt 2015)

Hey danke erstmal für deine Antwort.
Ich verstehe nich genau in wie weit mir "previousOrSame" bei meinem Problem weiter hilft.

Ich möchte  *alle Tage der aktuellen* Woche (also KW41 vom 5.10 bis 11.10) angezeigt bekommen bis die neue Woche beginnt. 
Am Montag (12.10) sollen dann *alle Tage  der nächsten* Woche (also KW42 vom 12.10 bis 18.10) angezeigt werden.
Und immer so weiter.


----------



## Joose (6. Okt 2015)

robotic hat gesagt.:


> Ich möchte  *alle Tage der aktuellen* Woche (also KW41 vom 5.10 bis 11.10) angezeigt bekommen bis die neue Woche beginnt.
> Am Montag (12.10) sollen dann *alle Tage  der nächsten* Woche (also KW42 vom 12.10 bis 18.10) angezeigt werden.
> Und immer so weiter.



Was du erreichen willst habe ich schon verstanden. Und auch dein Problem habe ich verstanden: Wenn nun Montag der 12.10 vorbei ist bekommst du mit "nextOrSame" eben nicht mehr den 12.10 angezeigt sondern schon den 19.10. oder?



robotic hat gesagt.:


> Ich verstehe nich genau in wie weit mir "previousOrSame" bei meinem Problem weiter hilft.



Dein Problem ist das er immer den aktuellen Tag (heutigen) oder den nächsten Tag nimmt welcher dem übergebenen Wochentag entspricht. Wenn nun aber ein Wochentag vorbei ist willst du eben den vorherigen der dem übergebenen Wochentag entspricht.

Du musst kontrollieren, ob der Tag X schon vorbei ist, wenn ja dann holst du dir mit "previousOrSame" den Tag der aktuellen Kalendarwoche. Ist der Tag noch nicht vorbei kannst du dir "nextOrSame" die anderen Tage der Kalendarwoche holen.


----------



## Joose (6. Okt 2015)

Eine ganz andere Variante wäre folgende:

Frage das aktuelle Datum und dessen Wochentag ab. Um nun auf die anderen Wochentage zu kommen muss du jeweils nur X Tage subtrahieren bzw. addieren.


----------



## robotic (6. Okt 2015)

Joose hat gesagt.:


> Wenn nun Montag der 12.10 vorbei ist bekommst du mit "nextOrSame" eben nicht mehr den 12.10 angezeigt sondern schon den 19.10. oder?


Richtig.



Joose hat gesagt.:


> Du musst kontrollieren, ob der Tag X schon vorbei ist, wenn ja dann holst du dir mit "previousOrSame" den Tag der aktuellen Kalendarwoche. Ist der Tag noch nicht vorbei kannst du dir "nextOrSame" die anderen Tage der Kalendarwoche holen.


klingt verwirrend^^ aber ich werde mir hierzu gedanken machen und es mal versuchen...



Joose hat gesagt.:


> Frage das aktuelle Datum und dessen Wochentag ab. Um nun auf die anderen Wochentage zu kommen muss du jeweils nur X Tage subtrahieren bzw. addieren.


Hmm würde hier aber nicht die Ausgabe jedesmal verrutschen?
Also wenn "heute" Montag ist dann klappt es:
1. Montag(heute) 2.Diensatg...7.Sonntag

Wenn aber "heute" Dienstag ist:
1.Dienstag(heute) 2.Mittwoch...7.Montag


----------



## Joose (6. Okt 2015)

robotic hat gesagt.:


> klingt verwirrend^^ aber ich werde mir hierzu gedanken machen und es mal versuchen...



Du musst in deinem Programm ja irgendwie das aktuelle Tagesdatum bekommen. Von diesem Tagesdatum kannst du auch den Wochentag bekommen.
Jedes Datum vor dem aktuellen Datum kann mittels Methode "previousOrSame" gefunden werden. Jedes Datum nach dem aktuellen Datum kann mittels Methode "nextOrSame" gefunden werden.



robotic hat gesagt.:


> Hmm würde hier aber nicht die Ausgabe jedesmal verrutschen?
> Also wenn "heute" Montag ist dann klappt es:
> 1. Montag(heute) 2.Diensatg...7.Sonntag
> 
> ...



Wie schon gesagt addieren oder aber subtrahieren.
Wenn heute Dienstag ist, dann musst du für Montag -1 rechnen (oder aber +(-1) )

Du musst natürlich schauen das die richtige Reihenfolge eingehalten wird.

Variante 3 (ist mir gerade wieder eingefallen):
Vom aktuellen Datum rechnest du auf den letzten Montag zurück (falls das aktuelle Datum schon Montag ist braucht man hier nichts machen) und von Montag aus kann man sich den Rest der Woche ausrechnen.

Wie du siehst gibt es mehrere Möglichkeiten an die Tage einer Woche zu kommen.
Welche Variante du nun wählst hängt nur von dir ab und deinem Code.


----------



## robotic (8. Okt 2015)

Hallo,
dank dir habe ich es jetzt hinbekommen.
Hier der Quelltext:

```
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;


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

  
    LocalDate today = LocalDate.now();
    //System.out.println(today);
      
    LocalDate date = LocalDate.of(2015, 10, 16);
    //System.out.println(weekday.getDayOfWeek());
   
    DayOfWeek weekday = date.getDayOfWeek();
     // System.out.println(xoxo);
    //String s= xoxo.toString();
   
  switch (weekday.toString()){
      case "MONDAY":
        
         LocalDate mon = date;
         LocalDate tue = date.plusDays(1);
         LocalDate wed = date.plusDays(2);
         LocalDate thu = date.plusDays(3);
         LocalDate fri = date.plusDays(4);
         System.out.println("case 1");
         System.out.println(mon);
         System.out.println(tue);
         System.out.println(wed);
         System.out.println(thu);
         System.out.println(fri);
       
          break;
   
      case "TUESDAY":
        
         LocalDate mon2 = date.minusDays(1);
          LocalDate tue2 = date;
          LocalDate wed2 = date.plusDays(1);
          LocalDate thu2 = date.plusDays(2);
          LocalDate fri2 = date.plusDays(3);
          System.out.println("case 2");
          System.out.println(mon2);
          System.out.println(tue2);
          System.out.println(wed2);
          System.out.println(thu2);
          System.out.println(fri2);
            break;
         
        
      case "WEDNESDAY":
        
         LocalDate mon3 = date.minusDays(2);
          LocalDate tue3 = date.minusDays(1);
          LocalDate wed3 = date;
          LocalDate thu3 = date.plusDays(1);
          LocalDate fri3 = date.plusDays(2);
          System.out.println("case 3");
          System.out.println(mon3);
          System.out.println(tue3);
          System.out.println(wed3);
          System.out.println(thu3);
          System.out.println(fri3);
           break;
        
      case "THURSDAY":
        
         LocalDate mon4 = date.minusDays(3);
          LocalDate tue4 = date.minusDays(2);
          LocalDate wed4 = date.minusDays(1);
          LocalDate thu4 = date;
          LocalDate fri4 = date.plusDays(1);
          System.out.println("case 4");
          System.out.println(mon4);
          System.out.println(tue4);
          System.out.println(wed4);
          System.out.println(thu4);
          System.out.println(fri4);
           break;
         
      case "FRIDAY":
       
         LocalDate mon5 = date.minusDays(4);
          LocalDate tue5 = date.minusDays(3);
          LocalDate wed5 = date.minusDays(2);
          LocalDate thu5 = date.minusDays(1);
          LocalDate fri5 = date;
          System.out.println("case 5");
          System.out.println(mon5);
          System.out.println(tue5);
          System.out.println(wed5);
          System.out.println(thu5);
          System.out.println(fri5);
           break;
         
            }
      }}
```


----------



## robotic (8. Okt 2015)

So nun wo ich das jetzt habe, wollte ich gerne noch etwas wissen.
Ich habe eine Datenbank wo ich 5 querys habe.
Dabei soll mir die,
1.Query alle Informationen für den Montag
2.Query alle Informationen für den Dienstag
usw. Ausgeben.

Bis jetzt musste ich immer das Datum selbst eintragen so wie hier:
ResultSet montag = myStmnt.executeQuery("select * from gericht where date_start='2015-10-05'");
ResultSet dienstag = myStmnt.executeQuery("select * from gericht where date_start='2015-10-06'");
ResultSet mittwoch = myStmnt.executeQuery("select * from gericht where date_start='2015-10-07'");
ResultSet donnerstag = myStmnt.executeQuery("select * from gericht where date_start='2015-10-08");
ResultSet freitag = myStmnt.executeQuery("select * from gericht where date_start='2015-10-9'");

Kann ich dem jetzt irgendwie sagen, das er sich das jeweilige Datum aus der Ausgabe meines Programms nehmen soll?


----------



## Joose (8. Okt 2015)

Schaut gut aus. Hab mir deinen Code zur Hand genommen und ihn etwas optimiert 
Hinweis: Du hast bei dir viel doppelten Code durch die Ausgabe in jedem switch Zweig.


```
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class Homedate {
   public static void main(String[] args) {
     LocalDate today = LocalDate.now();

     LocalDate[] weekdays = getWeekdays(today);
    
     System.out.println(weekdays[0]);
     System.out.println(weekdays[1]);
     System.out.println(weekdays[2]);
     System.out.println(weekdays[3]);
     System.out.println(weekdays[4]);
   }
  
   public static LocalDate[] getWeekdays(LocalDate date) {
     LocalDate monday = date;
     if(date.getDayOfWeek() > 1) {
       monday = date.minusDays(date.getDayOfWeek() - 1);
     }
     LocalDate[] weekdays = new LocalDate[5];
     weekdays[0] = monday;
     for(int i = 1; i <= 4; i++) {
       weekdays[i] = monday.plusDays(i);
     }
   }
}
```

Anmerkung: Hab den Code aber nicht getestet.


```
ResultSet montag = myStmnt.executeQuery("select * from gericht where date_start='" + deineVariableMitdemDatumVonMontag  + "'");
......
```

So würde das theoretisch gehen. Aber Achtung man sollte immer PreparedStatement verwenden statt selber zusammen gestückelten SQLs

```
String gerichtQuery = "select * from gericht where date_start=?;";
PreparedStatement gerichtStatement = con.prepareStatement(gerichtQuery);
gerichtStatement .setDate(1, [DEINE_DATUM_VARIABLE]);

ResultSet gerichtTag = gerichtStatement.execute();
```

Ich glaube du hast in deinem Code viele Sachen doppelt - fünfach drinnen um etwas für jeden Tag zu machen. Probier das zu vereinfachen, dadurch wird der Code übersichtlicher, kürzer und leichter anzupassen


----------



## robotic (8. Okt 2015)

Joose hat gesagt.:


> Schaut gut aus. Hab mir deinen Code zur Hand genommen und ihn etwas optimiert
> Hinweis: Du hast bei dir viel doppelten Code durch die Ausgabe in jedem switch Zweig.
> 
> 
> ...



Wow deine Lösung ist viel kürzer. Ich verstehe nicht mal genau was da passiert 


Joose hat gesagt.:


> Anmerkung: Hab den Code aber nicht getestet.



Funktioniert leider bei mir nicht. Er meckert bei den Operatoren "..*>*1" und "..*-*1".

Das Problem was ich bei der Datenbank Abfrage habe ist halt, dass er die Variablen innerhalb der cases nicht annimmt.
Naja ich werde erstmal weiter versuchen und schauen was "PreparedStatement" überhaupt ist. 

Ich melde mich sobald ich was habe bzw. nicht weiter weiß.

Danke vielmals.
MfG


----------



## Joose (8. Okt 2015)

robotic hat gesagt.:


> Wow deine Lösung ist viel kürzer. Ich verstehe nicht mal genau was da passiert



Naja probiere es einfach mal per Stift+Papier logisch durchzugehen. Grob gesagt egal welches Datum du an die Methode übergibst, es wird immer der Montag davor gesucht (außer der Tag selber ist ein Montag). Und danach einfach immer Tage addiert um die restlichen Tage der Woche zu bekommen.



robotic hat gesagt.:


> Funktioniert leider bei mir nicht. Er meckert bei den Operatoren "..*>*1" und "..*-*1".



Ja mein Fehler, nach dem Aufruf von "getWeekday()" muss man noch "getValue()" aufrufen.



robotic hat gesagt.:


> Das Problem was ich bei der Datenbank Abfrage habe ist halt, dass er die Variablen innerhalb der cases nicht annimmt.



Ich würde zu diesem Problem generell ein neues Thema aufmachen, da es sich hierbei ja schon um etwas anderes handelt als die Wochentage zu einem bestimmten Wochentag zu bekommen.


----------



## robotic (8. Okt 2015)

Alles klar! Für die Datenbank-Problematik mache ich dann einen neuen thread auf.

Könntest du vielleicht deinen Quellcode noch überabrbeiten und hier mal posten?
Ich würde damit gerne etwas rumspielen, um es besser zu verstehen.
Wäre sehr nett.


----------



## Joose (8. Okt 2015)

```
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class Homedate {
   public static void main(String[] args) {
     LocalDate today = LocalDate.now();

     LocalDate[] weekdays = getWeekdays(today);
  
     System.out.println(weekdays[0]);
     System.out.println(weekdays[1]);
     System.out.println(weekdays[2]);
     System.out.println(weekdays[3]);
     System.out.println(weekdays[4]);
   }

   public static LocalDate[] getWeekdays(LocalDate date) {
     LocalDate monday = date;
     if(date.getDayOfWeek().getValue() > 1) {
       monday = date.minusDays(date.getDayOfWeek().getValue() - 1);
     }
     LocalDate[] weekdays = new LocalDate[5];
     weekdays[0] = monday;
     for(int i = 1; i <= 4; i++) {
       weekdays[i] = monday.plusDays(i);
     }
     return weekdays;
   }
}
```

So sollte es funktionieren.


----------



## robotic (8. Okt 2015)

Vielen Dank für deine Mühe, weiß das echt zu schätzen.
Leider sagt er mir nun bei dieser Zeile ----> "public static LocalDate[] getWeekdays(LocalDate date)"; :

"Exception in thread "main" java.lang.Error: Unresolved compilation problem:
   This method must return a result of type LocalDate[]"

Wenn du keine Lust mehr hast, kann ich das verstehen. Möchte dich nicht unnötig nerven 

gruß


----------



## JStein52 (8. Okt 2015)

Fast, es fehlt noch ein "return weekdays;" in der getWeekdays


----------



## Joose (8. Okt 2015)

Schon dazu editiert


----------



## robotic (20. Okt 2015)

Vielen Dank  
Funktioniert Super! Darf ich deinen Code weiter verwenden? Es ist viel kürzer und besser gelöst als meine variante.
MfG


----------



## Joose (20. Okt 2015)

Klar kannst du ihn verwenden.


----------



## robotic (4. Nov 2015)

Vielen dank! Arbeite seit Gestern wieder weiter am Programm und ich habe versucht deinen Code bei mir einzufügen.
Ich wollte beide Klassen miteinander verbinden und habe dazu etwas im web gefunden. Leider funktioniert es nicht.
Er erkennt die Arrays nicht, also "weekdays[0]" und "weekdays[1]" in der query.
main:

```
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;
import java.sql.*;
import java.time.LocalDate;

//import com.mysql.jdbc.PreparedStatement;

public class Speiseplan extends Application {
    @Override
    public void start(Stage stage)  throws Exception {    
            
                final TextArea ta1 = new TextArea();
                ta1.setPrefRowCount(5);
                ta1.setPrefColumnCount(10);
                ta1.setPrefWidth(250);
                ta1.setPrefHeight(100);
                ta1.setLayoutX(100);
                ta1.setLayoutY(50);
 
                final TextArea ta2 = new TextArea();
                ta2.setPrefRowCount(5);
                ta2.setPrefColumnCount(10);
                ta2.setPrefWidth(250);
                ta2.setPrefHeight(100);
                ta2.setLayoutX(400);
                ta2.setLayoutY(50);
 
                final TextArea ta3 = new TextArea();
                ta3.setPrefRowCount(5);
                ta3.setPrefColumnCount(10);
                ta3.setPrefWidth(250);
                ta3.setPrefHeight(100);
                ta3.setLayoutX(700);
                ta3.setLayoutY(50);
            
                final TextArea ta4 = new TextArea();
                ta1.setPrefRowCount(5);
                ta1.setPrefColumnCount(10);
                ta1.setPrefWidth(250);
                ta1.setPrefHeight(100);
                ta1.setLayoutX(100);
                ta1.setLayoutY(50);
 
                final TextArea ta5 = new TextArea();
                ta2.setPrefRowCount(5);
                ta2.setPrefColumnCount(10);
                ta2.setPrefWidth(250);
                ta2.setPrefHeight(100);
                ta2.setLayoutX(400);
                ta2.setLayoutY(50);
 
                final TextArea ta6 = new TextArea();
                ta3.setPrefRowCount(5);
                ta3.setPrefColumnCount(10);
                ta3.setPrefWidth(250);
                ta3.setPrefHeight(100);
                ta3.setLayoutX(700);
                ta3.setLayoutY(50);
         
               //LocalDate today = LocalDate.now();
                Wochentage wochenObjekt = new Wochentage();
                wochenObjekt.woche();
            
try {  
                 String url ="jdbc:mysql://localhost:3306/speiseplan";
                 String username ="root";
                 String password = "";
         
           
               Connection myConn = DriverManager.getConnection(url, username,password);
               Statement myStmnt = myConn.createStatement();
                
               ResultSet myRs = myStmnt.executeQuery("select * from gerichte where date= '" + weekdays[0].toString() + "'");
               while (myRs.next()){
         
                    String date = myRs.getString("date");
                    String name = myRs.getString("name");
                    String type = myRs.getString("type");
             
                    ta1.appendText(date + "\n");
                    ta2.appendText(name + "\n");
                    ta3.appendText(type + "\n");
                    }
       
               ResultSet myRs2 = myStmnt.executeQuery("select * from gerichte where date= '" + weekdays[1].toString() + "'");
               while (myRs2.next()){
               
                   String date = myRs2.getString("date");
                   String name = myRs2.getString("name");
                   String type = myRs2.getString("type");
            
                   ta4.appendText(date + "\n");
                   ta5.appendText(name + "\n");
                   ta6.appendText(type + "\n");
                   }
           
} catch (Exception e) {
          e.printStackTrace();
  }


                Pane pane = new Pane();
                Scene scene = new Scene(pane);
                pane.getChildren().addAll(ta1,ta2,ta3,ta4,ta5,ta6);
 
                stage.setWidth(1200);
                stage.setHeight(850);
                stage.setScene(scene);
                stage.setTitle("Termine");
                stage.show();
                stage.centerOnScreen();
}

    public static void main(String[] args) {
        launch(args);
    }
}
```
Ich habe diese Zeilen eingefügt und habe es eigntl. so gemacht wie beschrieben.

```
Wochentage wochenObjekt = new Wochentage();
          wochenObjekt.woche();
```


weekdays:

```
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class Wochentage {
   public void woche() {
     LocalDate today = LocalDate.now();

     LocalDate[] weekdays = getWeekdays(today);
     System.out.println(weekdays[0]);
     System.out.println(weekdays[1]);
     System.out.println(weekdays[2]);
     System.out.println(weekdays[3]);
     System.out.println(weekdays[4]);
   }

   public static LocalDate[] getWeekdays(LocalDate date) {
     LocalDate monday = date;
     if(date.getDayOfWeek().getValue() > 1) {
       monday = date.minusDays(date.getDayOfWeek().getValue() - 1);
     }
     LocalDate[] weekdays = new LocalDate[5];
     weekdays[0] = monday;
     for(int i = 1; i <= 4; i++) {
       weekdays[i] = monday.plusDays(i);
     }
     return weekdays;
   }
}
```


----------



## Joose (4. Nov 2015)

Zuerst mal ein kleiner Verbesserungsvorschlag zu der Erstellung deiner TextAreas  dadurch lassen sich änderungen einfacher durchführen und auch die Fehlersuche vereinfacht sich.
PS: bei dir dürfte sich ein Copy&Paste Fehler eingeschlichen haben deine TextAreas haben teilweise die gleichen LayoutX/Y Werte.


```
public static void createTextArea(int rowCount, int columnCount, int width, int height, int x, int y) {
   TextArea area = new TextArea();
   area.setPrefRowCount(rowCount);
   area.setPrefColumnCount(columnCount);
   area.setPrefWidth(width);
   area.setPrefHeight(height);
   area.setLayoutX(x);
   area.setLayoutY(y);
   return area;
}

final TextArea ta2 = createTextArea(5, 10, 250, 100, 400, 50);
final TextArea ta3 = createTextArea(5, 10, 250, 100, 700, 50);
final TextArea ta4 = createTextArea(5, 10, 250, 100, 100, 50);
final TextArea ta5 = createTextArea(5, 10, 250, 100, 400, 50);
final TextArea ta6 = createTextArea(5, 10, 250, 100, 700, 50);
```

Zu deinem Problem: Du erstellst ein LocalDate[], dieses ist aber nur in der Methode "woche" verfügbar. Da du diese Array nicht zurückgibst bzw. zwischenspeicherst wird es auch wieder aus dem Speicher entfernt sobald deine Methode fertig abgearbeitet wird. Hier eine mögliche Lösung:

```
LocalDate[] weekdays = Wochentage .getAktuelleWoche();
........
public static LocalDate[] getAktuelleWoche() {
   return getWoche(LocalDate.now());
}

public static LocalDate[] getWoche(LocalDate date) {
   return getWeekdays(date);
}
```

Einerseits würde ich das ganze statisch halten (damit erspart man sich die Objekterzeugung, welche hier nicht wirklich notwendig ist für die einfache Berechnung). Außerdem 2x Methoden anbieten um die aktuelle Woche oder eine nach Wunschdatum zu bekommen


----------



## robotic (4. Nov 2015)

Danke für deine Hilfe es hat wunderbar geklappt  Wobei du jetzt schon wieder einen anderen Vorschlag hast mit 2x Methoden. Das hört sich sogar besser an, denn ich hatte eh vor irgendwann auch das Wunschdatum einzubauen.
Ich werde das auch gleich mal testen.

Nochmal zum "return", diese speichert also nur die Array ab ja? 
Und wozu braucht man das get? Ist es notwendig, damit man die Variablen bzw. Array in einer anderen Klasse benutzen darf? Sorry, wenn die fragen zu doof sind. Ich bin noch ein richtiger Grünschnabel in java.


----------



## Joose (4. Nov 2015)

In der Methode "getWeekdays" deiner Klasse Wochentage erzeugst du ein LocalDate-Array. Damit man damit etwas machen kann muss man dieses an den aufrufenden Code zurückgeben -> return.
"return" selbst gibt nur an: beende die Methode hier und liefere folgenden Wert zurück an den Aufrufer.

Von welchem "get" sprichst du? Wenn du "getAktuelleWoche" bzw. "getWoche" meinst: Das sind einfache Methode mit einem x beliebigen Namen. Theoretisch könntest du die beiden Methoden auch "hugo" und "fritz" nennen. Aber man sollte sich angewöhnen einen sinnvollen Namen zu wählen (am besten so das man am Namen erkennt was die Methode macht).
Normalerweise sollten Methoden welche mit "get...." Anfangen einen Wert zurückliefern. 

Um Objekte welche in einer Klasse A (Methode Y) erzeugt werden in einer Klasse B zu verwenden musst du diese übergeben. Das kann man durch einen Methodenauruf realisieren.
Das gehört aber zu Grundlagen der OOP. Sollte dir da etwas unklar sein lies sie dir einfach nach.


----------



## JStein52 (4. Nov 2015)

Ich will ja kein Spielverderber sein, aber in seiner getWeekdays aus dem Post von 11:06 war doch ein return weekdays drin ??

Edit:  ihr meint wahrscheinlich in seiner Methode woche()  fehlt der return weekdays ??!!


----------



## robotic (4. Nov 2015)

Super, jetzt ist einiges klarer geworden. Danke

Also ich habe es nun mit den 2 Methoden probiert und es klappt auch soweit.

```
//import java.time.DayOfWeek;
//import java.time.temporal.TemporalAdjuster;
//import java.time.temporal.TemporalAdjusters;
import java.time.LocalDate;


public class Wochentage {
 
    public static LocalDate[] getAktuelleWoche() {
          return getWoche(LocalDate.now());
        }
 
    public static LocalDate[] getWoche(LocalDate date) {
           return getWeekdays(date);
        }
 
    public static LocalDate[] getWoche() {
    
   //LocalDate today = LocalDate.now();
     LocalDate today = LocalDate.of(2015, 10, 15);
  

     LocalDate[] weekdays = getWeekdays(today);
     System.out.println(weekdays[0]);
     System.out.println(weekdays[1]);
     System.out.println(weekdays[2]);
     System.out.println(weekdays[3]);
     System.out.println(weekdays[4]);
     return weekdays;
   }
 

   public static LocalDate[] getWeekdays(LocalDate date) {
     LocalDate monday = date;
     if(date.getDayOfWeek().getValue() > 1) {
       monday = date.minusDays(date.getDayOfWeek().getValue() - 1);
     }
     LocalDate[] weekdays = new LocalDate[5];
     weekdays[0] = monday;
     for(int i = 1; i <= 4; i++) {
       weekdays[i] = monday.plusDays(i);
     }
     return weekdays;
   }
}
```

Aufrufen tue ich dann so LocalDate[] weekdays = Wochentage.getAktuelleWoche();

Jetzt frage ich mich, wieso bei getAktuelleWoche() die Wochentage nicht in der Console angezeigt werden.
Bei getWoche() klappt es.


----------



## JStein52 (4. Nov 2015)

Weil du zwei getWoche hast !!  Schau mal wann welche aufgerufen wird !!


----------



## Joose (4. Nov 2015)

JStein52 hat gesagt.:


> Ich will ja kein Spielverderber sein, aber in seiner getWeekdays aus dem Post von 11:06 war doch ein return weekdays drin ??
> 
> Edit:  ihr meint wahrscheinlich in seiner Methode woche()  fehlt der return weekdays ??!!



Natürlich hast du Recht 
Habe mich hier selber mit den Methodennamen vertan

@robotic Jap schau dir was JStein52 geschrieben hat, das sollte deine Frage beantworten.


----------



## robotic (4. Nov 2015)

Ihr hattet recht! Ich habe es nun abgeändert:

```
import java.time.LocalDate;

public class Wochentage {
    public static LocalDate[] getAktuelleWoche() {
  
     LocalDate today = LocalDate.now();
  
     LocalDate[] weekdays = getWeekdays(today);
     System.out.println(weekdays[0]);
     System.out.println(weekdays[1]);
     System.out.println(weekdays[2]);
     System.out.println(weekdays[3]);
     System.out.println(weekdays[4]);
     return weekdays;
        }
    public static LocalDate[] getWoche() {

     LocalDate today = LocalDate.of(2015, 10, 15);
  
     LocalDate[] weekdays = getWeekdays(today);
     System.out.println(weekdays[0]);
     System.out.println(weekdays[1]);
     System.out.println(weekdays[2]);
     System.out.println(weekdays[3]);
     System.out.println(weekdays[4]);
     return weekdays;
   }

   public static LocalDate[] getWeekdays(LocalDate date) {
     LocalDate monday = date;
     if(date.getDayOfWeek().getValue() > 1) {
       monday = date.minusDays(date.getDayOfWeek().getValue() - 1);
     }
     LocalDate[] weekdays = new LocalDate[5];
     weekdays[0] = monday;
     for(int i = 1; i <= 4; i++) {
       weekdays[i] = monday.plusDays(i);
     }
     return weekdays;
   }
}
```

Bin mir nur nicht sicher ob es elegant gelöst wurde, weil ich die getWoche() quasi kopiert habe.


----------



## Joose (4. Nov 2015)

Nein ist nicht elegant gelöst. Da die Methode "getWoche" nun keinen Parameter mehr hat und somit immer fix die Wochentage der Woche vom 15.10.2015 zurückgibt.
Ich weiß nicht warum du den Code von mir nochmal ändern musstest ... so wie ich ihn gepostet habe hättest du ihn nur kopieren und bei dir einfügen müssen.

Oder geht es dir um die Konsolenausgaben? Die würde ich wenn ich der Methode "getWeekdays" vor dem return einfügen.


----------



## robotic (10. Nov 2015)

Ja, es geht mir *auch *um die Konsolenausgabe. Hätte gerne beides. 
Und getWoche() soll mir immer die Woche anzeigen die ich gerne hätte.
Deshalb dachte ich, ich könnte später irgendwann  im argument statt fix Werte, einfach int variablen einfügen, die ich dann über "Scanner(System.in)" eingeben kann...hoffe das klappt so wie ich mir das denke.

Aber bevor ich sowas mache möchte ich vorerst nur getAktuelleWoche() benutzen und das Programm so gut es geht zum laufen bringen.


----------



## Joose (10. Nov 2015)

```
import java.time.LocalDate;

public class Wochentage {
    public static LocalDate[] getAktuelleWoche() {
          return getWoche(LocalDate.now());
        }

   public static LocalDate[] getWoche(int year, int month, int day) {
          return getWoche(LocalDate.of(year, month, day));
       }

    public static LocalDate[] getWoche(LocalDate date) {
           return getWeekdays(date);
        }

   public static LocalDate[] getWeekdays(LocalDate date) {
     LocalDate monday = date;
     if(date.getDayOfWeek().getValue() > 1) {
       monday = date.minusDays(date.getDayOfWeek().getValue() - 1);
     }
     LocalDate[] weekdays = new LocalDate[5];
     weekdays[0] = monday;
    // hier kannst du montag ausgeben
     for(int i = 1; i <= 4; i++) {
       weekdays[i] = monday.plusDays(i);
      // hier kannst du die anderen tage ausgeben
     }
     return weekdays;
   }
}
```

Die Konsolenausgabe solltest du dann in der Methode "getWeekdays" realisieren.


----------

