Основы дженериков
泛型类
Сначала мы определяем простой класс Container:
public class Container {
private String object;
public void set(String object) { this.object = object; }
public String get() { return object; }
}
Это наиболее распространенная практика. Одним из недостатков этого является то, что в контейнер можно загружать только элементы типа String. В будущем, если нам потребуется загрузить другие типы элементов, такие как Integer, мы должны переписать другой контейнер. Чтобы повторно использовать , использование дженериков может очень хорошо решить эту проблему.
public class Container<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
Чтобы наш класс Container можно было использовать повторно, мы можем заменить T любым типом, который захотим:
Container<Integer> integerContainer = new Container<Integer>();
Container<Double> doubleContainer = new Container<Double>();
Container<String> stringContainer = newContainer<String>();
泛型方法
После прочтения универсальных классов давайте взглянем на универсальные методы. Объявление универсального метода так же просто, как добавление префикса возвращаемого типа в виде
public class Util {
public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
return p1.getKey().equals(p2.getKey()) &&
p1.getValue().equals(p2.getValue());
}
}
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public void setKey(K key) { this.key = key; }
public void setValue(V value) { this.value = value; }
public K getKey() { return key; }
public V getValue() { return value; }
}
Мы можем вызывать универсальные методы следующим образом:
Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);
Или после Java 1.7 вы можете использовать вывод типа, чтобы позволить Java автоматически выводить соответствующие параметры типа:
Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);
泛型接口
Определение и использование универсального интерфейса и универсального класса в основном одинаковы. Общие интерфейсы часто используются в производителях различных классов, см. пример:
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
Когда класс, реализующий универсальный интерфейс, не передает общие аргументы:
/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator<T> implements Generator<T>{
@Override
public T next() {
return null;
}
}
Когда класс, реализующий универсальный интерфейс, передает общие аргументы:
/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
граничный символ
Теперь мы хотим реализовать такую функцию, чтобы найти количество элементов, превышающее определенный элемент в универсальном массиве, мы можем сделать это следующим образом:
public static <T> int countGreaterThan(T[] anArray, T elem) {
int count = 0;
for (T e : anArray)
if (e > elem) // compiler error
++count;
return count;
}
Но это заведомо неправильно, потому что кроме примитивных типов типа short, int, double, long, float, byte, char другие классы могут не использовать оператор >, поэтому компилятор сообщает об ошибке, так как же решить эту проблему? ? Ответ заключается в использовании граничных символов.
public interface Comparable<T> {
public int compareTo(T o);
}
Создание объявления, подобного приведенному ниже, эквивалентно указанию компилятору, что параметр типа T представляет все классы, реализующие интерфейс Comparable, что эквивалентно указанию компилятору на то, что все они реализуют по крайней мере метод compareTo.
public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
int count = 0;
for (T e : anArray)
if (e.compareTo(elem) > 0)
++count;
return count;
}
подстановочный знак
Прежде чем понять подстановочные знаки, мы должны сначала прояснить концепцию или позаимствовать класс Container, который мы определили выше, предполагая, что мы добавим такой метод:
public void boxTest(Container<Number> n) { /* ... */ }
Итак, теперь Контейнер Какие типы параметров разрешено принимать? Можем ли мы пройти в контейнере или Контейнер Шерстяная ткань? Ответ — нет, хотя Integer и Double являются подклассами Number, но в общем Container или Контейнер с контейнером Между ними нет никаких отношений. Это очень важно, и давайте углубим наше понимание на полном примере.
Во-первых, давайте определим несколько простых классов, которые мы будем использовать ниже:
class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
В следующем примере создается универсальный класс Reader, а затем в f1(), когда мы пытаемся Fruit f = fruitReader.readExact(apples); компилятор сообщит об ошибке, потому что List со списком Между ними нет никаких отношений.
public class GenericReading {
static List<Apple> apples = Arrays.asList(new Apple());
static List<Fruit> fruit = Arrays.asList(new Fruit());
static class Reader<T> {
T readExact(List<T> list) {
return list.get(0);
}
}
static void f1() {
Reader<Fruit> fruitReader = new Reader<Fruit>();
// Errors: List<Fruit> cannot be applied to List<Apple>.
// Fruit f = fruitReader.readExact(apples);
}
public static void main(String[] args) {
f1();
}
}
Но согласно нашим привычным привычкам мышления должна быть связь между Apple и Fruit, но компилятор не может ее распознать, так как же решить эту проблему в универсальном коде? Мы можем исправить это, используя подстановочные знаки:
static class CovariantReader<T> {
T readCovariant(List<? extends T> list) {
return list.get(0);
}
}
static void f2() {
CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
Fruit f = fruitReader.readCovariant(fruit);
Fruit a = fruitReader.readCovariant(apples);
}
public static void main(String[] args) {
f2();
}
Это эквивалентно указанию компилятору, что параметры, принимаемые методом readCovariant класса fruitReader, имеют длину, равную длине подклассов, удовлетворяющих Fruit (включая сам Fruit), так что отношения между подклассом и родительским классом также связаны.
принципы PECS
Выше мы видели использование, похожее на , с помощью которого мы можем получить элементы из списка, поэтому можем ли мы добавлять элементы в список? Давайте попробуем:
public class GenericsAndCovariance {
public static void main(String[] args) {
// Wildcards allow covariance:
List<? extends Fruit> flist = new ArrayList<Apple>();
// Compile Error: can't add any type of object:
// flist.add(new Apple())
// flist.add(new Orange())
// flist.add(new Fruit())
// flist.add(new Object())
flist.add(null); // Legal but uninteresting
// We Know that it returns at least Fruit:
Fruit f = flist.get(0);
}
}
Ответ - нет, компилятор не позволяет нам это сделать, почему? Для этой проблемы мы могли бы также рассмотреть ее с точки зрения компилятора. Поскольку список List сам по себе может иметь несколько значений:
List<? extends Fruit> flist = new ArrayList<Fruit>();
List<? extends Fruit> flist = new ArrayList<Apple>();
List<? extends Fruit> flist = new ArrayList<Orange>();
Когда мы пытаемся добавить Apple, flist может указывать на новый ArrayList.
();
Когда мы пытаемся добавить Orange, flist может указывать на новый ArrayList.
();
Когда мы пытаемся добавить Fruit, этот Fruit может быть любым типом Fruit, а flist может хотеть только определенный тип Fruit, компилятор не может его распознать, поэтому он сообщит об ошибке.
Следовательно, для класса коллекции, который реализует , он может рассматриваться только как источник, который предоставляет (получает) элементы извне, и не может использоваться как потребитель для получения (добавления) элементов извне.
Что, если мы хотим добавить элементы? Вы можете использовать :
public class GenericWriting {
static List<Apple> apples = new ArrayList<Apple>();
static List<Fruit> fruit = new ArrayList<Fruit>();
static <T> void writeExact(List<T> list, T item) {
list.add(item);
}
static void f1() {
writeExact(apples, new Apple());
writeExact(fruit, new Apple());
}
static <T> void writeWithWildcard(List<? super T> list, T item) {
list.add(item)
}
static void f2() {
writeWithWildcard(apples, new Apple());
writeWithWildcard(fruit, new Apple());
}
public static void main(String[] args) {
f1();
f2();
}
}
Таким образом мы можем добавлять элементы в контейнер, но недостаток использования super в том, что мы не можем в дальнейшем получить элементы в контейнере.Причина очень проста.Продолжим рассматривать эту проблему с позиции компилятора , Для списка List это может иметь следующие значения:
List<? super Apple> list = new ArrayList<Apple>();
List<? super Apple> list = new ArrayList<Fruit>();
List<? super Apple> list = new ArrayList<Object>();
Когда мы пытаемся получить яблоко через список, мы можем получить фрукт, который может быть апельсином и другими типами фруктов.
В соответствии с приведенным выше примером мы можем заключить правило «Производитель расширяется, потребитель супер»:
«Producer Extends» — если вам нужен доступный только для чтения список, из которого можно создать T, используйте .
«Consumer Super» — если вам нужен список только для записи для потребления T, используйте .
Если нам нужно читать и писать одновременно, мы не можем использовать подстановочные знаки.
hack
Если вы прочитаете исходный код некоторых классов коллекций Java, вы обнаружите, что они иногда используются вместе, например:
public class Collections {
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i=0; i<src.size(); i++)
dest.set(i, src.get(i));
}
}
Так что иногда вы все еще хотите нарушить рутину и хотите писать и читать одновременно, вы можете использовать описанный выше метод:
例子
public class PECSTest {
private List<? extends Father> glist = new ArrayList<>();
public static void main(String[] args) {
PECSTest pecsTest = new PECSTest();
pecsTest.test();
}
private void test() {
List<Father> list = new ArrayList<>();
Collections.copy(list, this.glist);
list.add(new Father("father")); // 添加父类
list.add(new Child(23)); // 添加一个子类
glist = new ArrayList<>(list);
System.out.println(glist); // 打印
}
class Father {
public String name;
public Father(String name) {
this.name = name;
}
@Override
public String toString() {
return "Father{" +
"name='" + name + '\'' +
'}';
}
}
class Child extends Father {
public int age;
public Child(int age) {
super("child");
this.age = age;
}
@Override
public String toString() {
return "Child{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
}
输出
[Father{name='father'}, Child{name='child', age=23}]