Array of objects und ständige Constructor-Aufrufe

[steinitz]

Ich habe für eine Übung eine PKW-Klasse erstellt.
dieser zählt eine statische Klassenvariable totalCars die Anzahl der erzeugten Instanzen.
Deshalb habe ich es in den Constructor gerlegt: totalCars++.
Soweit sind die Ausgeben korrekt und die Klasse scheint fehlerfei zu sein.

In einer weiteren Aufgabe habe ich eine Klasse Fuhrpark erstellt, deren Elemente diese PKWs sind.

Das Testprogramm funktioniert einwandfrei. Ich lege einen Fuhrpark mit 5 PKWs an.
Nur der PKW-Zähler wird auf über 200 am Ende des Programmlaufs erhöht.

Ich habe herausgefunden, dass der PKW-Constructor scheinbar jedesmal aufgerufen wird, wenn ich über das Array auf Methoden der PKW-Klasse zugreife.

Was ist der Grund für dieses Verhalten?

[Java]
*
*
*/
package ab5;

/**
*
*
*
*/
public class Aufgabe3 {
private static String[] angestellte = { "Andreas", "Sandra", "Julia", "Maria", "Annette" };
// Lenker und Mitfahrer könnte man auch mit dem vistor-pattern programmieren
public static void main(String[] args) {

final String UNT = "\n-------------------------\n";
System.out.println("Uebungsblatt 5, Aufgabe 3" + UNT);

PKW auto1 = new PKW("VW", "Team", 5, 4, 120, 89, 10.4f, 45.0f, 35.0f,
90000, 9);
PKW auto2 = new PKW("Golf", "GTI", 4, 4, 160, 95, 6.8f, 53.5f, 53.0f,
87000, 9);
PKW auto3 = new PKW("Toyota", "Corolla", 5, 4, 120, 89, 10.4f, 45.0f,
35.0f, 90000, 9);
PKW auto4 = new PKW("Saab", "890i", 5, 4, 160, 95, 6.8f, 53.5f, 53.0f,
77000, 9);
PKW auto5 = new PKW("Mitsubishi", "TDi", 2, 4, 120, 89, 10.4f, 45.0f,
35.0f, 16000, 9);
// Debug System.out.println(auto1);

// Anlegen des Fuhrparks
Fuhrpark testFuhrpark = new Fuhrpark();
testFuhrpark.addPKW(auto1);
testFuhrpark.addPKW(auto2);
testFuhrpark.addPKW(auto3);
testFuhrpark.addPKW(auto4);
testFuhrpark.addPKW(auto5);
// Debug
System.out.println(testFuhrpark);
System.out.println("\nAnzahl der PKW: " + testFuhrpark.getBelegt());
/* O.K. * /
PKW auto = testFuhrpark.getPKW( 5, 130 ); //
System.out.println( auto ); // fahren /*
/* */

// foreach - generisches for
// Volltanken aller PKWs
for (PKW pkw : testFuhrpark.fuhrpark) {
if (pkw != null)
pkw.fill();
}
System.out.println("\nDer Fuhrpark hat bisher insgesamt "
+ (testFuhrpark.getTotalCo2() / 1000.0f)
+ " kg CO2 produziert.\n---------------------------------------------------------------");
// ////////////////////////////////////////////////////////////////////////////

/*
* * / // Debug:
* System.out.println("Fahrzeug: "+testFuhrpark.getNumPKW(0) ); //
* status testFuhrpark.getNumPKW(0).drive(ettape); //
* System.out.println("Fahrzeug: " +testFuhrpark.getNumPKW(0) ); //
* status // Debug: PKW auto = testFuhrpark.getNumPKW(3); //
* auto.drive(ettape); // fahren /*
*/
Lenker fahrer = new Lenker();
// Auto suchen und ausgeben
boolean gefahren = true;
/* */
while (gefahren) {
// for ( PKW pkw : testFuhrpark.fuhrpark ){
// Strecke festlegen
int ettape = (int) ( Math.random() * 100.0 );
for ( int i = 0; i < testFuhrpark.getBelegt(); i++ ) {
// System.out.println( testFuhrpark.getBelegt() );
if (
( testFuhrpark.getNumPKW(i) != null )
&&
( testFuhrpark.getNumPKW(i).getCurrentFuelCapacity() > 2.0f )
)
gefahren = testFuhrpark.getNumPKW(i).canDriveKilometer(ettape);
else
gefahren = false;

if (gefahren) {
System.out.println("\nStrecke: " + ettape);
String str = angestellte[fahrer.getRandomPerson( angestellte.length )];
testFuhrpark.getNumPKW(i).drive(ettape); //

System.out.println("Das Modell "
+ testFuhrpark.getNumPKW(i).getModelName()
+ " wurde gefahren von "
+ str );
System.out.println( ( testFuhrpark.getNumPKW(i).getSeats() -1 ) +
" Personen können mitfahren.");

System.out.println("Tankinhalt nach der Fahrt: "
+ testFuhrpark.getNumPKW(i).getCurrentFuelCapacity());
} // - if

} // - for
} // - while
/* */
System.out.println("\nDer Fuhrpark hat insgesamt "
+ (testFuhrpark.getTotalCo2() / 1000.0f)
+ " kg CO2 produziert.");
System.out.println(testFuhrpark);

} // - main
} // - class

