Java 如何对泛型类型使用构造函数/转换

我有一个父类，

parent

，有两个子类，

a

和

B

。我有另一个类，

Wrapper

，它包含一个接口，

函数

，它应该将A转换成B或将A转换成A

如果我定义

new Wrapper<A,B>(new Function<A,B>(){public B transform(A a){return new B(a);}});

编辑：

我的问题在范围和实施方面与建议的副本不同。例如，我的代码结构是一个简单的父类，有两个兄弟类。可能的副本中的结构更为复杂，涉及多代和子类，这些子类以令人困惑的方式杂乱无章。我不确定那段代码试图做什么，答案丝毫没有帮助我理解我自己的问题，因为它似乎是另一个问题的独特结构所特有的。

没有办法创建“通用”构造函数。当前实现的解决方案是实例化

函数中的对象。因为这是调用方的责任（在您的设计中），所以很容易：

Wrapper<A, B> wrapper = new Wrapper<A, B>((a) -> new B(a));

使用以上两种方法，您的主要方法如下所示：

public static void main(String... args) {
    Wrapper<A, B> wrapper = new Wrapper<A, B>((a) -> new B(a));

    A a = new A();
    B b = wrapper.transform(a);

    System.out.println(b.getValue());

    wrapper = new Wrapper<A, B>(A.class, B.class);
    b = wrapper.transform(a);
    System.out.println(b.getValue());
}

publicstaticvoidmain（字符串…参数）{
包装器=新包装器（（a）->新B（a））；
A=新的A（）；
B=包装器.transform（a）；
System.out.println（b.getValue（））；
包装器=新包装器（A.class，B.class）；
b=包装器转换（a）；
System.out.println（b.getValue（））；
}

并且运行时没有任何类型转换错误


上述lambda表达式的java1.7版本：

Wrapper<A, B> wrapper = new Wrapper<A, B>(new Function<A, B>() {
    @Override
    public B transform(A a) {
        return new B(a);
    }
});

Wrapper=new Wrapper（新函数（）{
@凌驾
公共B转换（A）{
返回新的B（a）；
}
});

以及：

this.function=新函数（）{
@凌驾
公共类型2转换（类型1对象1）{
试一试{
返回type2Class.getConstructor（type1Class.newInstance（object1）；
}捕获（例外e）{
抛出新的运行时异常（e）；
}
}
};
由于无法使用泛型类型参数创建实例，我们必须解决它。在阅读您正在使用的注释时，我将把答案限制为Java7。以下是我的建议：

public interface Transform<P extends Parent> {

    P with(int value);

}

public static void main(String[] args) {
    Transform<B> transformToB = new Transform<B>() {

        @Override
        public B with(int value) {
            return new B(value);
        }

    };

    A a = new A();
    B b = transformToB.with(a.getValue());
    System.out.println(b.getValue());
}

如果
A
和
B
具有不同的字段，则最后一种方法也适用。如果
B
有一个字段
String value4
，我们可以向
transformToB
添加一行额外的内容，比如
B.setValue4（a.getValue3（）+“#”+a.getValue2（））
我认为你的函数做得太多了，遵循SRP它应该做一件事，或者从A转换到B或从B转换到A，你不能使用不同的函数？@vmrvictor我可能会创建不同的函数，但是，在实际的代码中，我有很多子类。5个子类将需要5^5个函数（函数也必须反射性地采用A->A）。实际代码所做的不仅仅是转换。这只是一个简单的例子来说明这个问题。@vmrvictor我很感激你提出了一个重复的问题，但是，坦率地说，我不理解这个问题或那个答案。我认为，从其范围和实施情况来看，我的问题与这一问题完全不同。例如，我的结构是一个简单的父结构，有两个兄弟姐妹的孩子，而可能重复的结构中有一个父结构，有两代，还有更多的子类以令人困惑的方式杂乱无章。访问该链接丝毫没有帮助我理解我的问题。谢谢你的回答！我在
object1
下遇到一个错误。Eclipse告诉我为object1创建一个局部变量。我正在旧mac上使用Eclipse3.8，所以这可能是我的旧版本不知道的。我不熟悉
（）->{}
符号。你能给我解释一下吗？我刚才读了一些关于lambda函数的内容，但简而言之，它似乎是实现接口的缩写。@user2303321我假设您在使用
函数
接口时使用的是java 8或更高版本。您的eclipse是否设置为以1.8作为目标进行编译？如果目标版本较旧，则不起作用。关于lambdas你是对的。不幸的是，Eclipse3.8最多只支持Java1.7。只是lambda函数表示法不受支持，还是对象的实例化也不受支持？我可以用标准接口符号实现同样的想法吗？@user2303321哪个包是
函数
的来源？是的，您可以将这些lambda表达式转换为匿名类。它们都在同一个包中。函数只是我自己定义的类。这是正确的实现方式吗<代码>公共包装器（最终类type1Class，最终类type2Class）{this.function=new function（）{public Type2 transform（Type1 object1）{try{return type2Class.getConstructor（type1Class）.newInstance（object1）；}catch（异常e）{throw new RuntimeException（e）；}；}；}；

Wrapper<A, B> wrapper = new Wrapper<A, B>(new Function<A, B>() {
    @Override
    public B transform(A a) {
        return new B(a);
    }
});

this.function = new Function<Type1, Type2>() {

    @Override
    public Type2 transform(Type1 object1) {
        try {
            return type2Class.getConstructor(type1Class).newInstance(object1);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
};

public interface Transform<P extends Parent> {

    P with(int value);

}

public static void main(String[] args) {
    Transform<B> transformToB = new Transform<B>() {

        @Override
        public B with(int value) {
            return new B(value);
        }

    };

    A a = new A();
    B b = transformToB.with(a.getValue());
    System.out.println(b.getValue());
}

interface Transform<From extends Parent, To extends Parent> {

    To from(From f);

}

public static void main(String[] args) {
    Transform<A, B> transformToB = new Transform<A, B>() {

        @Override
        public B from(A a) {
            B b = new B();
            b.setValue(a.getValue());
            b.setValue2(a.getValue2());
            b.setValue3(a.getValue3());

            return b;
        }

    };

    A a = new A();
    B b = transformToB.from(a);

    System.out.println(b.getValue());
}