Zeitumrechnung

[Maurice16]

Hallo Leute
Ich habe hier Programm,womit am die europäische Zeit/ das Datum in die amerikanische umzurechnen kann.

 //Versuch4.java
//Umwandlung von Europäischer Zeit und Temperatur in Amerikanische

import javax.swing.JOptionPane;

public class Versuch4{

//Deklaration aller Methoden für die Variablen

public static String eingabeEUZeit,eingabeEUTemperatur;
public static double temperaturC,temperaturF;
public static int zeitE,zeitA;
public static boolean am;

public static void main(String args[]){
//Eingabe der Werte

	eingabeEUZeit=JOptionPane.showInputDialog("Geben Sie die EU Zeit in hhmm ein,\nwelche in die amerikanische Zeit ungewandelt wird:");

	eingabeEUTemperatur=JOptionPane.showInputDialog("Geben Sie die EU Temperatur in °C ein,\nwelche in °F umgewandelt wird:");

//Deklaration der Zeit und Temperatur

	zeitE=Integer.parseInt(eingabeEUZeit);

	temperaturC=Double.parseDouble(eingabeEUTemperatur);

//Ausgabe eingeben

	ausgabe();
	System.exit(0);

}


public static void ausgabe(){
//Get Werte und Methoden durchlaufen lassen;

temperaturC = getTC();
temperaturF = tChange(temperaturC);
zeitE = getZE();
am = controllam(zeitE);
zeitA = zChange(am,zeitE);

//Anfang der Ausgabe


if(am == true){
JOptionPane.showMessageDialog(null,temperaturF + " = Umgewandelte Temperatur in °F \n" + zeitA+ " am,ist die amerikanische Zeit");

}
else{
JOptionPane.showMessageDialog(null,temperaturF + " = Umgewandelte Temperatur in °F \n" + zeitA + " pm,ist die amerikanische Zeit");
}


}


//Methode der Temperaturumwandlung


static double getTC() {
  return temperaturC;
}



static double tChange(double temperaturC)
{
double temperaturF;
temperaturF = (temperaturC * 9/5) + 32;
return temperaturF;

}


//Methode zur Zeitumwandlung



static int getZE(){
return zeitE;
}




static boolean controllam(int ZE)
{
	if(ZE < 1200)
	{
		am = true;
	}
	
	else if(ZE == 2400)
	{
		am= true;
	}
	
	else{
		am = false;
	}

return am;
}


// Zeitumwandlung


static int zChange(boolean am, int zeitE){	
	if(am == true && zeitE != 0 && zeitE != 2400)
	{
		zeitA = zeitE;
	}
	
	else if(zeitE == 0 )
	{
		zeitA = (zeitE+1200);
	}
	
	
	else{
		zeitA = (zeitE-1200);
	}
	return zeitA;
}

}

Meine Frage..
Wozu dient

static double getTC() {
  return temperaturC;
}

static int getZE(){
return zeitE;
}

Nächste Frage,
Wie nennt man das was man in diesem Teil des Programmes macht, und wozu nützt es?

public static void ausgabe(){
//Get Werte und Methoden durchlaufen lassen;

temperaturC = getTC();
temperaturF = tChange(temperaturC);
zeitE = getZE();
am = controllam(zeitE);
zeitA = zChange(am,zeitE);

Danke im Vorraus =)

 

[Collinwood]

Meine Frage..
Wozu dient

static double getTC() {
  return temperaturC;
}

static int getZE(){
return zeitE;
}

Den "static"-Modifier mal außer Acht gelassen, sind das sog. "Getter-Methoden", die eigentlich dafür gedacht sind, in objektorientierten Sprachen den Objekten anderer Klassen die Inhalte der Attribute bereitzustellen. Brauchst du auch eine Erklärung zum Thema "static" oder ist das erstmal unwichtig?

Nächste Frage,
Wie nennt man das was man in diesem Teil des Programmes macht, und wozu nützt es?

