# rechnen mit Stunden und Minuten



## Dodi.Hudori (14. Nov 2012)

und schon hab ich die nächste Aufgabe an der ich sitze (sollte ich das vielleicht alles in einem Thread schreiben?).

diesmal hab ich noch absolut keine Ahnung wie ich an die Sache rangehen soll 

ich soll laut Aufgabe folgendes erstellen:

eine Klasse Time die Objekte erzeugen, addieren, vergleichen und ausgeben kann.

Die Klasse soll enthalten:
die Attribute: Stunden und Minuten (beide vom Typ int),
verschiedene Konstruktoren zum Erzeugen der Objekte durch Angabe der Stunden und Minuten, nur durch Minuten oder durch Angaben in der Form "hour:min",
die Methoden (overloading) 

*public Time add(int min),

public Time add(Time t), was bedeutet hier Time?

public Time sub(int min)

public Time sub(Time t)*

zum Addieren und Subtrahieren von Zeiten, die Methode 

public int compareTo(Time t)

zum Vergleichen von Zeiten ( -1 wenn die aktuelle Zeit vor der Vergleichszeit liegt, 0 bei gleichen Zeiten und sonst 1)

und die Methode 

public String toString()

zur Ausgabe der Uhrzeit als String.

Testen Sie Time in main. Erzeugen Sie darin zufällige Time-Objekte und prüfen Sie daran die obigen Methoden.

hierzu hab ich mir erstmal folgendes Grundgerüst gebaut:


```
public class Time implements Comparable<Time>{
   private int h;      
   private int min; 
   private int sec;
   
   public Time add(int min) {
	return null;

   }
   public Time add(Time t) {
	return t;

   }
   public Time sub(int min) {
	return null;

   }
   
   public Time sub(Time t) {
	return t;

   }
   public int compareTo(Time t) {
	return h;

   }
   public String toString() {
	return null;

   }
   public static void main(String[] args) {

   }
}
```

klingt eigentlich nicht schwer, allerdings weiß ich absolut nicht wie ich da rangehen soll  auch dieses Video: Java Programmieren Lernen #41 - Die Objekte für die Constructors erstellen - YouTube

hat mir nur begrenzt weitergeholfen.

Ich bin für jeden eurer Tips dankbar! :/


----------



## bERt0r (14. Nov 2012)

> public Time add(Time t), was bedeutet hier Time?


Time ist ein zweites Time Objekt. Z.b was kommt raus wenn du zu 12:00 01:30 addierst?


----------



## Dodi.Hudori (14. Nov 2012)

Time add macht daraus (oder sollte daraus) 13:30 machen? aber wieso steht dort TIME t und nicht int t oder double?


----------



## Pentalon (14. Nov 2012)

Time ist der Datentyp der eigenen Klasse.
Damit kannst Du einen Parameter vom Typ Time übergeben.

Mit

```
Time t1 = new Time(1, 30);
```
 (nur mal so geraten, einen Konstruktor hast Du ja nicht gezeigt)
erstellst Du ja ein Objekt und dieses kannst Du dann mit:

```
Time t2 = new Time(t1);
```
übergeben.

Innerhalb der Methode kannst Du dann auf die privaten Felder 

```
private int h;      
   private int min; 
   private int sec;
```
zugreifen und damit rechnen.

Pentalon


----------



## Dodi.Hudori (14. Nov 2012)

also ich habe mich gerade mit mehreren Videos über Konstruktoren informiert und denke das ich das ganze nun etwas besser verstehe. Dem Konstruktor muss ich dann doch auch die h, min, und sec übergeben damit die Klasse Time damit rechnen kann oder?

edit: so ich hab mal einen kleinen Test geschrieben:


```
public class Time implements Comparable<Time>{
   private int h;      
   private int min; 

   
   public Time(int Stunden, int Minuten){
	   
	   h = Stunden;
	   min = Minuten;

	   
   }
   
   public Time add(int min) {


	return null;
	   
	     

   }
   
   public Time add(Time t) {
	return t;

   }
   
   public Time sub(int min) {
	return null;

   }
   
   public Time sub(Time t) {
	   
	return t;

   }
   
   public int compareTo(Time t) {
	return h;

   }
   
   public String toString() {
	return null;

   }
   
   public static void main(String[] args) {
	   
	   
	   Time t1 = new Time(6,12);
	   Time t2 = new Time(2,4);
	   
	   Time t3 = new Time(t1.h +t2.h, t1.min + t2.min);
	   
	   
	   System.out.println("alte Zeit " +t1.h+ " Stunden " +t1.min+ " Minuten" );
	   System.out.println("alte Zeit " +t2.h+ " Stunden " +t2.min+ " Minuten" );
	   System.out.println("neue Zeit " +t3.h+ " Stunden " +t3.min+ " Minuten" );
   }
}
```

ausgegeben wird:


```
alte Zeit 6 Stunden 12 Minuten
alte Zeit 2 Stunden 4 Minuten
neue Zeit 8 Stunden 16 Minuten
```

genial  so langsam wirds, in der Main kann ich zwei Zeiten schonmal zusammenrechnen,
aber wie bekomm ichs nun hin das ganze nicht in der Main zusammenzurechnen sondern in der Time add?


----------



## Pentalon (14. Nov 2012)

Das schaut schon gut aus.
Gewöhne Dir gleich an die Namenskonventionen einzuhalten:
Variablen klein, Methoden klein z.b. addTime(), Klassen Gross z.B. Time().

der Konstruktor sollte dann so aussehen:


```
public Time(int stunden, int minuten, int sekunden){
       
       this.h = stunden;
       this.min = minuten;
       this.sec = sekunden;
   }
```

