Polymorphie Programmdesign Frage

[GhostfaceChilla]

Hallo Leute.
Ich arbeite zur Zeit an einem kleinen Projekt, wo ich Befehle einer Fernbedienung entgegennehme und diese dann verarbeite. Nun habe ich mir diese 3 Klassen erstellt:

public class UsbDataInputListener implements UsbPipeListener {
    
    @Override
    public void errorEventOccurred(UsbPipeErrorEvent upee) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public void dataEventOccurred(UsbPipeDataEvent upde) {
        final byte[] recData = upde.getData(); //Übertragene Bytes
        //Input wird überprüft
        //Aktion für die jeweilige Taste wird durchgeführt
        if(Arrays.equals(recData, Keys.POWER)){
            Key_Action.callShutdown();
        }
        ....
        ....
    }

Diese Klasse horscht auf eine ErrorEvent oder ein DataEvent. Ein DataEvent wird durch den Druck auf eine Taste aufgerufen.

public final class Keys {

    public static final byte[] POWER = {4,1}; 
    //Direkt Zugriff aus Musi,Spiele,Gallerie und Videos
    public static final byte[] MUSIC = {2,5,0,4,0,0,0,0,2,5,0,30,0,0,0,0};
    public static final byte[] GAME = {2,5,0,5,0,0,0,0,2,5,0,31,0,0,0,0};
    public static final byte[] GALLERY = {2,5,0,6,0,0,0,0,2,5,0,32,0,0,0,0};
    public static final byte[] VIDEO = {2,5,0,7,0,0,0,0,2,5,0,33,0,0,0,0};
    //Steurung für Film und Musik
    public static final byte[] BEFORE = {3,-74,0};
    public static final byte[] BEFORE2 = {2,0,0,0,0,0,0,0,3,-74,0};
    public static final byte[] NEXT = {3,-75,0};
    public static final byte[] NEXT2 = {2,0,0,0,0,0,0,0,03,-75,0};
    public static final byte[] BACKWARD = {3,-53,0};
    public static final byte[] BACKWARD2 = {2,0,0,0,0,0,0,0,03,-53,0};
    public static final byte[] FORWARD = {3,-54,0};
    public static final byte[] FORWARD2 = {2,0,0,0,0,0,0,0,03,-54,0};
    public static final byte[] PLAY = {3,-51,};
    public static final byte[] PLAY2 = {2,0,0,0,0,0,0,0,03,-51,0};
    public static final byte[] STOP = {3,-73,0};
    public static final byte[] STOP2 = {2,0,0,0,0,0,0,0,03,-73,0};
    //Nummernfeld und Navigation durch das Menü
    public static final byte[] NUMBER_ONE = {2,0,0,43,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] UP = {2,0,0,82,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] NUMBER_THREE = {2,-128,0,0,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] LEFT = {2,0,0,80,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] ENTER = {2,0,0,40,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] RIGHT = {2,0,0,79,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] NUMBER_SEVEN= {2,1,0,18,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] DOWN = {2,0,0,81,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] ESCAPE = {2,0,0,41,0,0,0,0,2,0,0,0,0,0,0,0};
    public static final byte[] ZERO = {2,0,0,0,0,0,0,0,2,4,0,43,0,0,0,0};
    //Lautstärkeregelung
    public static final byte[] VOL_UP = {3,-23,0};
    public static final byte[] VOL_DOWN = {3,-22,0};
    public static final byte[] MUTE = {3,-30,0};
}

Diese Klasse beinhaltet den jeweiligen bytecode der Tasten

public class Key_Action {
    
    private static final Runnable SHUTDOWN = new Runnable(){
        @Override
        public void run() {
            try {
                ShutdownInfoController isc = new ShutdownInfoController();
                Window shtdnWin = new Window("/app/view/ShutdownInfoView.fxml","Info zum Herunterfahren",
                                  isc,false);
            } catch (IOException ex) {
                Logger.getLogger(Keys.class.getName()).log(Level.SEVERE, null, ex);
            }
        }  
    };
    
    //Ruft das neue Fenster auf
    public static void callShutdown(){
        Platform.runLater(SHUTDOWN);
    }
    
