Methoden zusammenfassen/Kalender erstellen

[evil]

Hallo,

Habe folgenden Code

class Start {
  public static void main(String[] args) {
    Kalender kalender = new Kalender();
    Skiunterricht.setzePreisProStunde(20);  // Gilt fuer jeden Skiunterricht
    Job.setzeGehaltProStunde(15);   // Gilt fuer jede Stunde im Job
    kalender.setzeAktivitaet(new Skiunterricht("bei Frau Meier"), 
                             Wochentage.DIENSTAG, 
                             13);
    kalender.setzeAktivitaet(new Skiunterricht("bei Herrn Mueller"), 
                             Wochentage.MITTWOCH, 
                             13);
    kalender.setzeAktivitaet(new Skiunterricht("bei Frau Meier"), 
                             Wochentage.DONNERSTAG, 
                             13);
    for (int stunde = 13; stunde <= 16; ++stunde) {
      kalender.setzeAktivitaet(new Wanderung("Inselsberg"),
                             Wochentage.MONTAG, 
                             stunde);
    }
    for (int stunde = 13; stunde <= 20; ++stunde) {
      kalender.setzeAktivitaet(new Job("Aushilfe"),
                               Wochentage.FREITAG,
                               stunde);
    }
    for (Wochentage tag: Wochentage.values()) {
      for (int stunde = 0; stunde <= 7; ++stunde) {
        kalender.setzeAktivitaet(new Schlaf(), tag, stunde);
      }
    }
    System.out.println(kalender);
    System.out.println("Bilanz: " + kalender.berechneBilanz() + " Euro" + "\n");
  }

Die Datei Wochentage hab ich ebenfalls gegeben.

public enum Wochentage { MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG }

Nun wollte ich eine Klasse

class Kalender {

erzeugen und dort die Methode

setzeAktivitaet

mit

Skiunterricht, Wanderung, Job und Schlaf

zusammenfassen. Nun weiß ich nicht, wie ich die alle unter einen Hut bringen soll.

Das Programm soll 24 Stunden (von 0 - 23 Uhr) ausgeben und die Aktivitäten dazuschreiben.
Also zum Beispiel:

MONTAG
0 Uhr: Schlaf
1 Uhr: Schlaf
2 Uhr: Schlaf
3 Uhr: Schlaf
4 Uhr: Schlaf
5 Uhr: Schlaf
6 Uhr: Schlaf
7 Uhr: Schlaf
8 Uhr:
9 Uhr:
10 Uhr:
11 Uhr:
12 Uhr:
13 Uhr: Wanderung Inselsberg
14 Uhr: Wanderung Inselsberg
15 Uhr: Wanderung Inselsberg
16 Uhr: Wanderung Inselsberg
17 Uhr:
18 Uhr:
19 Uhr:
20 Uhr:
21 Uhr:
22 Uhr:
23 Uhr

 

[nrg]

Du brauchst nicht nur eine Klasse Kalender, sondern auch eine Klasse Skiunterricht, Wanderung, Job und Schlaf. Dort dann jeweils den richtigen Konstruktor (siehe main()). Außerdem könnten diese alle ein Interface implementieren, um in deiner Klasse Kalender die Parameter für setzteAktivitaet genauer deklarieren zu können.
z.b.

interface Aktivitaet{}

public class Skiunterricht implements Aktivitaet {
	private String info;
	public Skiunterricht(String info) {
		setInfo(info);
	}
	public void setInfo(String info) {
		this.info = info;
	}
	public String getInfo() {
		return info;
	}
}

 

[nrg]

deine Methode setzeAktivitaet wuerde dann so aussehen:

