C++ typedef in Java umgehen wie? brauch hilfe

[3Cyb3r]

Hallo,

ich bin gerade ein Menü für ein Spiel zu implementieren. Ich gestaltee das ganze dynamisch, so das es auch für andere Spiele verwendbar ist. So etwas habe ich in C++ schon einmal gemacht hat super geklappt und so wollte ich mein Sourcecode nun einfach umschreiben. Das mit einfach war leider nichts, denn in Java gibt es nichts vergleichbares zu typedef (bitte keine Diskussion über den Sinn von typedef anfangen es macht bei Generics Sin!).

Mein kontretes Problem ist das ich durch typedef eine Variable Methode bekommen habe und nicht weiß wie ich dies in Java mache / umgehe.

Hier einmal mein C++ Code(alles vollständig damit man den Sinn erkennen kann^^):

namespace menu
{
class MenuEntry
{
protected:
  virtual void do_action() = 0;
  virtual std::string do_getName() const = 0;
  virtual std::string do_getDescription() const { return ""; }
public:
  void action() { do_action(); }
  std::string getName() const { return do_getName(); }
  std::string getDescription() const { return do_getDescription(); }
  virtual ~MenuEntry(){}
};

//Methode mit 0 Parametern
template<typename Class>
class MenuEntryMethod : public MenuEntry
{
public:
  typedef void (Class::*Method)();
private:
  Class* p;
  Method method;
  std::string name;
  
protected:
  void do_action()
  {
    (p->*method)();
  }
  std::string do_getName() const
  {
    return name;
  }
  
public:
  MenuEntryMethod(Class* p, Method method, std::string const& name)
  : p(p), method(method), name(name)
  {}
};

//Methode mit 2 Parametern
template<typename Class, typename Param1, typename Param2>
class MenuEntryMethodParam2 : public MenuEntry
{
public:
  typedef void (Class::*Method)(Param1, Param2);
private:
  Class* p;
  Method method;
  Param1 param1;
  Param2 param2;
  std::string name;
  
protected:
  void do_action()
  {
    (p->*method)(param1, param2);
  }
  std::string do_getName() const
  {
    return name;
  }
  
public:
  MenuEntryMethodParam2(Class* p, Method method, Param1 param1, Param2 param2,std::string const& name)
  : p(p), method(method), param1(param1), param2(param2), name(name)
  {}
};


//Vereinfach die Verwendung
template<typename Class>
MenuEntryMethod<Class>* makeMenuEntry(Class* p, void (Class::*method)(), std::string const& name)
{
  return new MenuEntryMethod<Class>(p, method, name);
}

template<typename Class, typename Param1, typename Param2>
MenuEntryMethodParam2<Class, Param1, Param2>* makeMenuEntry(Class* p, void (Class::*method)(Param1, Param2), Param1 param1, Param2 param2, std::string const& name)
{
  return new MenuEntryMethodParam2<Class, Param1, Param2>(p, method, param1, param2, name);
}

class Menu
{
protected:
  std::vector<MenuEntry*> entries;
  typedef std::vector<MenuEntry*>::iterator iterator;
  
  virtual void do_display() = 0;
  virtual void do_select() = 0;

public:
  virtual ~Menu()
  {
    std::for_each(entries.begin(), entries.end(), Delete());
  }
  
  void addEntry(MenuEntry* entry)
  {
    entries.push_back(entry);
  }
  
  void display() { do_display(); }
  void select() { do_select(); }
 
};
}

In meine Anwendung dann z.B.:

// Application heißt die Klasse in der dies ausgeführt wird

  menu::Menu* menu = new Menu();

  menu->addEntry(menu::makeMenuEntry(this, &Application::exit, "Exit"));
  menu->addEntry(menu::makeMenuEntry(this, &Application::startGame, PLAYER_HUMAN, PLAYER_AI,     "Start Game (Player    VS  Computer)"));
  menu->addEntry(menu::makeMenuEntry(this, &Application::startGame, PLAYER_AI, PLAYER_HUMAN,     "Start Game (Computer  VS  Player)"));
  menu->addEntry(menu::makeMenuEntry(this, &Application::startGame, PLAYER_HUMAN, PLAYER_HUMAN,  "Start Game (Player    VS  Player)"));
  menu->addEntry(menu::makeMenuEntry(this, &Application::startGame, PLAYER_AI, PLAYER_AI,        "Start Game (Computer  VS  Computer)"));

So hier mal mein momentaner Java Code:

public class MenuEntryMethod<T> extends MenuEntry {
	
	private T oclass;

        // geht nich da ich keine Methode als Attribut machen kann
	
	private String name;
	
	protected void do_action() {
		// geht ja nicht da das Attribut fehlt
		
	}
	
}

abstract public class MenuEntry {
	
	abstract protected void do_action();
	
	abstract protected String do_getName();
	
	protected final String do_getDescription() {
		return "";
	}
	
	public void action() {
		this.do_action();
	}
	
	public String getName() {
		return this.do_getName();
	}
	
	public String getDescription() {
		return this.do_getDescription();
	}

}

 

[deepthroat]

Hi.

Nicht wirklich eine C++ Frage. Und hat auch nicht wirklich etwas mit typedef zu tun, da typedef nur einen Alias für einen Typ vereinbart und man schließlich auch überall direkt den Typ statt des Alias hinschreiben könnte.

In Java kann man keine Zeiger auf Methoden definieren (obwohl man mit Reflection etwas ähnliches anstellen könnte).

Verwende einfach eine Klasse. It's OOP, remember? KISS!

abstract public class MenuAction {
  abstract public void do();
}

Du könntest anonyme innere Klassen verwenden um die Aktionen zu verknüpfen.

Gruß