Hallo, liebe Leute,
da mein eigentliches Problem ("Objekt soll anderes Objekt zerstören") an der Realität* vorbeizugehen schein, habe ich eine andere Lösung gefunden: Es gibt eine Klasse
Gott, die andere Objekte erschaffen kann. Außerdem verwaltet sie das BuchDesLebens, in dem alle lebenden Objekte verzeichnet sind. Aus dieser Klasse wird das Objekt
derHerr instanziert, der bis in alle Ewigkeit über seine Schöpfung wacht.
Das ganze sieht dann so aus:
Main.java
Java:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package zoo002;
/**
*
* @author Frederik
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Gott wird erschaffen...
Gott DerHerr = new Gott("DerHerr");
// ...und beginnt mit der Arbeit.
DerHerr.start();
// als erstes erschafft er ein paar Hühner
Huhn Elfi = DerHerr.erschaffeHuhn("Elfriede", 730, "braun");
Huhn Berta = DerHerr.erschaffeHuhn("Berta", 523, "weiß");
// Die Hühner leben friedlich auf dem Bauernhof
Elfi.gruesse();
Berta.gruesse();
Elfi.scharre();
Berta.gackere();
Ei Osterei = Berta.legeEi();
// Bis der Herr beschließt, dass es genug ist und ein Huhn tötet
Elfi = DerHerr.toeteLebewesen(Elfi); // hier fände ich eine Lösung mit Out-Parameter intuitiver!
// Elfi.scharre(); // und hier wird eine Exception geworfen, weil das Huhn ja tot ist :-)
// weil es jetzt aber Langweilig ist auf der Erde, schafft Gott wieder ein zweites Huhn
Huhn Gundi = DerHerr.erschaffeHuhn("Kunigunde", 620, "schwarz");
// und das Leben geht weiter...
Gundi.gruesse();
// ...bis Gundi eines Tages völlig grundlos auf Berta losgeht
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Berta.gackere();
Gundi.attackiere(Berta);
Gundi.attackiere(Berta);
Gundi.attackiere(Berta); // hier stirbt Berta
}
}
Lebewesen.java:
Java:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package zoo002;
/**
*
* @author Frederik
*/
public class Lebewesen {
// ATTRIBUTE
private String Name;
private int Lebenskraft;
// GETer & SETer
void setName(String x) {
Name = x;
}
String getName() {
return Name;
}
void setLebenskraft(int x) {
Lebenskraft = x;
}
void erhöheLebenskraft(int x) {
Lebenskraft += x;
}
void erniedrigeLebenskraft(int x) {
Lebenskraft -= x;
}
int getLebenskraft() {
return Lebenskraft;
}
// DESTRUKTOR
@Override
protected void finalize() {
System.out.println(this.getName() + "> ist gerade gestorben.");
}
}
Huhn.java:
Java:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package zoo002;
/**
*
* @author Frederik
*/
public class Huhn extends Lebewesen {
// ATTRIBUTE
private float Gewicht;
private String Farbe;
// METHODEN
void gackere() {
System.out.println(getName() + ": *gack* *gack*");
}
void gruesse() {
System.out.println(getName() + ": Hallo, ich bin " + getName() + ".");
}
void scharre() {
System.out.println(getName() + "> scharrt auf dem Boden.");
}
void attackiere(Huhn Huhn) {
Huhn.erniedrigeLebenskraft(10);
if(Huhn.getLebenskraft() <= 0) {
System.out.println(getName() + "> hat " + Huhn.getName() + " getötet!");
// Wie im echten Leben! Da die Lebenskraft des Gegners <= 0 ist, meint das Huhn, es hätte seinen Gegner getötet.
// Aber wirklich tot ist das Huhn erst, wenn Gott es von seinen Leiden erlöst hat.
// Denn vielleicht lässt er es ja wiederauferstehen?
} else {
System.out.println(getName() + "> hat " + Huhn.getName() + " attackiert!");
}
}
Ei legeEi() {
System.out.println(getName() + "> hat ein Ei gelegt.");
return new Ei("braun", 45);
}
// KONSTRUKTOR
Huhn(String Name, float Gewicht, String Farbe) {
this.setName(Name);
this.setLebenskraft(100);
this.Gewicht = Gewicht;
this.Farbe = Farbe;
System.out.println(this.getName() + "> wurde soeben geboren.");
}
}
Gott.java
Java:
package zoo002;
import java.util.ArrayList;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Frederik
*/
public class Gott extends Thread { // eigentlich würde hier "extends Lebewesen impements Runnable" besser passen!
// ATTRIBUTE
String Name;
private ArrayList<Lebewesen> BuchDesLebens;
// METHODEN
@Override
public void run() {
// Gott macht bis in alle Ewigkeit nichts anderes, als seine Schöpfung zu überwachen
while(true) {
for(int i = 0; i < (BuchDesLebens.size() - 1); i++) {
Lebewesen Delinquent = BuchDesLebens.get(i);
if(Delinquent.getLebenskraft() <= 0) {
this.toeteLebewesen(Delinquent);
}
}
}
}
Huhn erschaffeHuhn(String Name, int Gewicht, String Farbe) {
// Das, was Gott am liebsten macht - ein neues Huhn erschaffen:
Huhn neuesHuhn = new Huhn(Name, Gewicht, Farbe);
// jetzt kommt der Verwaltungskram:
BuchDesLebens.add(neuesHuhn); // Huhn ins Buch des Lebens eintragen
// Das neue Huhn ins Leben entlassen:
return neuesHuhn;
}
Huhn toeteLebewesen(Lebewesen altesLebewesen) {
BuchDesLebens.remove(altesLebewesen);
altesLebewesen.finalize();
System.out.println(this.getName() + "> hat " + altesLebewesen.getName() + " von seinen Leiden erlöst.");
return null;
}
// KONSTRUKTOR
Gott(String Name) {
this.setName(Name);
BuchDesLebens = new ArrayList(0);
}
}
Jetzt gibt es zumindest mal ein Konstrukt, das über Leben und Tod der einzelnen Objekte wacht. Wie kann ich es aber realisieren, dass
derHerr darüber wacht, was ein Objekt darf und was nicht? Ich stell mir das so vor, dass
Berta scharren will (
Berta.scharre()
. derHerr schaut dann in sein BuchDesLebens und sieht "oh, da steht keine Berta drin, also ist sie tot". Und dann verbietet er
Berta das Scharren.
Du verstehst, was ich meine? Dass also nicht das Objekt selbst in jeder Methode prüft, ob es die noch ausführen darf oder nicht. Vielmehr soll das Objekt
derHerr managen, ober ein anderes Objekt überhaupt noch irgendwas darf oder nicht. egal was das ist...
Viele Grüße,
Frezl
---------------------------
* Wer diesen Satz aufmerksam liest, merkt, dass ich ganz nebenbei die Existenz Gottes bewiesen habe...
