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

Question

Given

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

And several classes containing static fields of type A

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

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

I would like to parameterize a class with B1 or B2 to get MIN field of type A from class B in the class C :

class C <T, P> {
   private T t = ???;
}

When C<A, B1> c = new C(); what should be placed instead ??? to get B1.MIN ? Is it possible?

EDIT: Thank you for the answers, I have upvoted both. I have arrived simply at

class C <T, P> {
   private T t;

   public C(T min) {
      this.t = min;
   }
}

This will be just C<A, B1> c = new C<A, B1>(B1.MIN); because as you can see it is hard to avoid a constructor for C taking an instance of B1 or smth like that. But in this case B1 at least not instantiated.

Answer 1

You can use an interface to achieve this behavior:

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; 
}

Then you can create: C<B1> and C<B2> and use both.

As Tom suggested in the comments below, this approach is limited to use static fields. An even better approach would be:

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

I would forget static and have a concrete instance of an interface:

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

The concrete instance could be singleton, so next best thing to a static:

public enum B implements Bounds<A> {
    INSTANCE;

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

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

C then defined like so:

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

    private T min;

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

    public T getMin() {
        return min;
    }
}

Usage:

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

Self describing

Maybe you don't want this meta data type ( B ), maybe you want types to describe themselves. So C could be defined for types that can describe their own bounds:

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

    private T min;

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

    public T getMin() {
        return min;
    }
}

Usage:

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

Where A is:

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;
    }
}