# Designproblem mit innere Klassen und Vererbung



## Arif (23. Apr 2017)

Hallo, ich wollte ein Spiel programmieren, aber ich weiß nicht welches Design besser geeignet ist.
In dem Spiel gibt es Figuren, die von einem Spieler oder vom Computer gesteuert werden können. Und ich habe dafür 2 Varianten:



> 1.




```
public class Figur {
    MoveAble moveModul;
    AttackAble attackModul;
   
    public Figur(boolean isPlayer) {
        if (isPlayer) {
            Player player = new Player();
            setModule(player, player);
        } else {
            Bot bot = new Bot();
            setModule(bot, bot);
        }
    }
   
    private void setModule(MoveAble m, AttackAble a) {
        moveModul = m;
        attackModul = a;
    }         
                           
    public void update() {
        moveModul.move();
        attackModul.attack();                               
    }

    private class Player implements MoveAble, AttackAble, MouseListener, MouseMotionListener, KeyListener {

        @Override
        public void attack() {
            //Player-Verhalten
        }

        @Override
        public void move() {
            //Player-Verhalten
        }

        @Override
        public void keyTyped(KeyEvent e) {
            //..
        }

        @Override
        public void keyPressed(KeyEvent e) {
            //..
           
        }

        @Override
        public void keyReleased(KeyEvent e) {
            //..
           
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            //..
           
        }

        @Override
        public void mouseMoved(MouseEvent e) {
            //..
           
        }

        @Override
        public void mouseClicked(MouseEvent e) {
            //..
           
        }

        @Override
        public void mousePressed(MouseEvent e) {
            //..
           
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            //..
           
        }

        @Override
        public void mouseEntered(MouseEvent e) {
            //..
           
        }

        @Override
        public void mouseExited(MouseEvent e) {
            //..
           
        }
    }
   
    private class Bot implements MoveAble, AttackAble {
       
        @Override
        public void attack() {
            //Bot-Verhalten
        }
       
        @Override
        public void move() {
            //Bot-Verhalten
        }
    }
}
```



> 2.




```
public class Figur implements MoveAble, AttackAble {
   
    @Override
    public void move() {
        //Bot-Verhalten
    }
   
    @Override
    public void attack() {
        //Bot-Verhalten
    }
}


public class Player extends Figur implements MouseListener, MouseMotionListener, KeyListener {
   
    @Override
    public void move() {
        //Player-Verhalten
    }
   
    @Override
    public void attack() {
        //Player-Verhalten
    }
   
    //implementierende Methoden...
}
```

Ich weiß nicht ob ich innere Klassen für die Mehrfachimplementierung für Methoden verwenden soll, oder Vererbung, damit der Spieler das Verhalten des Bots erweitern und überschreiben kann.
Hoffentlich könnt ihr helfen.


----------



## Java20134 (25. Apr 2017)

Ich finde die zweite Art und Weise schöner, da diese einfach mit der Vererbung arbeitet und es übersichtlicher ist. Was du Dir aber einmal noch überlegen kannst, ist ob du die Listener wirklich alle in der Klasse Player implementieren willst? Das würde ich abhängig machen, ob du nur ein Element hast, was du immer abfragst, ansonsten würde ich es ändern. Und eine Idee hätte ich noch. Ich würde die Klasse Figure als Interface implementieren.


----------



## Arif (25. Apr 2017)

Danke für deine Antwort. Ich habe alles neu umstrukturiert und mich für Vererbung entschieden, da es übersichtlicher und leichter erweiterbar ist.


----------



## mrBrown (25. Apr 2017)

Ich würde ersteres Bevorzugen, kannst auch mal nach Entity-Component-Model suchen 

Das wird grad bei spielen häufiger benutzt, da übersichtlicher und leichter erweiterbar und anpassbar


----------



## Arif (26. Apr 2017)

Meinst du, dass ersteres nach Entity-Component-Model ähnelt?


----------



## mrBrown (26. Apr 2017)

ja, es geht etwas in die Richtung 

Außerdem:composition over inheritance


----------



## Arif (26. Apr 2017)

Wenn du Zeit und Lust hast, kannst du die Struktur des Spiels (wurde nicht von mir programmiert) ansehen.
Es verwendet das State Pattern.  Und was ist eigentlich der Unterschied zwischen ECM und State Pattern ?
Ich habe ein Beitrag über das State Pattern gefunden: https://www.philipphauer.de/study/se/design-pattern/state.php


----------