    //PC wird heruntergefahren
    public static void actShutdown() throws IOException{
        String cmdtext = "shutdown.exe /s /hybrid /t 0 "; // Befehl um PC herunterzufahren
        Runtime.getRuntime().exec(cmdtext); // Befehl wird ausgeführt;
    }
    
    
}

Diese Klasse führt dann die eigentliche Aktion der Taste aus, hier z.B die POWER Taste.

Meine Frage wäre jetzt, ob das Programmieren so ok ist? Ich habe auch shcon überlegt eine Klasse Key zu erstellen und dieser die Konstanten und den inhalt der Klasse Key_Action zuzuweisen und eine Instanzvariable byte[], die die aktuelle Taste wiederspiegelt. Aber das fände ich persönlich komplizierter. Nun wollte ich fragen was ihr davon haltet?Kann man den code so lassen, wenn nicht wäre eine kurze Erklärung ganz hilfreich

-GhostfaceChilla-

 

[Natac]

Ich würde aus Keys ein enum machen, dass auch noch gleich ein paar schöne Methoden anbietet:

public enum Keys{
  POWER(4,1),
  MUSIC(2,5,0,4,0,0,0,0,2,5,0,30,0,0,0,0),
  
  //... 

  private byte[] bytes;

  private Keys(byte... bytes){// Konstruktor mit varargs ermöglicht byte-arrays verschiedener länge
    this.bytes = bytes;
  }

  public boolean equals(byte[] bytes){//Methode zum vergleichem mit einem andere byte-array
    return Arrays.equals(bytes, this.bytes);
  }

  public static Keys getKey(byte[] bytes){//Methode zum finden eines Keys bei gegebenem Byte-Array
    for(Keys key: values()){
      if(key.equals(bytes)){
        return key;
      }
    return null; // Vorsicht, NPE möglich!
  }

}

Damit ist die Klasse schon mal "Aufgeräumter". Und die Nutzung sieht dann auch schöner aus:

 public void dataEventOccurred(UsbPipeDataEvent upde) {
        final byte[] recData = upde.getData(); //Übertragene Bytes
        //Input wird überprüft
        //Aktion für die jeweilige Taste wird durchgeführt
        if(Keys.POWER.equals(recData)){
            Key_Action.callShutdown();
        }
        ....
        ....
    }[/Java]

Wenn die Aktion pro Taste immer gleich bleibt, könnte man überlegen, ob man das entsprechende Runnable auch mit ins Enum packt. Denn so wie es aktuell aussieht, prüfst du per if jede Taste durch. Das könnest du dann mit [code=Java]Keys key = Keys.getKey(upde);
if(key !=null){
  key.call();
}

abkürzen. call() ist dabei die Methode im Enum, die das entsprechende Runnable aufruft. Den Code dafür habe ich hier jetzt nicht geschrieben.
Vielleicht geht das aber auch schon zu weit. Poste mal mehr Code, dann kann man auch besser sagen, wie man den Code noch optimieren kann.

EDIT: Ist dir bewusst, dass 03 mit der führenden 0 oktal interpretiert wird? Also 03 = 3, 08 = 10, 09 = 11

 

[GhostfaceChilla]

Vielen Dank schonmal
Ja, die 03 soll als 03 da stehen, das is beabsichtig
Und nein, jede Taste führt eine andere Aktion aus, daher muss auch mit if else alles durchgeprüft werden, ist zwar nervig, aber mit switch oder sonstigem ist die leider nicht zu realisier.

-GhostfaceChilla-

 

[Gucky]

Wenn jetzt die letzte Taste gedrückt wird, musst du dennoch sämtliche Tasten prüfen. Das ist ein riesiger Overhead, den du dir aufbürdest. Und schön sieht es IMHO auch nicht aus.

Ich halte eine Art Binärbaum für besser, dass du die Tastatur in Bereiche zu vielleicht 10 oder weniger Tasten aufteilst und erst überprüfst, in welchem Bereich eine Taste gedrückt wurde und dementsprechend eine weiterführende Methode aufrufst.

 

[Natac]

Vielen Dank schonmal
Ja, die 03 soll als 03 da stehen, das is beabsichtig
Und nein, jede Taste führt eine andere Aktion aus, daher muss auch mit if else alles durchgeprüft werden, ist zwar nervig, aber mit switch oder sonstigem ist die leider nicht zu realisier.

-GhostfaceChilla-

Natürlich führt jede Taste eine andere Aktion aus. Die Frage ist: ist diese Aktion pro Taste immer gleich?

Wenn ja, könntest du das enum eben entsprechend erweitern:

public enum Keys{
  POWER(new Runnable(){ // geht ab Java 8 mit Lambdas schöner
    public void run(){
       //Do power action
    }
  }, 4,1),
  