Die Instanz von Time mit dem Namen t3 kannst Du nicht direkt ausdrucken, dazu machst Du Dir am Anfang einfach eine Methode anzeige().


```
public void anzeige() {
      
      system.out.println("Zeit= "+this.h+":"+this.min+":"+this.sec);
}
```

dann kannst Du mit 
	
	
	
	





```
t3.anzeige();
```
die Zeit dieser Instanz anzeigen lassen.

Später überschreibt man zu diesem Zweck die Methode toString, aber für den Anfang reicht auch die Methode anzeige();

Pentalon


----------



## Dodi.Hudori (14. Nov 2012)

Hallo Pentalon,

wie du oben siehst habe ich den Konstruktor nun so "gebaut" (die Sekunden brauch ich doch nicht):


```
public Time(int Stunden, int Minuten){
	   
	   h = Stunden;
	   min = Minuten;	   
   }
```

wenn ich das Video welches ich gerade geschaut habe richtig verstanden habe dient mir jetzt public Time add als zweiter konstruktor der nicht BEIDE werte fordert sondern auch nur mit dem Minuten wert umgehen kann, richtig?

das 
	
	
	
	





```
this
```
 habe ich bereits in meinen Unterlagen entdeckt, weiß allerdings nicht so recht was ich damit anfangen soll :/


----------



## Pentalon (14. Nov 2012)

Ja, Du kannst mehrere Konstruktoren haben, die mit unterschiedlichen Parametern die Instanz erzeugen können.

Mit THIS ist die jeweilige Instanz gemein, in der sich das Programm gerade befindet (current object).

Du kannst in der Methode auch eine Variable mit dem Namen h haben, dann würdest Du mit h=5 dieser Variable die 5 zuweisen. Mit this.h = 5 würdest Du der Instanzvariable die 5 zuweisen. Auch die Parameter der Methode können gleich heissen, wie die Namen der Instanfelder:


```
public Time(int h; int min) {
     this.h = h;
     this.min = min;
}
```

Lass Dich davon aber nicht verwirren, this ist einfach "dieses Objekt".

Pentalon


----------



## Dodi.Hudori (14. Nov 2012)

nun hab ich das mal umgebaut. Aber wie bekomm ich es jetzt hin das 2 Zeiten erzeugt werden und in der Public Time add oder Public Time sub berechnet werden? 


```
public class Time implements Comparable<Time>{
   private int h;      
   private int min; 

   //Konstruktor Stunden und Minuten
   public Time(int h, int min){   
	   this.h = h;
	   this.min = min;   
   }
   
   //Konstruktor Minuten
   public Time(int min){   
	   this.min = min;   
   }
   
   public Time add(int h, int min) {
	   
	   
	return null;
   }
   
   public Time add(Time t) {
	   
	
	   
	return t;

   }
   
   public Time sub(int min) {
	   
	return null;

   }
   
   public Time sub(Time t) {
	   
	return t;

   }
   
   public int compareTo(Time t) {
	return h;

   }
   
   public String toString() {
	return null;

   }
   
   public static void main(String[] args) {
	   
	   
	   Time t1 = new Time(6,12);
	   Time t2 = new Time(2,4);
	   Time t4 = new Time(50);
	   
	   Time t3 = new Time(t1.h +t2.h, t1.min + t2.min);
	   
	   
	   System.out.println("alte Zeit " +t1.h+ " Stunden " +t1.min+ " Minuten" );
	   System.out.println("alte Zeit " +t2.h+ " Stunden " +t2.min+ " Minuten" );
	   System.out.println("neue Zeit " +t3.h+ " Stunden " +t3.min+ " Minuten" );


   }
}
```


----------



## Pentalon (14. Nov 2012)

Daraus solltest Du die sub Methode ableiten können:


```
public Time add(int h, int min) {
	       
	       int stunde = this.h;
	       int minute = this.min;
	       
	       minute = minute + min;
	       if (minute > 59) {
	    	   minute = minute -60;
	    	   stunde++;
	       }
	       
	       stunde = stunde + h;
		   
	    return new Time(stunde, minute);
	   }
	   
	   public Time add(Time t) {
	 
	    return this.add(t.h, t.min);          // Hier wird nur das ADD mit den beiden INT Parametern aufgerufen
	   }
```

Deine Zeiten hast Du in der Main ja eh schon erzeugt.

```
Time t1 = new Time(6,12);
Time t2 = new Time(2,4);

Time t3 = t1.add(t2);
Time t4 = t1.add(5,15);
```

Sollte eigendlich klappen. Nicht getestet.

Pentalon


----------



## Dodi.Hudori (14. Nov 2012)

ich probiers mal aus  danke erstmal an dich


----------



## Creyawn (17. Nov 2012)

Hey Dodi.Hudori!
Kannst du mir vllt. sagen, welche Videos du dir genau angeschaut hast? Würde mich auch interessieren 
Thx


----------



## Dodi.Hudori (20. Nov 2012)

Aufgabe ist abgegeben und war soweit auch richtig, danke nochmal an alle hier 

Die Videos stammen ovn diesem Channel hier: http://www.youtube.com/feed/UCv0NoPtSgA_h_yd2HhbgoRg

find ich sehr gut erklärt und gefilmt!


----------



## Reactin (21. Nov 2012)

Der Link funktioniert leider nicht.


----------



## Dodi.Hudori (21. Nov 2012)

Reactin hat gesagt.:


> Der Link funktioniert leider nicht.



mit dem Link kommst du zum Youtube Cannel "Alles über Java", wenn du dir dort teil 26/27 (?) ansiehst erfährst du einiges über Konstruktoren mit einem sehr anschaulichen Beispiel


----------

