vererbung einer "selbst-instanzierungs-klasse"

[MamboKurt]

hmm ich hab da eher eine kleine - wahrscheinlich dumme - frage:
also mein ziel ist es mehere klassen zu schreiben, die sich slebst verwalten. dazu will ich , dass sich objekte nicht von außen einsehen oder direkt verändern lassen. dies soll alles über statische methoden laufen, in denen ich genau festlegen, was zu tun ist. ich wollte in guter objekt-orientierten arbeitsweise dies über vererbung machen und zwar ähnlich wie folgt:

// Oberklasse --------------------
import java.util.vecotr;

class Oberklasse
{
   private Oberklasse(){}

   public static void create()
   {
      objectvector.add(new Oberklasse());
   }

   public static void doSomeFancyStuffWithTheObjectsInTheVector()
   {
      // hier wir was mit den Objekten gemacht, die im Vector stehen
   } 

   protected static Vector objectvector = new Vector();
}

// Unterklasse I ----------------

class UnterklasseI extends Oberklasse
{
   private UnterklasseI(){}

   public static void doSomeCrazyStuffWithTheObjectsInTheVector();
   {
      // hier wir was mit den Objekten gemacht, die im Vector stehen
   } 
}

// Unterklasse II ---------------

class UnterklasseII extends Oberklasse
{
   private UnterklasseII(){}

   public static void doSomeCoolStuffWithTheObjectsInTheVector();
   {
      // hier wir was mit den Objekten gemacht, die im Vector stehen
   } 
}

da beide Unterklassen von Oberklasse erben bekommen ja beide die methode create(). leider wird hier in den Unterklassen kein Unterklassen-onjekt erzeugt, sondern ein Oberklassen-objekt, oder sehe ich das falsch? wie bekomme ich das hin, dass in der geerbten methode ein Unterklassen-onjekt erzeugt wird?
prinzipiell hätte ich ja eine static abtract-methode geschrieben, aber das geht ja nicht.
Wenn jemand einen vorschlag hat, dann bitte her damit. ich wäre euch sehr verbunden.

.MamboKurt

[Termite]

Hi

public static void create()
   {
      objectvector.add(new Oberklasse());
   }

sacht doch alles oder? es wird immer eine oberklasse erzeugt wenn create aufgerufen wurde egal in welcher unterklasse. Auser du überschreibst die Methode in den unterklassen.

ggf kannst du was mit hilfe von Interfaces oder abstrakten klassen drehen. so das die Methode create nur als Interface existiert und in jeder ableitung implementiert werden muss. hat aber auch wieder das problem, das in den klassen, die von der klasse die das Interface implementieren abgeleitet sind, die Methode wieder existiert und wieder zu diesen problemen führen.

frag mich gerade wozu das ganze gut sein soll. Aber das kann mir ja mal egal sein.

gruss

[grenouille_unreg]

Nur so ein Tip: statische Methoden und Überschreiben funktioniert net.