Универсальная переменная экземпляра в не-универсальном классе

в этом есть много непроверенных предупреждений, но в принципе нет необходимости держать List как что угодно, кроме того, что содержит вещи, которые вы знаете,Comparable. Вы применяете правила, которые вам нужны в конструкторе, и все остальное должно быть в порядке. Как насчет чего-то вроде этого:

public class MyClass {

    final private List<Comparable> values;

    public <T extends Comparable<? super T>>MyClass(T... values){
        this.values = new ArrayList<Comparable>();
        for(T item : values) {
            this.values.add(item);
        }
    }

    public <T extends Comparable<? super T>> List<T> getSortedLst() {
        Collections.sort(this.values);
        return (List<T>)this.values;
    }

}

быстрый тест с использованием следующего показывает, что для классов, реализующих сопоставимые (например, Integer и String) MyClass ведет себя, как ожидалось, но кину подборку ошибка для классов, которые не реализуют Comparable:

    class Junk { }

    public static void main(String[] args){
        MyClass s = new MyClass(1,2,3);
        System.out.println(s.getSortedLst());

        MyClass a = new MyClass("c", "a", "b");
        System.out.println(a.getSortedLst());

        MyClass c = new MyClass(new Junk());
    }

рассмотрим это так (то, что я собираюсь сказать, не является реальностью. но это иллюстрирует, почему вам нужно делать то, что вам нужно делать):

class Foo<T>
{
    private T value;

    T getValue() { return value; }
    void setValue(T val) {value = val; }
}

// some code that uses the above class

Foo<Integer> iFoo = new Foo<Integer>();
Foo<String> sFoo = new Foo<String>();
iFoo.setValue(5);
sFoo.setValue("Hello");

когда это происходит, компилятор (на самом деле не делает то, что я собираюсь сказать!) генерирует следующий код:

class IntegerFoo
{
    private Integer value;

    Integer getValue() { return value; }
    void setValue(Integer val) {value = val; }
}

class StringFoo
{
    private String value;

    String getValue() { return value; }
    void setValue(String val) {value = val; }
}

// some code that uses the above class

IntegerFoo iFoo = new IntegerFoo();
StringFoo< sFoo = new StringFoo();
iFoo.setValue(5);
sFoo.setValue("Hello");

Если бы вы могли параметризовать переменные/методы экземпляра без параметризации класса, вышеуказанная вещь (которая не является реальностью! не сработает.

что вы пытаетесь сделать должны быть возможным со статическими методами, но я не думаю, что это то, что вы хотите.

вы можете объяснить, почему вы хотите сделать код, который вы пытаетесь сделать? Возможно, мы сможем найти лучший способ сделать то, что вы хотите сделать, что работает в языке.

Я считаю, что следующее достигнет того, что вы хотите (более сильный тип сопоставимого). Это предотвратит добавление сопоставимых объектов, которые не входят в ваш интерфейс, в список и позволит использовать несколько реализаций.

public class test<T extends ComparableType> {


final List<T> values = new ArrayList<T>();
  public test (T... values) {
      for(T item : values) {
          this.values.add(item);
      }
  }

  public List<T> getSortedLst() {
      Collections.sort(this.values);
      return Collections.unmodifiableList(this.values);
  }
}

public interface ComparableType extends Comparable<ComparableType> {}

public class ConcreteComparableA implements ComparableType {
  @Override
  public int compareTo(ComparableType o) {
    return 0;
  }
}

public class ConcreteComparableB implements ComparableType {
  @Override
  public int compareTo(ComparableType o) {
    return 0;
  }
}

edit:

Я знаю, что это может быть очевидно; но если вы не хотите, чтобы класс был общим, это решение также будет работать с:

 public class test {
  final List<ComparableType> values = new ArrayList<ComparableType>();

  public test (ComparableType... values) {
      for(ComparableType item : values) {
          this.values.add(item);
      }
  }

  public List<ComparableType> getSortedLst() {
      Collections.sort(this.values);
      return Collections.unmodifiableList(this.values);
  }
}

Я бы сделал это так (я сделал это как список или как массив), если вам действительно не нужна переменная экземпляра / методы:

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;


public class MyClass
{
    public static <T extends Comparable<T>> List<T> asSortedList(final T ... vals)
    {
        final List<T> temp;

        temp = new ArrayList<T>(vals.length);
        temp.addAll(Arrays.asList(vals));
        Collections.sort(temp);

        return (Collections.unmodifiableList(temp));
    }

    public static <T extends Comparable<T>> T[] asSortedArray(final Class<?> clazz,
                                                              final T ...    vals)
    {
        final T[] temp;

        temp = (T[])Array.newInstance(clazz,
                                 vals.length);
        System.arraycopy(vals,
                         0,
                         temp,
                         0,
                         vals.length);
        Arrays.sort(temp);

        return (temp);
    }

    public static void main(final String[] argv)
    {
        final List<String> list;
        final String[]     array;

        list = MyClass2.asSortedList("c", "a", "b");
        System.out.println(list);

        array = MyClass2.asSortedArray(String.class, "z", "y", "x");
        System.out.println(Arrays.deepToString(array));
    }
}

ограничение типа, которое вы хотите для переменной, не может быть выражено напрямую. вы можете ввести новый тип, чтобы устранить проблему.

static class MyList<T extends Comparable<? super T>> extends ArrayList<T>{}

final MyList<?> values;

тем не менее, нет смысла быть чрезвычайно безопасным типом в частном фрагменте кода. Generic поможет вам прояснить ваши типы, а не запутать их.

public class MyClass<T extends Comparable<? super T>> {
    // This doesn't work as T isn't defined
    final List<T> values;

    public MyClass (T... values) {
        this.values = new ArrayList<T>(Arrays.asList(values));
    }

    public List<T> getSortedLst() {
        Collections.sort(this.values);
        return this.values;
    }
}