Generics

[eliot]

Hallo,

ich habe ein kleines Problem, welches ich gerne mit Generics lösen würde,
mir fehlt aber momentan der richtige Ansatz.

Folgende Situation liegt vor (Java Speudo Code):

public abstract class FirstClass<T>{
   
   public T getSomeObject(){
   ...
   }
}

public class SecondClass extends SecondClass<SomeObject>{
  ....
}

Ich habe eine Basisklasse (hier FirstClass) welche von mehreren weiteren
Klassen erweitert wird. Die Methode getSomeObject liefert ein Objekt
vom Typ der erweiterten Klasse zurück.
Dies funktioniert soweit (mit Hilfe von Reflections).

Nun würde ich gerne folgende Erweiterung vornehmen:

Jede Klasse, die FirstClass erweitert, soll eine Methode implementieren,
die eine Default Instance der der erweiterten Klasse zurück gibt, also ein Singleton.
z.B.:

public class SecondClass extends SecondClass<SomeObject>{
   private static SecondClass<SomeObject> singleton=null;
  ....
  public static  synchronized final SecondCalss<SomeObject> getDefaultInstance(){
    if(singleton==null){
      singleton = new SecondClass<SomeObject>();
    }
    return singleton;
  }
}

Wie kann ich in FirstClass sicherstellen, dass alle erweiterten Klassen
die Methode getDefaultInstance implementieren und den richtigen Typ zurückgeben?

regards
eliot

 

[Marco13]

public abstract class FirstClass<T>{

   abstract T getDefaultThing();
   
}

!?

 

[SlaterB]

für static kann man keine Vererbung vorgeben, siehe auch
http://www.java-forum.org/java-basi...singelton-fabriken-wohin-mit-getinstance.html

 

[eliot]

Hallo,

hier mal meine Lösung:

public class Test {    
    
}

public class GenericClass<T> {

    @SuppressWarnings("unchecked")
    private static Map<Class, Object> defaults = new HashMap<Class, Object>();

    @SuppressWarnings("unchecked")
    protected static synchronized <F> F getObject(Class<F> clazz) {
        try {
            F f = (F) defaults.get(clazz);
            if (f == null) {
                f = clazz.newInstance();
                defaults.put(clazz, f);
                System.out.println("new instance");
            }
            return f;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static <F> F getInstance() throws Exception {
        throw new NotImplementedException();
    }

    public static <F> F getInstance() throws Exception {
        throw new NotImplementedException();
    }
}

public class TestFacade extends GenericClass<Test> {

    @SuppressWarnings("unchecked")
    public static TestFacade getInstance() {
        return getObject(TestFacade.class);
    }

    public static void main(String[] args) {
        TestFacade o = null;
        o = TestFacade.getInstance();
        System.out.println(o.toString());
    }
}

Wenn ich getInstance in einer erweiterten Klasse nicht implementieren,
muss ich die Exception abfangen! Dies ist mein Hinweis auf eine fehlende Implementierung.

Hab ihr noch bessere Vorschläge?


EDIT: Jetzt mit Map
regards
eliot