	public void setzeAktivitaet(Aktivitaet activity, Wochentage wochentag, int stunde){
		//...
	}

Als Attribut für Kalender kannst du ein Array (Größe 7 für die Wochentage) mit LinkedHashMaps/TreeMaps oder 2D Arrays nehmen. Dieses enthält 7x24x2 Einträge. Der Konstruktor initialisiert das Attribut lediglich.

edit: für Skiunterricht und Job Attribute wie Preis und Gehalt nicht vergessen.

 

[evil]

Danke erstmal, sorry wenn das jetzt Schritt für Schritt geht.

Also mein Interface sieht dann folgendermaßen aus, falls das so richtig ist?!

interface Aktivitaet { 
   public Skiunterricht();
   public Job();
   public Schlaf();
   public PreisProStunde();
   public GehaltProStunde();
 }

Aber ich versteh nicht so ganz was in der Klasse Skiunterricht passiert. Klar, sie holt sich erstmal die brauchbaren Methoden aus dem Interface. Es wird ein String erstellt und an die Methode übergeben.. Aber irgendwie blick ich nicht ganz durch.

Mein Array kann ich ja einfach mit

a = new int [5][24]  //Montag - Freitag

Aber dann muss ich das Array wieder in einen String umwandeln?

 

[nrg]

Dein Interface ist schonmal falsch . Ein Interface stellt eine Schablone, für die Klassen, die es implementieren, dar.

Interface Activity:

public interface Activity {
	public String toString();
}

class Skiunterricht:

public class Skiunterricht implements Activity  {
    private String info;
    private static double stundenPreis;
    public Skiunterricht(String info) {
        setInfo(info);
    }
	public void setInfo(String info) {
        this.info = info;
    }
    public String getInfo() {
        return info;
    }
	public double getPreisProStunde() {
		return stundenPreis;
	}
	public static void setzePreisProStunde(double preisProStunde) {
		stundenPreis = preisProStunde;
	}
    @Override
	public String toString(){
    	return "Skiunterricht " + info;
    }
}

class Wanderung

public class Wanderung implements Activity {
    private String ort;
    public Wanderung(String ort) {
        setOrt(ort);
    }
    public void setOrt(String ort) {
        this.ort = ort;
    }
    public String getOrt() {
        return ort;
    }
    @Override
	public String toString(){
    	return "Wanderung " + ort;
    }
}

und das Selbe für Job (dort mit Attribut stundengehalt) und Schlaf (dort mit keinem Attribut).

 

[nrg]

zu deinem "Speichermedium" vom Kalender, halte ich jetzt nach nochmaligen Überlegen ein Array für eher ungeeignet.
Mit

ArrayList<LinkedHashMap<Integer, Activity>> kalender = new ArrayList<LinkedHashMap<Integer, Activity>>();

würde es schon funktionieren. Allerdings deinen bisherigen Fragen nach zu urteilen, glaub ich nicht, dass du sowas handlen kannst. (obs soo performant ist, weiß ich jetzt auch nicht)

fällt jemanden eine bessere/einfachere Möglichkeit ein?

 

[evil]

So jetzt hab ich erstmal das andere gemacht, ich hoffe das ist richtig..

public class Job implements Activity {
	private String aushilfe;
	private static int gehalt;
	public Job(String aushilfe) {
		setAushilfe(aushilfe);
	}
	public void setAushilfe(String aushilfe) {
		this.aushilfe = aushilfe;
	}
	public String getAushilfe() {
		return aushilfe;
	}
	public int GehaltProStunde(int gehaltProStunde) {
		gehalt = preisProStunde;
	}
	@Override
	public String toString() {
		return "Aushilfe" + aushilfe;
	}
}

public class Schlaf implements Activity {
	private String schlafen;
	public Schlaf(String schlafen) {
		setSchlafen(schlaf);
	}
	public void setSchlaf(String schlafen) {
		this.schlafen = schlafen;
	}
	public String getSchlafen() {
		return schlafen;
	}
	@Override
	public String toString() {
		return "Schlaf";
	}
}

Und ich dachte irgendwie, in das Interface kommen die Methoden die ich verwende, war wohl nicht so..

Mit dem HashMap hast du recht, hab in der Javabibliothek was gefunden, allerdings wird man daraus ohne Erklärung nicht ganz schlau.
Das wäre jetzt mein Ansatz gewesen

import java.util.HashMap;

class MapKalender {
  public static void main(String[] args) {
    ArrayList<LinkedHashMap<Integer, Activity>> kalender = 
                             new ArrayList<LinkedHashMap<Integer, Activity>>();
                             
                             
                             
                             ...
                             
  }
}

 

[nrg]

Das sieht doch schonmal ganz gut aus. Ein paar Kleinigkeiten:

	public int GehaltProStunde(int gehaltProStunde) {
		gehalt = preisProStunde;

Methodennamen schreibt man klein (setzteGehaltProStunde). Ausserdem brauchst du noch eine Getter.

public class Schlaf implements Activity {
	@Override
	public String toString() {
		return "Schlaf";
	}
}

reicht

Und ich dachte irgendwie, in das Interface kommen die Methoden die ich verwende, war wohl nicht so..

Ein Interface gibt Methoden vor, die in den Klassen, von denen es implementiert wird, überschrieben werden müssen. Ich glaub du verstehst noch nicht ganz den Zweck hier von dem Interface. Es dient lediglich einer besseren Deklaration in der Kalender Methode.

	public void setzeAktivitaet(Activity act, Wochentage wochentag, int stunde){

somit ist für setzteAktivitaet als ersten Paramenter "Activity act," nur ein Objekt der Klasse möglich, die das Interface Activity implementiert.
Folgenden geht natürlich genauso:

	public void setzeAktivitaet(Object act, Wochentage wochentag, int stunde){

Allerdings kannst du dann jedes Objekt übergeben, was natürlich nicht gewünscht ist!

Mit dem HashMap hast du recht, hab in der Javabibliothek was gefunden, allerdings wird man daraus ohne Erklärung nicht ganz schlau.
Das wäre jetzt mein Ansatz gewesen

import java.util.HashMap;

class MapKalender {
  public static void main(String[] args) {
    ArrayList<LinkedHashMap<Integer, Activity>> kalender = 
                             new ArrayList<LinkedHashMap<Integer, Activity>>();
                             
  }
}

Die Klasse sollte Kalender heissen.

Das mit der Liste von Maps ist wie gesagt nicht so leicht zu handlen. Ich hab das mal aus Spass hier gecodet. Mir fällt als weitere Option nurnoch eine Klasse Tag, mit dem Attribut LinkedHashMap<Integer, Activity>, ein und in der Klasse Kalender dann ein Array vom Typ Tag. Fällt hierzu jemanden eine bessere Option ein?

Woher hast du diese Aufgabe?

 

[evil]

Also, erstmal fettes Dankeschön für die Hilfe.

Ich hab mir gerade mal überlegt, dass man doch ein char-Array erstellen kann

char[][] a = new char [5][24]

falls das überhaupt geht mit dem 2-dim.

Dann übergibt man das Array einem String

char[][] a = new char[5][24]
for (int i = 0 < 24, i++) {
  a[i] = In.read();
  String s = new String(a);
}

Ist bestimmt nicht das richtige..

Die Aufgabe hab ich von einer Uni-Seite, praktisch als kleine Übung, dachte es wäre einfacher..

 

[nrg]

char geht schonmal garnicht, weil du ja einen Wochentag, eine Activity und einen int reinsteckt.

Was gehen würde, ist ein 3D Array vom Typ Object. Das ist allerdings aus OO-Sicht absolut unschön. Wenn du willst kann ich dir mal meine Lösung posten (ist aber eher Quick and Dirty ). Zum Erklären ist mir das grad weng zuviel.

 

[evil]

Ich bin für alles momentan dankbar
Vielleicht weiß jemand anderes ja auch och eine Lösung

 

[nrg]

das ist meine Klasse Kalender:

import java.util.*;

public class Kalender {
	ArrayList<LinkedHashMap<Integer, Activity>> kalender;
	
	public Kalender() {
		kalender = new ArrayList<LinkedHashMap<Integer, Activity>>();
		for (int i = 1; i <= 5; i++) {
			LinkedHashMap<Integer, Activity> tag = new LinkedHashMap<Integer, Activity>();
			for (int j = 0; j <= 23; j++)
				tag.put(j, null);
			kalender.add(tag);
		}
	}
	public void setzeAktivitaet(Activity act, Wochentage wochentag, int stunde){
	        if (stunde < 0 || stunde > 24)
	        	throw new HourOutOfBoundsException("Invalid Hourparameter " + stunde + ". Integer must between 0 (inclusive) and 24 (exclusive).");
	        else
	        	kalender.get(wochentag.ordinal()).put(stunde, act);
	}
	public double berechneBilanz(){
		double bilanz = 0;
		Iterator<LinkedHashMap<Integer, Activity>> iter = kalender.iterator();
		while (iter.hasNext()) {
			for (Map.Entry<Integer, Activity> e : iter.next().entrySet() ) {
				if (e.getValue() instanceof Skiunterricht)
					bilanz -= ((Skiunterricht)e.getValue()).getPreisProStunde();
				else if (e.getValue() instanceof Job)
					bilanz += ((Job)e.getValue()).getGehaltProStunde();
			}
		}
		return bilanz;
	}
	@Override
	public String toString(){
		StringBuilder sb = new StringBuilder();
		Wochentage[] w = Wochentage.values();
		int i = 0;
		Iterator<LinkedHashMap<Integer, Activity>> iter = kalender.iterator();
		while (iter.hasNext()) {
			sb.append(w[i].name() + "\n");
			for (Map.Entry<Integer, Activity> e : iter.next().entrySet() ) {
				if (e.getValue() != null)
					sb.append(e.getKey() + " Uhr: " + e.getValue() + "\n");
				else
					sb.append(e.getKey() + " Uhr:\n");
			}

			i++;
		}
		return sb.toString();
	}
}

Das die Exception (kein muss)

public class HourOutOfBoundsException extends RuntimeException 
{ 
	private static final long serialVersionUID = 1L;
	public HourOutOfBoundsException() { 
	} 

  public HourOutOfBoundsException( String s ) { 
    super( s ); 
  } 
}

was mir an der ganzen Sache noch nicht so gefällt, ist der Konstruktor von der Kalender Klasse. Da initialisiere ich schonmal die "ganze Woche" mit den Stunden von 0-23 als Key und dem Wert Null, damit die Ausgabe nicht nur die geplanten Stunden ausgibt, sondern alle wie in deiner Vorgabe (wie gesagt eher Quick and Dirty, allerdings wäre die Überlegung nur die geplanten Stunden auszugeben). Ausserdem wird die komplette Woche ausgegeben und nicht nur ein Tag (hab bei dir kein shellui oder ähnliches gesehen, wo die Ausgabe festgelegt wird).

Weiß allerdings, wie gesagt, nicht in wiefern dir das jetzt weiterhilft . Was für dich jetzt vielleicht noch eine Intressante Übung wäre, wäre ein ShellUI zu basteln, der in der main() das Ganze steuert und benutzerdefinierte Eingaben/Ausgaben ermöglicht .

grüße
nrg

 

[nrg]

Hier jetzt nochmal eine Option nur mit Arrays. Hab ich glaub schonmal paar Posts drüber geschrieben, dass du noch eine Klasse Tag erstellen kannst:

Klasse Tag:

public class Tag {
	
	private Activity[] tag;
	
	public Tag() {
		setTag(new Activity[24]);
	}
	public void setTag(Activity[] tag) {
		this.tag = tag;
	}
	public Activity[] getTag() {
		return tag;
	}
	public void setzeAktivitaet(Activity act, int stunde) {
		tag[stunde] = act;
	}
}

Klasse Kalender:

public class Kalender {
	
	private Tag[] kalender;
	public Kalender() {
		kalender = new Tag[5];
	}
	public void setzeAktivitaet(Activity act, Wochentage wochentag, int stunde){
	        if (stunde < 0 || stunde > 24)
	        	throw new HourOutOfBoundsException("Invalid Hourparameter " + stunde + ". Integer must between 0 (inclusive) and 24 (exclusive).");
	        else if (kalender[wochentag.ordinal()] == null) 
	        	kalender[wochentag.ordinal()] = new Tag();
	        kalender[wochentag.ordinal()].setzeAktivitaet(act, stunde);
	}
	public double berechneBilanz(){
		double bilanz = 0;
		for (Tag t : kalender) {
			for (Activity a : t.getTag()) {
				if (a instanceof Skiunterricht)
					bilanz -= ((Skiunterricht)a).getPreisProStunde();
				else if (a instanceof Job)
					bilanz += ((Job)a).getGehaltProStunde();
			}
		}
		return bilanz;
	}
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		Wochentage[] w = Wochentage.values();
		int j = 0, i = 0;
		for (Tag t : kalender) {
			sb.append(w[i].name() + "\n");
			j = 0;
			for (Activity a : t.getTag()) {
				if (a != null)
					sb.append(j + " Uhr: " + a + "\n");
				else
					sb.append(j + " Uhr:\n");
				j++;
			}
			i++;
		}
		return sb.toString();
	}
}

Die Exception kannst du ja von oben entnehmen (oder komplett weglassen). Die Lösung ist wesentlich simpler als die vorherige. Damit kannst du bestimmt was angefangen. Wie gesagt, kannst ja ein schönes ShellUI rumbasteln.

grüße
nrg

 

[evil]

Oh man.. Das ist auf jeden Fall besser zu verstehen, ich werde mich gleich mal dransetzen und schaun, ob ich da alles versteh, wenn nicht, melde ich mich nochmal

Darf ich mal so nebenbei fragen, wie lange du das schon machst?