Objekt einer Klasse in sich selbst

Question

Hey ich denke, wenn ich Instanz einer Klasse mit in sich selbst machen könnte...

Mein Problem ist, dass ich 3D-Sphären für Planeten und ihre Monde erstelle, deren Daten ich in Object behalte. Ich übergebe Parameter an den Konstruktor meiner Planetenklasse für "Size" "Orbital Radius" "Texture" "Revolution Speed" etcetra. Ich muss eine weitere Klasse für die Monde der Planeten erstellen, die ein exaktes Duplikat der Mondklasse ist.

Ich dachte, wenn ich die Klasse Objekt in sich selbst machen könnte. Übergeben Sie einen Parameter für die Liste \array von Objekten von sich selbst zu erstellen und wie für die Erde werde ich "1" übergeben, um einen Mond zu erstellen und da der Mond den gleichen Konstruktor haben wird, werde ich "0" für keine Monde des Mondes übergeben. zu erstellen.

Etwa so

class Planet
{
    Model     u_sphere;
    Texture2D u_texture;
    //Other data members

    List<Planet> Moons = new List<Planet>(); 

    Planet()
    {
    //Default Constructor
    }

    //Overloaded\Custom Constructor
    Planet(Model m, Texture2D t, int moon_count)
    {
       u_sphere  = m;
       u_texture = t;

       while(moon_count > 0)
       {
           Model     moon_sphere = LoadMesh("moon.x");
           Texture2D u_texture   = LoadTexture("moon.bmp"); 
           Planet    temp        = new Planet(moon_sphere,moon_texture,0);
           Moons.Add(temp);
           moon_count--;
       }
    }
    //Others Getters & Setters
}

• Ist das irgendwie möglich?

• oder Was ist die beste Praxis \approach für diese Art von Problem?

p.s Ich verwende C# und Microsoft X.N.A Framework

Answer 1

Ja, warum nicht? Aber vielleicht möchten Sie eine Basisklasse des Typs CelestialBody von denen sowohl Ihr Planet y Moon Klassen wird es geben. Und Sie müssen keine Prüfung bestehen Planet 's Moon s in den Konstruktor aufzunehmen, aber Sie können einfach Planet sehen so aus:

public class Moon : CelestialBody
{
    //Moon-only properties here.
}

public class Planet : CelestialBody
{
    //Planet-only properties here.
    public List<Moon> Moons { get; set; }
}

Und dann hinzufügen Moon s so:

myPlanet.Moons.Add(new Moon(...));

Z.B. abstrahiert man einen Teil der Informationen, da ein Moon ist kein Planet .

Answer 2

Ein objektorientierterer Ansatz könnte darin bestehen, jeden mondspezifischen Code in eine eigene Klasse aufzuteilen. Das könnte helfen, den Code besser zu organisieren, wenn er größer wird. Ich weiß, ein Mond ist nicht wirklich ein Planet, aber wen interessiert das schon?

Der Nachteil ist jedoch, dass Sie jetzt Ihre Vererbungsmöglichkeiten einschränken, so dass es sich um eine Designentscheidung handelt, über die Sie nachdenken müssen.

class Planet 
{     
    Model     u_sphere;
    Texture2D u_texture;
    List<Planet> Moons = new List<Planet>();

    Planet(){}

    Planet(Model m, Texture2D t, int moon_count)     
    {
        u_sphere  = m;
        u_texture = t;

        while(moon_count > 0)        
        {
            Planet    temp        = new Moon();
            Moons.Add(temp);
            moon_count--;
        }     
    }
} 

class Moon : Planet
{   
    Moon()
    {
        u_sphere  = LoadMesh("moon.x");
        u_texture = LoadTexture("moon.bmp");
    }
}

Answer 3

Sicher. Sie verwenden die Klasse einfach wieder. Denken Sie daran, dass einige Eigenschaften der Klasse möglicherweise nicht mehr gelten (es gibt keine Monde von Monden, nicht wahr?)

Vielleicht möchten Sie einen Konstruktor hinzufügen, der einen booleschen Wert, isChild, übergibt. Auf diese Weise kann das verschachtelte Kind wissen, dass es tatsächlich ein Kind ist.

Answer 4

Was Sie bereits haben, scheint ziemlich genau zu sein. Eine mögliche Verbesserung wäre, eine neue Klasse namens Moon und vererbt es von Planet . Auf diese Weise könnten Sie zusätzliche Eigenschaften/Funktionalitäten für Moon wie das Speichern eines Verweises auf den Eigentümer Planet .

Answer 5

Natürlich ist dies ein gültiger Code.

Diese Art von Design könnte jedoch aus anderen Gründen fragwürdig sein. Warum sollte eine Planetenklasse wissen, wie man andere Planeteninstanzen erstellt usw. Es ist viel klarer, wenn die Logik, die Planeten zu erstellen sind außerhalb der Klasse imo.