public static void ausgabe(){
//Get Werte und Methoden durchlaufen lassen;

temperaturC = getTC(); //Total unnütz, hier wird die Celsius-Temperatur aus der Getter-Methode in das Klassenattribut geschrieben.
temperaturF = tChange(temperaturC); // Hier wird eine Methode aufgerufen, die das Temparaturformat ändert. Der Methoden-Parameter ist die Celsius-Temp. und es wird in dem Attribut für die Fahrenheit-Temp. gespeichert.
zeitE = getZE(); // //Total unnütz, hier wird die europäische Zeit aus der Getter-Methode in das Klassenattribut geschrieben.
am = controllam(zeitE); // Mit dieser Methode vom Rückgabetyp "Boolean" wird überprüft, ob das Format tatsächlich amerikanisch vorliegt.
zeitA = zChange(am,zeitE); // Hier wird eine Methode aufgerufen, die das Zeitformat ändert. Die Methoden-Parameter sind die amerikanisch?-Boolean und die europäische Zeit und es wird in dem Attribut für die amerikanische Zeit gespeichert.

Danke im Vorraus =)

Bitte

Edit: Der eben kritisierte Code sieht folgendermaßen etwas schöner aus:

temperaturF = tChange(getTC());
zeitA = zChange(controllam(zeitE),zeitE);

 

[Maurice16]

Was wäre denn die Folge daraus, wenn ich die Sachen einfach weg lassen würde?

 

[Collinwood]

Welche Sachen weglassen?

 

[Maurice16]

static double getTC() {
  return temperaturC;
}

tatic int getZE(){
return zeitE;
}

 

[Collinwood]

Also wenn die Klasse so bleibt wie sie ist, und nichts dazu kommt, dann ist es völlig egal ob du schreibst:

temperaturF = tChange(getTC());
zeitA = zChange(controllam(getZE()),getZE());

oder

temperaturF = tChange(temperaturC);
zeitA = zChange(controllam(zeitE),zeitE);

Aber "normal" wäre eigentlich ein objektorientiertes Umfeld, dann verschwindet auch der ganze "Static-Müll", und dann sähe der Code so aus:

this.temperaturF = this.tChange(this.temperaturC);
this.zeitA = this.zChange(this.controllam(this.zeitE),this.zeitE);

 

[Maurice16]

Aber was bezweckt dieser Ausdruck?
Das verstehe ich nicht

 

[Collinwood]

Wenn ich alles detailliert erklären müsste, wird das hier zu lang, ich bitte also darum, nach den Wörtern mit "*" dahinter im Zusammenhang mit dem Wort "Java" mit einer Suchmaschine das nötige Wissen zu erwerben.

Du kannst deinen Attributen* entweder in einer einzigen Zeile ein Ergebnis eines Methodenaufrufs* direkt zuweisen*. Das sieht dann so aus:

temperaturF = tChange(temperaturC); // temperaturF: Attribut // tChange(): Methodenaufruf, diese Methode erwartet einen Parameter vom Typ "double" und gibt einen ebensolchen zurück.

Du machst also in einem Schritt einen Methodenaufruf* und mit dem resultierenden Ergebnis eine Zuweisung*.
Zum nachlesen, welche Ergebnisse man zuweisen kann und welche nicht, bitte auch nach dem Unterschied der Methodentypen in Java suchen (void oder mit Rückgabetyp)*.
Es geht aber, für Anfänger einfacher geeignet, auch in zwei Schritten:

variable = ErgebnisDieserMethode();
andereVariable = ErgebnisAndererMethode(variable);

Und das mit den Getter-Methoden* erkläre ich jetzt ein wenig:
Für die Attribute* deiner Klasse existieren, je nach Modifier* bestimmte Zugriffsrechte*. Es ist nicht immer möglich, für Objekte* außenstehender Klassen* auf die Attribute* des Objekts* DIESER Klasse* zuzugreifen (manipulieren oder lesen). Um einen etwaigen Zugriff sauber zu ermöglichen, erstellt man für ein Attribut* Getter*- und Setter*-Methoden. Den Zugriff kann man dann erstmal einfach steuern mit den Modifiern* "public"* und "private"*.
Das sieht dann so aus:

String s = ""; //Attribut

//Diese Methode darf von jedem anderen Objekt aufgerufen werden
public String getString() {
return this.s; //this bedeutet, dass das Attribut gemeint ist, und keine gleichnamige andere Variable
}

//Diese Methode darf nur das eignende Objekt selbst ausführen
private void setString(String s) {
this.s = s; //this jetzt klar?
}