Question

我想在Java中使用多态来处理以下场景：

public class Main {

    public static void main (String[] args) {

        handle(new B());
        handle(new C());
    }

    public static void handle(A a){
        // here I want to create a F<T>, in way that:
        // * F must be C or D if A is B or C
        // * T must B the real type of A
        // e.e:
        //     new F<A>();
        // task => see the output from D or E
    }

}   

class A {

}

class B extends A {

}

class C extends A {

}

class D<B> extends F{

    public D(){
        System.out.println("Created D of B");
    }
}

class E<C> extends F{

    public E(){
        System.out.println("Created E of C");
    }

}

abstract class F<T>{

}

入口点是类handle的{{1}}方法。

该方法接收一个对象Main，该对象可以是类A或B的实例。

我的任务是找到一种方法来创建一个新的对象C，它取决于收到的F实例的实际类型，而A对象必须是{{1} }或F取决于C，如果它分别是D或A。

任何想法都将受到赞赏。

感谢。

Answer 1

@See Java类型擦除概念。 doc

您可以做的一件事是在A中引入虚拟方法：

F<? extends A> supply();

因此，在多态性的帮助下，您将实例化委托给具体类。这种方法类似于模板方法模式。

Answer 2

您可以使用a关键字检查instanceof是否是B或C的实例，这可能是您正在寻找的句柄方法实现（或多或少）：

 public static F handle(A a){

        if (a instanceof B) {
           // a is B, do something about that, possibly create some D<B> ?
           return new D();
        }

        if (a instanceof C) {
           // a is C, do something about that, possibly  create some E<C> ?
           return new E();
        }

        // if somehow you get here, that means something weird happened
        throw new RuntimeException("unsupported case");

    }

Answer 3

我已经解决了这个实现：

public class Main {

    private static D d;

    public static void main (String[] args) {
        handle(new B());
        handle(new C());
    }

    public static void handle(A a){     
        d = solveD(a);
        d.handle(a);
    }

    private static D solveD(A a){
        if (a instanceof B){
            return new E();
        } else return new F();
    }

}   

class A {

}

class B extends A {

}

class C extends A {

}

interface D<T extends A>{
    public void handle(T t);
}

class E implements D<B> {

    @Override
    public void handle(B b){
        System.out.println("Handling E of B");
    }
}

class F implements D<C>{

    @Override
    public void handle(C c){
        System.out.println("Handling F of C");
    }

}

使用Spring，方法solveD不是必需的，因为我们可以根据a.getClass().getSimpleName()获取bean，使用{注释E和F {1}}。

Java：基于Generic Type创建动态Object实例

3 个答案: