Философия Java3 - Брюс Эккель

Map<Person, List<? extends Pet» petPeople = new HashMap<Person, Li st<? extends Pet»():

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

//: net/mindview/uti1/New.java

// Utilities to simplify generic container creation

// by using type argument inference.

package net mindview util; import java util *.

public class New {

public static <K.V> Map<K,V> map() { return new HashMap<K.V>();

}

public static <T> List<T> list О { return new ArrayList<T>();

}

public static <T> LinkedList<T> 1 ListО { return new Li nkedLi st<T>().

}

public static <T> Set<T> setО { return new HashSet<T>();

}

public static <T> Queue<T> queueO { return new LinkedList<T>();

}

// Примеры:

public static void main(String[] args) {

Map<String, List<String>> sis = New.mapO; List<String> Is = New listO: Li nkedLi st<String> lis = New.lListO; Set<String> ss = New set(); Queue<String> qs = New.queueO;

}

} ///-

Примеры использования представлены в main() — вычисление аргументов типов устраняет необходимость в повторении списков параметров. Этот прием можно использовать в holding/MapOfList.java:

II- generics/SimplerPets.java import typeinfo.pets.*; import java util *; import net.mindview.util.*;

public class SimplerPets {

public static void main(String[] args) {

Map<Person, Li st<? extends Pet» petPeople = New map(); // Остальное без изменений...

}

} ///.-

Пример интересный, однако трудно сказать, насколько он эффективен в действительности. Человеку, читающему код, придется просмотреть дополнительную библиотеку и разобраться в ее коде. Возможно, вместо этого стоит оставить исходное (пусть и избыточное) определение — как ни парадоксально, этот вариант проще. Хотя, если в стандартную библиотеку Java будет добавлено некое подобие New.java, им можно будет пользоваться.

Вычисление типов не работает ни в каких других ситуациях, кроме присваивания. Если передать результат вызова метода (скажем, New.mapO) в аргументе другого метода, компилятор не пытается выполнить вычисление типа. Вместо этого вызов метода интерпретируется так, как если бы возвращаемое значение присваивалось переменной типа Object. Пример ошибки такого рода:

//: generics/LimitsOfInference.java import typeinfo.pets.*; import java.util.*;

public class LimitsOflnference { static void

f(Map<Person, List<? extends Pet» petPeople) {} public static void main(String[] args) {

// f(New.mapO); II He компилируется

}

} ///:-

Явное указание типа

При вызове параметризованного метода также можно явно задать тип, хотя на практике этот синтаксис используется редко. Тип указывается в угловых скобках за точкой, непосредственно перед именем метода. При вызове метода в пределах класса необходимо ставить this перед точкой, а при вызове статических методов перед точкой указывается имя класса. Проблема, продемонстрированная в LimitsOflnference.java, решается при помощи следующего синтаксиса:

//: generics/ExplicitTypeSpecification.java import typeinfo.pets.*: import java.util.*; i mport net.mi ndvi ew.uti1.*:

public class ExplicitTypeSpecification {

static void f(Map<Person, List<Pet>> petPeople) {} public static void main(String[] args) { f(New. <Person, Li st<Pet»map()):

}

} ///:-

Конечно, при этом теряются преимущества от использования класса New для уменьшения объема кода, но дополнительный синтаксис необходим только за пределами команд присваивания.

Параметризованные методы и переменные списки аргументов

Параметризованные методы нормально сосуществуют с переменными списками аргументов:

II: generics/GenericVarargs.java import java.util.*;

public class GenericVarargs {

public static <T> List<T> makeList(T... args) { List<T> result = new ArrayList<T>(); for(T item : args)

result.add(item);-return result;

public static void main(String[] args) { List<String> Is = makeListCA"); System out.println(ls); Is - makeListCA", "В". "С"); System.out.println(ls);

Is = makeListC"ABCDEFFHIJKLMNOPQRSTUVWXYZ".split("")); System.out.printi n( Is);

}

} /* Output: [A]

[А, В. C]

[, А, В. C. D, E. F, F, H, I, J. K. L, M, N, 0. P. Q, R. S. T. U. V. W. X, Y, Z] *///•-

Метод makeList() предоставляет ту же функциональность, что и метод java. util.Arrays.asList() из стандартной библиотеки.

Использование параметризованных методов с Generator

Генераторы хорошо подходят для заполнения Collection, и для выполнения этой операции было бы удобно создать параметризованный метод:

//: generics/Genetcitors.java // Обобщенный метод заполнения коллекции import generics.coffee.*; import java.util.*; import net.mindview.util.*;

public class Generators {

public static <T> Collection<T>

fill(Collection<T> coll. Generator<T> gen, int n) { for(int i =0; i < n; i++)

coll .add(gen.nextO); return coll;

}

public static void main(String[] args) { Collection<Coffee> coffee = fill(

new ArrayList<Coffee>(). new CoffeeGenerator(). 4); for(Coffee с : coffee)

System.out.printin(c); Collection<Integer> fnumbers = fill(

new ArrayList<Integer>(), new FibonacciO. 12); for(int i fnumbers)

System.out.printO + ");

}

} /* Output: Americano 0 Latte 1 Americano 2 Mocha 3

1. 1. 2. 3. 5. 8. 13. 21. 34. 55. 89. 144. *///:-

