Typ für Instanzvariable später festlegen

[LTHEGD421]

Hallo,

ich habe da eine Frage: Kann man den Typ einer Instanzvariablen später festlegen?

Vereinfachtes Beispiel:
-3 Klassen: "Entscheidung", "Eins" und "Zwei"

In Klasse "Entscheidung" brauche ich eine Instanzvariable vom Typ "Eins" oder "Zwei". Der Typ soll erst im Laufe des Programms "Entscheidung" festgelegt werden, bis dahin werden sie nicht verwendet.

Geht das?

Bisher mache ich das so, dass ich beide Instanzvariablen anlege(Eins eins; Zwei zwei.
Und wenn später die Entscheidung getroffen wurde, nur eine davon verwende, die andere wird im weiteren Verlauf nicht benötigt.
Das nervige ist, dass wenn ich eine Methode aus Eins oder Zwei aufrufe, immer erst abfragen muss, ob Eins oder Zwei gewählt wurde.

 

[Gelöschtes Mitglied 5909]

für sowas verwendet man interfaces

 

[LTHEGD421]

Nachtrag:
Sorry hab das vergessen:

Ich meine z.Bsp so etwas:

public class Entscheidung {

public wahl; //Ohne Typ, nur Bezeichnung

...
public void entscheide() {

}

}

 

[gman]

Nein, das geht so nicht. Es muss immer ein Typ angegeben werden. Wie raiL schon sagte kannst
du dafür ein Interface erstellen das dann die beiden Klassen implementieren.

Eventuell könnte dir aber auch eine Enum mit den beiden Fällen weiterhelfen. Das hängt davon
ab wie die beiden Variablen verwendet werden.

 

[Gelöschtes Mitglied 5909]

für sowas verwendet man interfaces

public interface Essen {
	
	public void verzehren();
	
}

public class Doener implements Essen {

	public void verzehren() {
		System.out.println("lecker Döner!!");
	}
	
}


public class Burito implements Essen {

	public void verzehren() {
		System.out.println("viva mexico");
	}
	
}

public class Entscheidung {
		
	private Essen essen;
	
	public void entscheideDich(String essen) {
		if (essen.equals("döner") {
			essen = new Doener();
		} else {
			essen = new Burito();
		}
		essen.verzehren();
	}
	
}

 

[LTHEGD421]

Vielen Dank für eure Antworten und Anteilnahme.
An Interfaces habe ich gedacht, hatte gehofft, dass es vielleicht doch eine andere Möglichkeit geben würde, da ich noch nie mit Interfaces gearbeitet habe.

Ich lese mich erst einmal in das Thema ein. Das Beispiel von raiL ist wirklich genial, auf Anhieb versteht man worum es geht

Danke nochmals allerseits.

 

[Thief]

Nur aus Neugierd jetzt... Das war doch jetzt ein Abstract Factory Pattern?

 

[maki]

Ich sehe keine abstrakte Factory, auch keine konkrete Factory, eigentlich gar keine Factory

 

[Gelöschtes Mitglied 5909]

nö, da is nicht eine factory und für das abstract factory pattern brauchst du mindestens zwei factories (eine abstrakte, eine konkrete)

 

[Thief]

Wäre das keine Factory?

public interface Essen {
    
    public void verzehren();
    
}
 
public class Doener implements Essen {
 
    public void verzehren() {
        System.out.println("lecker Döner!!");
    }
    
}
 
 
public class Burito implements Essen {
 
    public void verzehren() {
        System.out.println("viva mexico");
    }
    
}
 
public class Nahrungsfactory {
        
    private Essen essen;
    private static Nahrungsfactory instance;

    public static Nahrungsfactory getInstance(){
       if(instance == null){
            instance = new Nahrungsfactory();
       }
       return instance;
    }

    
    public Essen getEssen(String essen) {
        if (essen.equals("döner") {
            return new Doener();
        } else {
            return new Burito();
        }
    }
}

public class Kunde{

   private Essen essen;

   public static void main(String[] args){
      Essen essen = NahrungsFactory().getInstance().getEssen("Döner");
      new Kunde(essen).eat();
   }

   public Kunde(Essen essen){
       this.essen = essen;
   }

   public void eat(){
      essen.verzehren();
   }
}

 

[LTHEGD421]

Jetzt hätte ich doch noch eine Frage dazu:

Übertragen auf raiL's Beispiel:

Die Methode "verzehren()" muss in einem eigenen Thread laufen. Kann ich die "Unterklasse extends Thread" dann einfach in die Klasse mit dem Interface reinpacken?

 

[LTHEGD421]

OK erledigt

Danke nochmals für die Anteilnahme und Hilfe.
Durch die Verwendung von Interfaces ergeben sich mir total neue Möglichkeiten. Ich hätte mich früher damit beschäftigen sollen, das ist in solch einem Fall natürlich viel effizienter... So nach und nach verstehe ich es immer mehr. Was ich erreichen wollte funktioniert einwandfrei.

 

[LTHEGD421]

Da bin ich wieder...
Jetzt habe ich einiges über Interfaces gelernt, und dennoch habe ich eine Frage:

Nehmen wir raiL's Beispiel aus Post #5, ich habe es umgeändert um meine Frage zu verdeutlichen:

public interface Bewertung {

    public void bewerten(String inhalt);

}

public interface Essen {
    
    public void verzehren();
    
}
 
public class Doener implements Essen {
 
    public void verzehren() {
        System.out.println("lecker Döner!!");
    }

    Bewertung b = new Bewertung();
    b.bewerten("war ein guter Döner");
     
    
}
 
 
public class Burito implements Essen {
 
    public void verzehren() {
        System.out.println("viva mexico");
    }

    Bewertung b = new Bewertung();
    b.bewerten("war ein guter Burito");
    
}
 
public class Entscheidung extends javax.swing.JFrame implements Bewertung() {
        
    private Essen essen;

    private TextField tf;

    public void bewerten(String inhalt) {

        tf.setText("war gut");
    }
    
    public void entscheideDich(String essen) {
        if (essen.equals("döner") {
            essen = new Doener();
        } else {
            essen = new Burito();
        }
        essen.verzehren();
    }
    
}
[code=Java]

...ein 2. Interface um Werte aus "Doener" oder "Burito" im Texfeld in "Essen" zu setzen.

Bisher habe ich sowas mit statischen Variablen erledigt. Wäre es nun besser das über ein Interface zu lösen, oder bei static zu bleiben? Besser soll heißen, effizienter bzw. performanter. Ich mache Berechnungen, und gebe mehrmals sekündlich Werte in bis zu 15 Textfeldern im JFrame aus. In diesem Beispiel hieße das: In einer Sekunde werden 20 Sachen gegessen und müssen ständig ausgegeben werden.

 

[LTHEGD421]

Sorry für meinen vorherigen Post, ignoriert ihn einfach...

Da bin ich wieder...
Jetzt habe ich einiges über Interfaces gelernt, und dennoch habe ich eine Frage:

Nehmen wir raiL's Beispiel aus Post #5, ich habe es umgeändert um meine Frage zu verdeutlichen:

public interface Bewertung {

public void bewerten(String inhalt);

}

public interface Essen {

public void verzehren();

}

public class Doener implements Essen {

public void verzehren() {
System.out.println("lecker Döner!!");
}

Bewertung b = new Bewertung();
b.bewerten("war ein guter Döner");


}


public class Burito implements Essen {

public void verzehren() {
System.out.println("viva mexico");
}

Bewertung b = new Bewertung();
b.bewerten("war ein guter Burito");

}

public class Entscheidung extends javax.swing.JFrame implements Bewertung() {

private Essen essen;

private TextField tf;

public void bewerten(String inhalt) {

tf.setText("war gut");
}

public void entscheideDich(String essen) {
if (essen.equals("döner") {
essen = new Doener();
} else {
essen = new Burito();
}
essen.verzehren();
}

}

...ein 2. Interface um Werte aus "Doener" oder "Burito" im Texfeld in "Essen" zu setzen.

Bisher habe ich sowas mit statischen Variablen erledigt. Wäre es nun besser das über ein Interface zu lösen, oder bei static zu bleiben? Besser soll heißen, effizienter bzw. performanter. Ich mache Berechnungen, und gebe mehrmals sekündlich Werte in bis zu 15 Textfeldern im JFrame aus. In diesem Beispiel hieße das: In einer Sekunde werden 20 Sachen gegessen und müssen ständig ausgegeben werden.

 

[myjday]

... und versteh auf einmal was Interfaces sind!

Hallo Leute!

Vielen Dank & Gruß,
myjday

 

[Landei]

Interfaces sind eine generelle Lösung, aber in so einfach gestrickten Fällen könnte man auch enums verwenden:

enum Essen {
  DOENER("lecker Döner","war ein guter Döner"), BURITO("viva la mexico","war ein guter Burito");
  private final String verzehr;
  private final String bewertung;
  Essen(String verzehr, String bewertung) {
     this.verzehr = verzehr;
     this.bewertung = bewertung; 
  }
  public String verzehren() { return verzehr; }
  public String bewerten() { return bewertung; }
}

In deinem Programm hast du dann eine Instanzvariable vom Typ Essen, die du mit DOENER oder BURITO belegen kannst.

Ein Vorteil von enums gegenüber normalen Klassen ist, dass man sie in switch-Statements verwenden kann, also keine if-Kaskade oder so braucht, um den aktuellen Wert einer Variable herauszufischen.

 

[maki]

@Thief
Das ist eine (concrete) Factory
leider mit Singleton...

 

[LTHEGD421]

...es geht mir eher darum, was von der Performance her am besten ist.

Beispiel:

public class GUI extends javax.swing.JFrame {

    public static void main(String[] args) {
        Zeige ein JFrame mit einem statischen Texfeld
        und einem Button an
    }

    private void buttonActionPerformed(java.awt.event.ActionEvent evt) {
        Rechner r = new Rechner();
        r.berechne();
    }
}

public class Rechner {
    public void berechne() {
        while (sehr lange zeit) {
            berechne;
            GUI.Textfeld.setText(aktuellesErgebnis);
        }
    }
}

Den Wert "aktuellesErgebnis" gebe ich direkt über statischen Zugriff auf dem Textfeld der GUI aus. Meine Frage ist, ob es einen performanteren Weg gibt, sodass ein Schleifendurchlauf nach Berechnung und Ausgabe schneller erfolgt.