*

// ----------------------------------------------------------------------------
public class Fuhrpark {

// maximale Anzahl der Fahrzeuge; Klassenvariable
private static final int MAXCARS = 25;

/**
* @return the Constant MAXCARS; Klassenvariable
*/
public static int getMAXCARS() {
return MAXCARS;
}

// kritisch
public PKW[] fuhrpark = new PKW[MAXCARS]; // Assoziatiation
public int belegt = 0;

public int getBelegt() {
return belegt;
}

public void setBelegt(int frei) {
this.belegt = frei;
}

// Initialisierung
public Fuhrpark() {
super();
for (int i = 0; i < fuhrpark.length; i++) {
fuhrpark = new PKW();
} // - for
/*
* // Debug * / for ( int i = 0; i < fuhrpark.length; i++ ){
* System.out.println( "Initialisierung:" + fuhrpark); } // - for /*
*/
} // - Fuhrpark()

// Zugriff auf bestimmten PKW
public PKW getNumPKW(int num) {
PKW result = new PKW();
result = this.fuhrpark[num];
return result;
}
/* O.K. */
public PKW getPKW(int seats, int entfernung) {
PKW result = new PKW();
for (PKW pkw : this.fuhrpark)
if ((pkw != null) && (pkw.getSeats() == seats)&& pkw.canDriveKilometer(entfernung))
result = pkw;
return result;
}

// summiert nur CO2-Werte
// für die Berechnung ist die Klasse PKW zuständig
public int getTotalCo2() {
int result = 0;
for (PKW pkw : this.fuhrpark) {
if (pkw != null)
result += pkw.getCO2();
}
return result;
}

// Mutuator - setter
public void addPKW(PKW pkw) {
this.fuhrpark[belegt] = pkw;
this.setBelegt(this.getBelegt() + 1);
// Debug System.out.println("Frei: " +belegt );
}

public String toString() {
// setzt den String aus den Strings der Autos zusammen
String s = "";
for (int i = 0; i < fuhrpark.length; i++) {
if (fuhrpark.getManufacturer() != null)
s += fuhrpark.toString() + "\n";
}
return s;
}

} // - class

