Variable Menge von Objekten erzeugen und mit ihren Attributen rechnen

[yogo]

Hallo,

seit einiger Zeit arbeite ich an einem Problem und komme nicht weiter, weshalb ich hier um Hilfe bitte.

Ich möchte ein Programm erstellen, dass die Temperatur an Wandschichten berechnet. Dafür habe ich eine csv-Datei mit den benötigten Angaben für die Wandschichten eingelesen und eine Klasse Wandschicht erstellt. Eine weitere Klasse Wand soll nun die Schichten als Attribute bekommen und damit rechnen.

Mein erstes Problem besteht darin, dass ich eine Anzahl von Schichten für meine Wand erzeugen will, die der Liste entnommen werden soll. Ist das was ich geschrieben habe richtig oder wo liegen die Fehler?
Als zweites möchte ich, in einer for-Schleife einen Wert "rGes" ausrechnen, der die Summe aus einzelnen "R" ist. Die Anzahl und der Wert der "R" sind wiederum abhängig von den Schichten in der Liste.
Wie muss eine for-Schleife aussehen, die das kann? (Meine ist offensichtlich falsch)


Ich bin für jeden Hinweis sehr dankbar!!!

MfG
yogo

package wandBerechnungen;

import java.util.ArrayList;


public class Wand {
	
	// Attribute
	private double rsi;		// W.übergangswiderstand innen [(Km^2)/(m^2)]
	private double rse;		// W.übergangswiderstand außen [(Km^2)/(m^2)]
	private double ti;										// Innenraumtemperatur [°C]
	private double te;										// Außentemperatur [°C]
	private ArrayList<Wandschicht> Schichten;	// Wie kommt die Wand zu ihren Schichten?
	private Wandschicht sch;
	
	// get-; set-Methoden
	public void setRsi(double rsInnen){
		rsi = rsInnen;
	}
	public double getRsi(){
		return rsi;
	}
	
	public void setRse(double rsAussen){
		rse = rsAussen;
	}
	public double getRse(){
		return rse;
	}
	
	public void setTi(double tInnen){
		ti = tInnen;
	}
	public double getTi(){
		return ti;
	}
	
	public void setTe(double tAussen){
		te = tAussen;
	}
	public double getTe(){
		return te;
	}
		
	// Funktion, die Wandschichten hinzufügt...
	public void setSchicht(Wandschicht schicht){
		
		for(int i = 0; i< Schichten.size(); i++){
			schicht.getDicke();
			schicht.getWaermeleitfaehigkeit();
			schicht.getR();
		}
		sch = schicht;
	}
	
	// ... und die sie zurückgibt
	public Wandschicht getSch(){
		return sch;
	}
	
	// R gesamt						
	double rGges = 0;
		for(int i=0; i<Schichten.size(); i++){
			rGges  += Schichten.get(sch.setR()); 
		}
	rGges  = rsi +rse + rGes;
	
	
	// Wärmestromdichte
	
	public double getWaermestromdichte(){
		double q = (1/(getRsi() + rGes + getRse()))*(getTi()-getTe());
		return q;
	}
	
	// Schichttemperatur + Schichtindex --> 
	
	public double getTemperatur(int index){
		if(index < 0){
			double tInnenwand = getTi() - getWaermestromdichte()*getRsi();	// Oberflächentemperatur innen
			return tInnenwand;
		} else {
			double Schichttemperatur = getTi() - getWaermestromdichte()*(getRsi()+sch.getR());
			return Schichttemperatur;
		}
	}	
}

 

[VfL_Freak]

Moin,

oh oh, Dein Code ist aber nicht wirklich lesbar ...
Gewöhne Dir am besten gleich "sprechende" Bezeichner an !

Als zweites möchte ich, in einer for-Schleife einen Wert "rGes" ausrechnen, der die Summe aus einzelnen "R" ist. Die Anzahl und der Wert der "R" sind wiederum abhängig von den Schichten in der Liste.
Wie muss eine for-Schleife aussehen, die das kann? (Meine ist offensichtlich falsch)

