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

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

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

}

Быстрый тест с использованием следующего показывает, что для классов, реализующих Comparable (таких как 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");

Если бы вы могли параметризовать переменные / методы экземпляра без параметризации класса, вышеуказанная вещь (ЭТО НЕ РЕАЛЬНОСТЬ!) Не сработала бы. .

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

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

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

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:

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

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

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

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

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

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