// ----------------------------------------------------------------------------
*/
public class PKW {

// //////////////////////// ATTRIBUTE //////////////////////////////
// //////////////////////// Klassenattribut ////////////////////////
private static int totalCars = 0;

private String manufacturer; // Hersteller

private String modelName; // Modell

private int doors; // Türen

private int seats; // Sitzplätze

private int horsePower; // Leistung

private float literper100km; // Verbrauch

private float maxFuelCapacity; // Tankinhalt

private float currentFuelCapacity; // Tankkapazität

private int kilometer; // Gesamtkilometer

// Sustainability

private int carbonDioxide; // g per km

private int totalCO2; // Gramm an CO2 seit Inbetriebnahme

public static String NEW_LINE;



// ///////////////////////////////////// Constructoren ///////////////////////////

PKW() {
super();// ruft Constructor der Oberklasse Object auf; IMMER in der ersten Zeile
// BUG!!!
totalCars++;
}

PKW( String manufacturer, String name,
int seats,
int doors,
int horsePower,
int carbonDioxide,
float literper100km,
float maxFuelCapacity,
float currentFuelCapacity,
int kilometer,
int totalCars
){
this(); // ruft parameterlosen Constructor auf; IMMER in der ersten Zeile
setModelName( name );
setManufacturer( manufacturer );
setSeats( seats );
setDoors( doors );
setHorsePower( horsePower );
setCarbonDioxide( carbonDioxide );
setLiterper100km( literper100km );
setMaxFuelCapacity( maxFuelCapacity );
setCurrentFuelCapacity( currentFuelCapacity );
setTotalKilometer( kilometer );
setTotalCO2( carbonDioxide * kilometer );
// setTotalNumberOfCars( totalCars ); -------------------------------------------------------------
//
// eigentlich Logik-Fehler
// daher auch nicht ausgewertet
// die Anzahl sollte vom Constructor erhöht werden
// und nicht willkürlich gesetzt werden können
//
}
// /////////////////////////////////// Setter und Getter ////////////////////////////////////////////////////

public void setManufacturer(String str) {
this.manufacturer = str;
}

public String getManufacturer() {
return manufacturer;
}

public String getModelName() {
return modelName;
}

public void setModelName(String str ) {
this.modelName = str;
}

public int getSeats() {
return this.seats;
}

public void setSeats(int val) {
this.seats = val;
}

public int getDoors() {
return doors;
}

public void setDoors(int val) {
this.doors = val;
}

public float getCurrentFuelCapacity() {
return this.currentFuelCapacity;
}

public void setCurrentFuelCapacity(float currentFuelCapacity) {
this.currentFuelCapacity = currentFuelCapacity;
}

public int getHorsePower() {
return horsePower;
}

public void setHorsePower(int val) {
this.horsePower = val;
}

public int getTotalKilometer() {
return this.kilometer;
}

public void setTotalKilometer(int val) {
this.kilometer = val;
}

public float getLiterper100km() {
return this.literper100km;
}

public void setLiterper100km( float val ) {
this.literper100km = val;
}

public float getMaxFuelCapacity() {
return maxFuelCapacity;
}

public void setMaxFuelCapacity(float val) {
this.maxFuelCapacity = val;
}

public int getTotalNumberOfCars() {
return totalCars;
}

public void setTotalNumberOfCars(int val) {
totalCars = val;
}

// /////////////////////////////////////////// Sustainability /////////////////////////////
public int getCarbonDioxide() { // g/km
return carbonDioxide;
}

public void setCarbonDioxide(int val) { // g/km
this.carbonDioxide = val;
}

public int getCO2() { // gramm per kilometer Gesamt
return totalCO2;
}

public void setTotalCO2(int totalCO2) { // gramm per kilometer
this.totalCO2 = totalCO2;
}
// //////////////////////////////////////// Methoden ///////////////////////////////////////////////////////////////
// Tanken O.K.
public void fill() {
this.setCurrentFuelCapacity( this.getMaxFuelCapacity() );
}
// soweit O.K.
public boolean drive( int kilometer ) {
// erzeugtes CO2
// Gesamtkilometer
float differenz = 0.0f;

differenz = getCurrentFuelCapacity();
// System.out.println("\ndebug - drive()- Tankinhalt vor : " + differenz);
differenz = differenz - usedFuel( kilometer );
// System.out.println("debug - drive()- Tankinhalt danach: " + differenz);
if ( differenz > 0.0f )
setCurrentFuelCapacity( differenz );
setTotalKilometer( ( getTotalKilometer() + kilometer ) );
// System.out.println("Debug: Gesamtkm " +getTotalKilometer() );
// System.out.println("Debug: differenz" +differenz );
setTotalCO2( getCO2() +erzeugtesCO2( kilometer ) );
// System.out.println("Debug: differenz" +differenz );
return true;
}

// O.K.
public boolean canDriveKilometer( int kilometer ) {

float differenz = 0.0f;

differenz = ( (getCurrentFuelCapacity() - usedFuel( kilometer ) ) );
//System.out.println("Debug: differenz" +differenz );
if ( differenz > 0.0f )return true;
else return false;
}


@Override
public String toString() {

StringBuilder result = new StringBuilder();
NEW_LINE = System.getProperty("line.separator");

// result.append(this.getClass().getName() + " Object {" + NEW_LINE);
result.append("\n Hersteller :\t" + manufacturer + NEW_LINE);
result.append(" Modell :\t" + modelName + NEW_LINE);
result.append(" Sitze :\t" + seats + NEW_LINE);
result.append(" Türen :\t" + doors + NEW_LINE);
result.append(" Leistung in PS :\t" + horsePower + NEW_LINE );
result.append(" Tankvolumen :\t" + getMaxFuelCapacity() + NEW_LINE );
result.append(" Tankinhalt :\t" + getCurrentFuelCapacity() + NEW_LINE );
result.append(" Kilometer :\t" + getTotalKilometer() + NEW_LINE );
result.append(" Gesamtgramm an CO2 :\t" + getCO2() + NEW_LINE );
// ////////////////////////////////////////////////////////////////
result.append(" Gesamtanzahl :\t" + getTotalNumberOfCars() + NEW_LINE);

// result.append("}");

return result.toString();
}

// ///////////////////////////// Helper - Hilfsmethoden private ////////////////////////////////////////////////////
// O.K.
public float usedFuel( int kilometer ) {
if ( kilometer > 0.0f )
return (float)( ( kilometer / 100.0f )* getLiterper100km() );
else
return 0.0f;
}

private int erzeugtesCO2( int kilometer ){
return kilometer * getCarbonDioxide();
}

}