Also hierzu ist zu sagen, das Deine for-Schleife einfach zwischen deinen Methoden in der Luft hängt und somit nirgendwo zu Einsatz kommt (jedenfalls soweit ich es überschaut habe)!

Gruß
Klaus

 

[mrbela]

zu 1)

mit "Schichten.size()" kannst Du arbeiten. Das machst Du also richtig..! Als Anmerkung: Man schreibt alle (!) Variablen klein. Also ist "schichten" viel schöner als "Schichten". 😉

zu 2)

Die For-Schleife an sich sieht richtig aus und sollte auch das tun, was Du Dir gedacht hast. Aber wie Klaus schon meinte, wird die ja gar nicht aufgerufen, da sie irgendwo im Nichts hängt.. Pack die doch in eine Methode rein und ruf diese (Methode) dann auf, wenn Du sie brauchst.

Viel Erfolg!

 

[yogo]

Hallo,

Danke für die Antwort!

Was meinst du mit "sprechenden Bezeichnern"?

Meinst du das bei der Schleife ungefähr so?

// R gesamt
	public double getRges(){
		double rGes = 0;
		for(int i=0; i<Schichten.size(); i++){
			rGes  += sch.getR(); 
		}
	return rGes  = rsi + rse + getRges();
	}

MfG
yogo

 

[mrbela]

"Sprechende Bezeichner" heißt so viel, dass Du die Variablen so benennst, dass sie auch ein dritter gut lesen und vor allem verstehen kann, was damit gemeint ist.

    private double ti;                                      // Innenraumtemperatur [°C]
    private double te;                                      // Außentemperatur [°C]

hier wäre durchaus

private double tempInnen;
private double tempAussen;

deutlich aussagekräftiger...

Die For-Schleife mit Methode sieht gut aus!

Nur musst Du noch schauen, was Du da genau machst:

for(int i=0; i<Schichten.size(); i++){
            rGes  += sch.getR(); 
        }

Willst Du nicht die ganzen Schichten an sich durchgehen?

Dann müsstest Du bspw. sowas in der Art versuchen:

for(int i=0; i<Schichten.size(); i++){
            rGes  += Schichten.get(i).getR(); 
        }

 

[VfL_Freak]

Moin

Was meinst du mit "sprechenden Bezeichnern"?

na ja, "sprechend" bezeichnet eine Namensgebung, von der Du selbst in 6 Monaten noch weißt, was das Ganze bedeuten soll ...

Beispiel: nicht "getRges", sonder besser "getResultGesamt"
Beispiel: was soll denn bitte "sch" oder (noch schlimmer) "R" sein 😱 ???:L

Meinst du das bei der Schleife ungefähr so?

// R gesamt
	public double getRges(){
		double rGes = 0;
		for(int i=0; i<Schichten.size(); i++){
			rGes  += sch.getR(); 
		}
	return rGes  = rsi + rse + getRges();
	}

Möglicherweise - so denn die Methode auch aufgerufen wird!
Es geht hierbei auch nicht darum, alles wild uim Methoden zu packen, sondern in den jeweils richtigen
Kontekt !!

Gruß
Klaus

 

[Joose]

Was meinst du mit "sprechenden Bezeichnern"?

    private double rsi;     // W.übergangswiderstand innen [(Km^2)/(m^2)]
    private double rse;     // W.übergangswiderstand außen [(Km^2)/(m^2)]
    private double ti;                                      // Innenraumtemperatur [°C]
    private double te;                                      // Außentemperatur [°C]

Unter

te

,

ti

,

rse

oder

rsi

kann man beim Lesen des Codes nicht wirklich etwas erfahren. Dass du deinen Code verstehst und weißt was auf den Variablen gespeichert wird ist zwar schön und gut, aber andere werden ihre Probleme haben damit (was auch Helfern betrifft bei Fehlern 😉)

Verwende stattdessen Bezeichnungen wie

temperaturInnen

. Ist zwar länger und mehr zu tippen. Aber jeder kann sich sofort was darunter vorstellen und durch eine IDE mit AutoComplete ist es auch schnell "getippt".

 

[yogo]

Danke für eure Hinweise und die schnelle Hilfe!

Ich werde die Bezeichungen noch ändern.

Viele Grüße
yogo