Обратите внимание на то, как параметризованный метод fill() применяется к контейнерам и генераторам как для типа Coffee, так и для Integer.

Обобщенный генератор

Следующий класс создает генератор для любого класса, обладающего конструктором по умолчанию. Для уменьшения объема кода в него также включен параметризованный метод для получения BasicGenerator:

//: net/mindview/uti1/BasicGenerator java // Автоматическое создание Generator для класса // с конструктором по умолчанию (без аргументов) package net.mindview util;

public class BasicGenerator<T> implements Generator<T> { private Class<T> type;

public BasicGenerator(Class<T> type){ this.type = type; } public T nextО { try {

// Предполагается, что type является public-классом, return type.newlnstance(); } catch(Exception e) {

throw new RuntimeException(e);

}

}

// Получение генератора по умолчанию для заданного type: public static <T> Generator<T> create(Class<T> type) { return new BasicGenerator<T>(type).

}

} ///:-

Класс предоставляет базовую реализацию, создающую объекты класса, который (1) является открытым (так как BasicGenerator определяется в отдельном пакете, соответствующий класс должен иметь уровень доступа public, не ограничиваясь пакетным доступом), и (2) обладает конструктором по умолчанию (то есть конструктором без аргументов). Чтобы создать один из таких объектов BasicGenerator, следует вызвать метод create() и передать ему обозначение генерируемого типа, параметризованный метод create() позволяет использовать запись BasicGenerator.create(MyType.class) вместо более громоздкой конструкции new BasicGenerator<MyType>(MyType.class).

Для примера рассмотрим простой класс с конструктором по умолчанию:

//: generics/CountedObject.java

public class CountedObject {

private static long counter = 0; private final long id = counter++; public long id() { return id; }

public String toStringO { return "CountedObject " + id,} } ///:-

Класс CountedObject отслеживает количество созданных экземпляров и включает его в выходные данные toString().

При помощи BasicGenerator можно легко создать Generator для CountedObject:

//: generics/BasicGeneratorDemo java i mport net.mi ndvi ew.uti1.*.

public class BasicGeneratorDemo {

public static void main(String[] args) { Generator<CountedObject> gen =

BasicGenerator create(CountedObject.class), for(int i = 0; i < 5; i++)

System, out pri ntl n(gen. nextO);

}

} /* Output CountedObject 0 CountedObject 1 CountedObject 2 CountedObject 3 CountedObject 4 */// ~

Как видите, применение параметризованного метода снижает объем кода, необходимого для получения объекта Generator. Раз уж механизм параметризации Java все равно заставляет вас передавать объект Class, его можно заодно использовать для вычисления типа в методе create().

Упрощение работы с кортежами

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

//• net/mi ndvi ew/uti1/Tuple.java // Библиотека для работы с кортежами // с использованием вычисления аргументов типов package net mindview.util,

public class Tuple {

public static <A,B> TwoTuple<A,B> tuple(A а. В b) { return new TwoTuple<A,B>(a, b).

}

public static <A,B,C> ThreeTuple<A,B,C> tuple(A а. В b. С с) {

return new ThreeTuple<A,B,C>(a, b, c):

}

public static <A,B,C.D> FourTuple<A,B,C.D> tuple(A а. В b. С с. D d) {

return new FourTuple<A,B.C.D>(a. b. c. d).

}

public static <A,B,C.D,E>

FiveTuple<A,B,C,D,E> tuple(A а. В b, С с, D d. E e) {

return new FiveTuple<A,B,C.D,E>(a, b. c. d. e);

}

} ///:-

А вот как выглядит обновленная версия TupleTest.java для тестирования Tuple.java:

//: generics/TupleTest2.java import net.mindview.util.*;

import static net.mindview.util.Tuple.*; продолжение &

public class TupleTest2 {

static TwoTuple<String,Integer> f() { return tupleChi", 47);

}

static TwoTuple f2() { return tupleC'hi", 47); } static ThreeTuple<Amphibian,String,Integer> g() { return tuple(new AmphibianO, "hi", 47);

}

static

FourTuple<Vehicle,Amphibian,String,Integer> hO {

return tuple(new VehicleO, new AmphibianO, "hi", 47);

}

static

FiveTuple<Vehicle,Amphibian.String,Integer,Double> к О { return tuple(new VehicleO, new AmphibianO, "hi", 47, 11.1);

}

public static void main(String[] args) {

TwoTuple<String,Integer> ttsi = f(); System out.println(ttsi): System.out.println(f20); System.out.println(gO); System.out println(hO); System.out.println(kO);

}

} /* Output (hi, 47) (hi, 47)

([email protected], hi, 47) ([email protected], [email protected], hi. 47) ([email protected], [email protected] hi. 47, 11.1) *///:-

Обратите внимание: f() возвращает параметризованный объект TwoTuple, a f2() — ^параметризованный объект TwoTuple. Компилятор в данном случае не выдает предупреждения о f2(), потому что возвращаемое значение не используется в «параметризованном» стиле: в каком-то смысле проводится «восходящее преобразование» его до непараметризованного TwoTuple. Но, если попытаться сохранить результат f2() в параметризованном объекте TwoTuple, компилятор выдаст предупреждение.