[/Java]

 

[SlaterB]

 public PKW getNumPKW(int num) {
        PKW result = new PKW();
        result = this.fuhrpark[num];
        return result;
    }

dir fällt wirklich absolut nicht auf, wieso 'der PKW-Constructor scheinbar jedesmal aufgerufen wird'?

 

[ThreadPool]

 public PKW getNumPKW(int num) {
        PKW result = new PKW();
        result = this.fuhrpark[num];
        return result;
    }

dir fällt wirklich absolut nicht auf, wieso 'der PKW-Constructor scheinbar jedesmal aufgerufen wird'?

Das ist nicht die einzige .

Ich schlage folgende Links vor:
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 3.6 Mit Referenzen arbeiten

Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 6.5 Objekte anlegen und zerstören

 

[mabus]

Hallo,

dein Problem steckt in der Klasse Fuhrpark selber. Alleine im Konstruktor von Fuhrpark erzeugst du momentan 25 PKW-Objekte.

for (int i = 0; i < fuhrpark.length; i++) {
            fuhrpark[i] = new PKW();
        } // - for

Somit wird die statische Variable im Konstruktor von PKW alleine durch das erzeugen eines Fuhrpark-Objektes bereits um den Wert fuhrpark.length erhöht.

Anschliessend sieh dir bitte nochmal die get-Methoden deiner Fuhrpark-Klasse an. Auch dort werden ständig neue PKW-Objekte instanziert und somit die statische Variable mit jedem Aufruf erhöht.


EDIT: Ok, da waren welche schneller, während ich den Beitrag geschrieben habe

 

[steinitz]

Danke für die schnellen Antworten. Hat super funktioniert!

Wenn man zulange in den eigenen Source schaut, sieht an nichts mehr. Das getPKW qar z.B. so ein Knoten in irgendeiner Hirnwindung.