  MUSIC(new Runnable(){
    public void run(){
       //Do music action
    }
   }, 2,5,0,4,0,0,0,0,2,5,0,30,0,0,0,0),

   private Runnable action;
   private byte[] bytes;

   private Keys(Runnable action, byte... bytes){
     this.action = action;
     this.bytes = bytes;
   }

   public void callAction(){
    action.run();
  }

  //... weitere Methoden (s.o.)
}

Wenn die Aktionen der Keys sehr kompliziert sind, könnte man auch überlegen zusätzlich zum enum auf eine Klassen-Stuktur zu verwenden, die die Aktionen abbildet.
Also eine abstrakte Klasse "Key" definieren, und jeden Key als konkrete Klasse implementieren (PowerKey, MusicKey, etc...) die von "Key" erbt.
Dann statt Runnable einfach ein Key-Objekt im Enum verlangen und für jeden Enum-Eintrag die entsprechende Klasse instanzieren.

Die Grundidee ist: Jeder Key weiß selbst, was er machem muss. Dann kannst du deine if-else-Kaskake nämlich auf drei Zeilen kürzen:

public void dataEventOccurred(UsbPipeDataEvent upde) {
  byte[] bytes =  upde.getData();
  Keys key = Keys.getKey(bytes); //richtigen key raussuchen
  if(key != null){
    key.callAction();//aktion für diesen Key ausführen
  }
}

 

[GhostfaceChilla]

Ok, das mit dem Binärbaum müsste ich mir mal anschauen, wie das jetzt gemeint ist. Könntest du vielleicht etwas genauer ausführen wie du ds meints? Und das mit dem pro Taste eine Klasse, hab ich mir auch schon gedacht, das wäre ja eigentlich ja dann auch "OOP" oder? Vielen dank Leute, bhatte gar nicht gewusst wie viel Verbesserungspotenzial in meinem Code steckt.

EDIT: Mir ist aufgefallen, das z.B alle Medienshortcuts mit [2,5,0] anfangen und z.B die Navigations- und Buchstabentasten mit [2,0,0] und die Videotasten alle mit [2,0,0,0,0,0,0,0,03] anfangen. D.h, ich könnte ja theoretisch nur 3 if Abfragen machen um eine kleine Auswahl auszugrenzen und dnn erst auf die genaue Taste prüfen oder ist das auch nicht so die schöne Art?

@Natac: Wie aber weis dein key Objekt, welche Taste es jetzt darstellt?Durch z.B key.getKey(byte[] b) weist man ja dann nur den Bytecode zu, aber d.h das Key Objekt weis ja nicht ob es jetzt ein PowerKey, MusicKey etc. ist ...

-GhostfaceChilla-

 

[Natac]

@Natac: Wie aber weis dein key Objekt, welche Taste es jetzt darstellt?Durch z.B key.getKey(byte[] b) weist man ja dann nur den Bytecode zu, aber d.h das Key Objekt weis ja nicht ob es jetzt ein PowerKey, MusicKey etc. ist ...

-GhostfaceChilla-

Doch das Key-Objekt weiß genau, welcher Schlüssel er ist. Das ist ja der Trick (der sich Polymorphie nennt). Ich erzeuge ja kein neues Key-Objekt, sondern suche nur das passende und gebe es zurück.

Ich habe vorrausgesetzt, dass du im Enum diese Methoden hast (hab ich vorherigem Post schon mal reingeschrieben):

// Instanz-Methode für einen Key: Passt das übergebene byte-Array (bytes) zu unserem byte-array (this.bytes)?
 public boolean equals(byte[] bytes){//Methode zum vergleichem mit einem andere byte-array
    return Arrays.equals(bytes, this.bytes); 
  }

//Statische Methode
public static Keys getKey(byte[] bytes){//Methode zum finden eines Keys bei gegebenem Byte-Array
    for(Keys key: values()){//values() liefert alle Werte des Enums als Array
      if(key.equals(bytes)){//Prüfen ob der Wert passt
        return key; // Enum-Wert zurückgeben
      }
    return null; // Kein Wert gefunden, NULL zurückgeben
}

Damit findest du zu jedem byte-Stream den passenden key. gibst du also 4,1 ein, so wird POWER zurückgegeben, da nur diese Enum-Konstante das gleiche Byte-Array hat.

 

[Gucky]

@TO
Ja so was meinte ich. Das wär schon schöner, als für alles eine if-Abfrage zu haben. Danach kannst du es vielleicht noch mehr differenzieren.


Wenn du pro Taste eine Klasse erstellst, könntest du den Binärbaum noch auf die Spitze treiben und jede Taste durch ein Blatt des Binärbaumes repräsentieren lassen. Allerdings bräuchtest du dazu vermutlich eine eigene Klasse Tastenbaum, da du bei den Binärbäumen aus der API meines Wissens nach Keinen Ast mit einem Key, bestehend aus mehreren "Unterkeys" erstellen kannst. Das ist allerdings ein eher kleiner Aufwand.

Außerdem kannst du dann eine abstrakte Oberklasse Taste erstellen, die die Methode tasteVerhalten() o.Ä. bereitstellt, die aufgerufen wird. Dank des Polymorphismus wird immer die richtige Methode aufgerufen und du musst nicht wissen, welche Taste gedrückt wurde.

 

[GhostfaceChilla]

Vielen Dank euch zwei
Ok, ich glaube ich werde es so umsetzen wie Natac es beschrieb, scheint für mich die einfachste Lösung zu sein. Jedoch hätte ich noch eine Frage:
Da ich nicht viel mit Enums arbeite wollte ich Fragen, wo den jetzt der Unterschied zwischen Key als Enum und Key als Klasse ist?

 

[Natac]

Bei enum bist du explizit auf die vorhanden Instanzen begrenzt. Von einer Klasse kannst du soviele Instanzen anlegen wie du willst.

Wenn du allerdings bei den Klassen Ordnung walten lässt (bspw. protected oder default-Konstruktor), dann dürfte ich Klassen-Variante um einiges schöner werden.

 

[GhostfaceChilla]

Ok, alles klar, dnake.
Jedoch iat mir aufgefallen das ich in einem Enum leider keine byte[] benutzen kann. Also wenn ich z.B folgendes anlege:

public enum Keys {

    //Bytecode für die verschiedenen Tasten
    POWER (4,1),
    //....
    
   private byte[] bytes;
              
    private Keys(byte... bytes){
        this.bytes = bytes;
    }

}

Dann weist der Compiler mich dauarf hin, das von (int,int) nicht nach byte[] konvertiert werden kann.Und dann jede Zahl zu casten erscheint mir übertrieben. Deswegen dneke ich, wäre eine normale Klasse besser.

-GhostfaceChilla-

 

[Natac]

Das varargs-Argument hat ja nichts mit dem enum zu tun. Den Konstruktor für die Klasse würde ich genauso schreiben.

Um dir Schreibaufwand zu ersparen würde ich dann den Konstruktor auf

int...

umstellen und im Konstruktor ein byte-array draus machen:

public Key(int... bytes){
  byte[] temp = new byte[bytes.length];
  for(int i = 0; i < bytes.length; i++){
    temp[i] = (byte) bytes[i];
  }
  this.bytes = temp;
}

Den Code schreibst du einmal und kannst danach in allen Konstruktoren bequem Zahlen benutzen, statt Dinge wie

new byte[]{4, 1}

oder

(byte)4, (byte)1

oder so schreiben zu müssen.

Wenn du eine falsche Zahl eingibst, fliegt dann eben eine ClassCastException. Wenn dir das zu schwammig ist kannst du die ja auch noch in eine vielsagendere Exception umwandeln.

 

[GhostfaceChilla]

Danke , darauf hätte ich auch selbst kommen können
Hätte nur noch eine Frage:
Und zwar ich habe die keys vorher von meiner Fernbedienung ausgelesen und habe die Daten in einem byte[] gespeichert. Jetzt habe ich ja Werte wie "03" und "09" drin. D.h der Compiler wird diese ja als Oktalwerte ansehen. Jetzt weis ich nicht, wie die 09 vorher beim auslesen zustande kam. Sie müsste ja ein byte representieren. Wie handle ich das? Der Code würde ja so oder so wegen der "09" nicht funktionieren. Aber muss mich sowieso erstmal in enum ein bisschen reinlesen, allein schon wie man das hinbekommt das man "Unterklassen" des Enums aufbauen kann. Also das z.B. Power, Music, etc. als Keys Objekt angesehen wird. Bzw., ich glaube das wäre kein guter Stil.

-GhostfaceChilla-

 

[GhostfaceChilla]

So, habe jetzt mal die Enum Klasse umgewandelt um die Klassenhierarchie zu verwirklichen:

public enum Keys {

    //Bytecode für die verschiedenen Tasten
    POWER(new Power(), new byte[]{4,1});
    //Direkt Zugriff aus Musi,Spiele,Gallerie und Videos
    /*
    MUSIC(2, 5, 0, 4, 0, 0, 0, 0, 2, 5, 0, 30, 0, 0, 0, 0),
    GAME(2, 5, 0, 5, 0, 0, 0, 0, 2, 5, 0, 31, 0, 0, 0, 0),
    GALLERY(2, 5, 0, 6, 0, 0, 0, 0, 2, 5, 0, 32, 0, 0, 0, 0),
    VIDEO(2, 5, 0, 7, 0, 0, 0, 0, 2, 5, 0, 33, 0, 0, 0, 0),
    //Steurung für Film und Musik
    BEFORE(3, -74, 0x09),
    BEFORE2(2, 0, 0, 0, 0, 0, 0, 0, 03, -74, 0),
    NEXT(3, -75, 0),
    NEXT2(2, 0, 0, 0, 0, 0, 0, 0, 03, -75, 0),
    BACKWARD(3, -53, 0),
    BACKWARD2(2, 0, 0, 0, 0, 0, 0, 0, 03, -53, 0),
    FORWARD(3, -54, 0),
    FORWARD2(2, 0, 0, 0, 0, 0, 0, 0, 03, -54, 0),
    PLAY(3, -51),
    PLAY2(2, 0, 0, 0, 0, 0, 0, 0, 03, -51, 0),
    STOP(3, -73, 0),
    STOP2(2, 0, 0, 0, 0, 0, 0, 0, 03, -73, 0),
    //Nummernfeld und Navigation durch das Menü
    NUMBER_ONE(2, 0, 0, 43, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    UP(2, 0, 0, 82, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    NUMBER_THREE(2, -128, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    LEFT(2, 0, 0, 80, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    ENTER(2, 0, 0, 40, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    RIGHT(2, 0, 0, 79, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    NUMBER_SEVEN(2, 1, 0, 18, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    DOWN(2, 0, 0, 81, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    ESCAPE(2, 0, 0, 41, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0),
    ZERO(2, 0, 0, 0, 0, 0, 0, 0, 2, 4, 0, 43, 0, 0, 0, 0),
    //Lautstärkeregelung
    VOL_UP(3, -23, 0),
    VOL_DOWN(3, -22, 0),
    MUTE(3, -30, 0);
 */
    
    private byte bytes[];// Repräsentiert den Key
    private Key k;
    
    private Keys(Key key, byte...  bytes){
        this.bytes = bytes;
        this.k = key;
    }
    
    public static Key getKey(byte[] bytes){
    for(Keys key: values()){
      if(Arrays.equals(key.getBytes(), bytes)){
        return key.k;
      } 
    }
        return null;
    }
    
    public byte[] getBytes(){
        return this.bytes;
    }
    
    public Key getKey(){
        return this.k;
    }
}

Die Enum Klasse Keys, hier habe ich es so geregelt, das mir bei der getKey Methode eine Unterklasse der Abstrakten Klasse Key liefert.Ich hoffe das das so ok ist.

@Override
    public void dataEventOccurred(UsbPipeDataEvent upde) {
        Key k = Keys.getKey(upde.getData());
        System.out.println(k); //Nur zum Test, hier könnte man dann k.call() machen um die Aktion aufzurufen
        
    }

Und diese Aktion reicht um die Tasten Aktion auszuführen.

Also funktioniert einwandfrei, habe zu Testzwecken jeder Key Klasse einen Namen als Attribut mitgegeben.

-GhostfaceChilla-

 

[Natac]

Ja, sieht doch schon gut aus. Ein paar Sachen würde ich noch ändern:

Alle Instanzen der Klasse "Key" sollten alle Daten und das Verhalten ihres Keys beeinhalten, damit du pro Key nur eine Klasse hast. Im Moment hast du die Byte-Folge noch im enum, das Verhalten aber in der Klasse. Das würde ich zusammenlegen:

public abstract class Key {
  private byte[] bytes;

  protected Key(int...bytes){//int... als argumente für übersichtlichen Code
    byte[] temp = new byte[bytes.length];
    for(int i =0; i<bytes.length;i++) temp[i] = bytes[i];
    this.bytes = temp;
  }

  public byte[] getBytes(){return bytes;} //Evtl. Kopie anlegen, da byte-array von außen manipuliert werden könnte?

  public void abstract call();
}

public class Power extends Key{
  
  public Power(){
    super(4,1); // Power kennt sein byte-array
  }

  //...

Im enum sieht das dann so aus:

public enum Keys{
  POWER(new Power()),

  private Key key;

  private(Key key){
    this.key = key;
  }

  public Key getKey(){return key;}

  public byte[] getBytes(){return key.getBytes();}

Somit hast du alles Key-Spezifische in der jeweiligen Klasse und das Enum verwaltet die Instanzen für dich.

Kleine Falle ist noch drinn:

public static Key getKey(byte[] bytes){
    for(Keys key: values()){
      if(Arrays.equals(key.getBytes(), bytes)){
        return key.k;
      }
    }
        return null; //NPE!

Ich würde dir empfehlen einen Key "Noop" anzulegen, der in seiner "call()"-methode nichts macht (eben no-operation). Diesen gibts du dann statt "null" zurück (Dieses Vorgehen nennt sich NullObject-Pattern).
Die Alternative ist, dass du immer auf "null" prüfen musst, wenn du einen Key ermittelst. Was den Code in meinen Augen aufbläst. Daher würde ich einfach einen "leeren" Key zurückgeben, der einfach nichts macht. Der Code sähe dann so aus:

public static Key getKey(byte[] bytes){
    for(Keys key: values()){
      if(Arrays.equals(key.getBytes(), bytes)){
        return key.k;
      }
    }
        return NOOP; // Key, der nichts tut.

 

[GhostfaceChilla]

Vielen dank
Jetzt habe ich nur noch das Problem, das die "03" laut meinem Compiler ein zu großer Wert ist. Ich weis aber nicht wie das jetzt ändern kann. Ich habe ja mit einem Testprogramm die Keys ausgelsen und da wurde das byte als "03" dargestellt. Wie kann ich das handeln??ich kann ja nicht aus 03 3 machen...

-GhostfaceChilla-

 

[Natac]

Zeig mal bitte die Codezeilen, wo das auftritt. Gerade 03 passt eigentlich in jeden Datentyp (sollte es zumindest :autsch: )

 

[Androbin]

Runtime.getRuntime().exec( cmdtext );

Gut zu wissen :hihi:

 

[GhostfaceChilla]

Huh, der Fehler ist weg ???:L
Ok, naja vielleicht hatte ich an anderer Stelle im Code nen Fehler. Egal es klappt alless Vielen Dank für die viele Hilfe, der Code sieht um einiges besser aus als vorher und lässt sich auch leicchter bearbeiten.
Vielen dank.

-GhostfaceChilla-

 

[Androbin]

Hier noch ein Tipp 8
[TIPP]Klicke auf "Thema als "erledigt" markieren"[/TIPP]

 

[GhostfaceChilla]

So, habe jetzt mal weiter programmiert und es hat sich mir noch eine Frage erschlossen.
Folgendes Szenario:
Man drückt die "rechts" Taste auf der Fernbedienung, nun wir die Taste erkannt die jeweilige Klasse dazu aufgerufen und nun muss die Aktion kommen, das nächste, rechte Element der View zu fokusieren.
Das Problem:
Ich muss erst einmal alle Elemente der aktuellen View in eine ObservableList speichern, dann das aktuell fokusierte erfragen und dann, wenn möglich das nächste Element fokusieren. Das Problem hierbei, da ein Model weder seine View noch seinen Controller kennen sollte, kann ich ja nicht das aktuelle Controller Objekt nach der Liste der vorhandenen Viewelemente fragen. Oder könnte ich das doch machen,zählt eein Key Objekt überhaupt als Model im Sinne von MVC?Also rein vom Programmierstil her, möglich wäre es ja. Oder würde man eher hingehen und den Controller die "rechtsklick" Aktion durchführen lassen?Aber dann müsste ich ja auch auf den Controller vom Model her zugreifen. Vielleicht gibts ja auch noch ne andere Lösung die ich gar nicht beachtet habe
Vielen dank schonmal für eure Hilfe.

-GhostfaceChilla-