Designproblem mit innere Klassen und Vererbung

[Arif]

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]

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]

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

 

[mrBrown]

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]

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

 

[mrBrown]

ja, es geht etwas in die Richtung

Außerdem:composition over inheritance

 

[Arif]

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