Jak rozłożyć konstruktor?

Powiedzmy, że mam klasę wroga, a konstruktor wyglądałby mniej więcej tak:

public Enemy(String name, float width, float height, Vector2 position, 
             float speed, int maxHp, int attackDamage, int defense... etc.){}

Wygląda to źle, ponieważ konstruktor ma tak wiele parametrów, ale kiedy tworzę instancję wroga, muszę określić wszystkie te rzeczy. Chcę również tych atrybutów w klasie Enemy, abym mógł iterować ich listę i uzyskać / ustawić te parametry. Myślałem, że może podklasę Enemy do EnemyB, EnemyA, jednocześnie kodując ich maxHp i inne specyficzne atrybuty, ale wtedy straciłbym dostęp do ich zakodowanych atrybutów, gdybym chciał iterować listę EnemyA (składającą się z EnemyA, EnemyB i EnemyC).

Próbuję tylko nauczyć się, jak kodować w sposób czysty. Jeśli to robi różnicę, pracuję w Javie / C ++ / C #. Doceniany jest każdy punkt we właściwym kierunku.

Rozwiązaniem jest połączenie parametrów w typy kompozytowe. Szerokość i wysokość są powiązane koncepcyjnie - określają wymiary wroga i zwykle będą potrzebne razem. Można je zastąpić Dimensionstypem, a może także Rectangletypem obejmującym pozycję. Z drugiej strony, może to więcej sensu do grupy positioni speeddo MovementDatarodzaju, szczególnie jeśli przyspieszenie później wchodzi w obraz. Z kontekstu Zakładam maxHp, attackDamage, defenseitp należą również razem w Statsrodzaju. Zmieniony podpis może wyglądać mniej więcej tak:

public Enemy(String name, Dimensions dimensions, MovementData movementData, Stats stats)

Dokładne informacje o tym, gdzie narysować linie, będą zależeć od reszty kodu i od tego, jakie dane są powszechnie używane razem.

Możesz rzucić okiem na wzorzec Konstruktora . Z linku (z przykładami wzorca kontra alternatywy):

[] Wzorzec konstruktora jest dobrym wyborem przy projektowaniu klas, których konstruktory lub fabryki statyczne miałyby więcej niż garść parametrów, zwłaszcza jeśli większość z tych parametrów jest opcjonalna. Kod klienta jest znacznie łatwiejszy do odczytania i zapisania w konstruktorach niż w tradycyjnym teleskopowym konstruktorze, a konstruktory są znacznie bezpieczniejsze niż JavaBeans.

Używanie podklas do ustawiania niektórych wartości nie jest pożądane. Tylko podklasę, gdy nowy typ wroga ma inne zachowanie lub nowe atrybuty.

Wzór fabryki jest zwykle używany do abstrakcyjny nad dokładnym klasy używanego, ale może być również wykorzystane w celu zapewnienia szablonów do tworzenia obiektów:

class EnemyFactory {

    // each of these methods is essentially a template for a kind of enemy

    Enemy enemyA(String name, ...) {
        return new Enemy(name, ..., presetValue, ...);
    }

    Enemy enemyB(String name, ...) {
        return new Enemy(name, ..., otherValue, ...);
    }

    Enemy enemyC(String name, ...) {
        return new EnemySubclass(name, ..., otherValue, ...);
    }

    ...
}

EnemyFactory factory = new EnemyFactory();
Enemy a = factory.enemyA("fred", ...);
Enemy b = factory.enemyB("willy", ...);

Zarezerwowałbym podklasę dla klas reprezentujących obiekt, który możesz chcieć samodzielnie wykorzystać, np. Klasę postaci, w której wszystkie postacie, nie tylko wrogowie, mają imię, prędkość, maxHp lub klasę reprezentującą duszki, które są obecne na ekranie o szerokości, wysokość, pozycja.

Nie widzę nic z natury złego w konstruktorze z wieloma parametrami wejściowymi, ale jeśli chcesz go trochę podzielić, możesz mieć jednego konstruktora, który ustawia większość parametrów, i innego (przeciążonego) konstruktora, którego można użyć aby ustawić określone, a inne ustawić na wartości domyślne.

W zależności od wybranego języka niektórzy mogą ustawić wartości domyślne parametrów wejściowych konstruktora, takie jak:

Enemy(float height = 42, float width = 42);

Przykład kodu, który należy dodać do odpowiedzi Rory Hunter (w Javie):

public class Enemy{
   private String name;
   private float width;
   ...

   public static class Builder{
       private Enemy instance;

       public Builder(){
           this.instance = new Enemy();
       }


       public Builder withName(String name){
           instance.name = name;
           return this;
       }

       ...

       public Enemy build(){
           return instance;
       }
   }
}

Teraz możesz tworzyć nowe instancje wroga w następujący sposób:

Enemy myEnemy = new Enemy.Builder().withName("John").withX(x).build();