自我描述

Question

给出

class A {
   public static A newInstance(int x) { ... }
}

包含A

类型的静态字段的几个类

class B1 {
   public static A MIN = A.newInstance(10);
}

class B2 {
   public static A MIN = A.newInstance(15);
}

我想使用B1或B2参数化一个类，以便从类{{1}中的类MIN获取A类B字段}}：

当class C <T, P> { private T t = ???; }应该放置什么C<A, B1> c = new C();才能获得???？有可能吗？

编辑：谢谢你的答案，我对两者都赞不绝口。我只是到了

B1.MIN

这只是class C <T, P> { private T t; public C(T min) { this.t = min; } }，因为您可以看到很难避免C<A, B1> c = new C<A, B1>(B1.MIN);的构造函数采用C或类似的实例。但在这种情况下B1至少没有实例化。

Answer 1

您可以使用界面来实现此行为：

class A {
    public static A newInstance() { return new A(); }
}

interface HasMin {
    public static A MIN = null;
}

class B1 implements HasMin {
    public static A MIN = A.newInstance();
}

class B2 implements HasMin {
    public static A MIN = A.newInstance();
}

class C<T extends HasMin> { 
    private A t = T.MIN; 
}

然后您可以创建：C<B1>和C<B2>并使用它们。

正如汤姆在下面的评论中所建议的那样，这种方法仅限于使用静态字段。更好的方法是：

public class Play {

    public static void main(String[] args) {
        B1 b1 = new B1();
        C<B1> c = new C<>(b1);
        System.out.println(c.getA());  // prints: A{ x=10 }

        B2 b2 = new B2();
        C<B2> c2 = new C<>(b2);
        System.out.println(c2.getA()); // prints: A{ x=20 }
    }
}

class A {
    private int x;

    public A(int x) {
        this.x = x;
    }

    @Override
    public String toString() {
        return "A{ x=" + x + " }";
    }

    public static A newInstance(int x) {
        return new A(x);
    }
}

interface GetMin {
    public A getMin();
}

class B1 implements GetMin {
    public A MIN = A.newInstance(10);

    @Override
    public A getMin() {
        return MIN;
    }
}

class B2 implements GetMin {
    public A MIN = A.newInstance(20);

    @Override
    public A getMin() {
        return MIN;
    }
}

class C<T extends GetMin> {
    private A a = null;

    public C(T t) {
        a = t.getMin();
    }

    public A getA() {
        return a;
    }
}

Answer 2

我会忘记静态并且有一个接口的具体实例：

public interface Bounds<T> {
    T min();
}

具体实例可能是单例，所以接下来最好的是静态：

public enum B implements Bounds<A> {
    INSTANCE;

    private final A min = A.newInstance(10);

    @Override
    public A min() {
        return min;
    }
}

然后

C定义如下：

public class C<T, P extends Bounds<T>> {

    private T min;

    public C(P bounds) {
        min = bounds.min();
    }

    public T getMin() {
        return min;
    }
}

用法：

C<A, B> c = new C(B.INSTANCE);

自我描述

也许您不想要这种元数据类型（B），也许您希望类型来描述自己。因此可以为可以描述自己边界的类型定义C：

public class C<T extends Bounds<T>> {

    private T min;

    public C(T anyT) {
        min = anyT.min();
    }

    public T getMin() {
        return min;
    }
}

用法：

C<A> c = new C(A.zero); //any A will do

A的位置：

public class A implements Bounds<A>{
    public final static A zero = A.newInstance(0);

    private final static A min = A.newInstance(10);

    public static A newInstance(int x) {
        return new A(x);
    }

    private int x;

    public A(int x) {
        this.x = x;
    }

    @Override
    public A min() {
        return min;
    }
}

是否可以从模板类参数中获取公共静态字段？

2 个答案:

自我描述