Обобщенные методы

1. Правильно ли я понимаю, что первый <T> в static <T> void setIfNull означает, что метод setIfNull() мы можем вызвать только у класса, чьим "вложенным" типом является <T>? То есть, с таким же успехом мы можем вызвать его и у List<T> ? нет :) первый <T> в данном случае показывает, что это параметризированный метод, и в этом методе будет использоваться какой-то тип данных, который мы назовем T T - это просто буковка. она ничего не значит. с таким же успехом можете заменить ее на совершенно другую буковку. в мапе - там буковки <K, V>, ну типа key и value. в общем, никакой связи этот метод с интерфейсом List не имеет. просто так совпало, что и тут, и там - одна и та же буковка. 2. Верно ли, что <T> — это тип данных, который может вернуть наш метод и/или получить в качестве параметров? а вот это уже больше похоже на правду, да :) как я уже сказал, можно использовать и другие буковки. и можно даже "объявить" что в нашем параметризированном методе будет использоваться сразу несколько разных типов данных (как сделано в интерфейсе мапы, например). но это если дженерики вам нужны только для одного метода. если вы указываете дженерик на уровне класса - тогда вот так вот дополнительно объявлять их в методах уже не надо) 3. ну да, получается что так) 4. книги хед-феьорст, философия джавы. статьи на джавараше, в интернете. статьи/туториал на сайте оракла. гугл в помощь. нет универсальной статьи, прочитав которую абсолютно все сразу въезжают в дженерики) это происходит постепенно: прочитал в первый раз - ничего не понял, прочитал другое что-то - оо, вроде что-то понял, прочитал еще где-то - еще что-то понял, итд. ну и да, просто прочитать - мало. обязательно в коде попробуйте еще что-то сделать

static <T, V> void add(List<T> list, List<V> list2, T t, V v) {

public <T, S> void handle(T what, S how)

public void handle(Object what, Object how)

<T extends BufferedReader, S extends Comparable<T>>

public static void main(String[] args) {
    List<Accountant> employees = new ArrayList<>();
    employees.add(new Accountant(1));
    employees.add(new Accountant(2));
    employees.add(new Accountant(3));

    doJobIfNotFirstEmployee(employees);
}

static <T extends Employee> void doJobIfNotFirstEmployee(List<T> employees) {
    employees.stream()
           .filter(employee -> employee.getId() != 1)
           .forEach(T::doJob);
}

static abstract class Employee {
    protected int id;
    public int getId() {
        return id;
    }
    abstract protected void doJob();
}

static class Accountant extends Employee {
    public Accountant(int id) {
        this.id = id;
    }
    @Override
    public void doJob() {
        System.out.printf("I am %s with id %d I am doing Job\n", this.getClass().getSimpleName(), id);
    }
}

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

Ну и вот еще набросал пример:

public static void main(String[] args) {
    Map<Integer, String> map = new HashMap<>();
    map.put(1, "One");
    map.put(2, "Two");

    Map<String, List<String>> mapWithLists = new HashMap<>();
    mapWithLists.put("first", Arrays.asList("One", "Two", "Three"));
    mapWithLists.put("second", Arrays.asList("1", "2", "", "3"));

    System.out.println(getOrDefault(map, 3, "NoValue"));
    getOrDefault(mapWithLists, "first", new ArrayList<>())
            .stream()
            .filter(str -> !str.isEmpty())
            .forEach(System.out::println);
}

static <K, V> V getOrDefault(Map<K, V> map, K key, V defaultValue) {
    V v;
    return (v = map.get(key)) != null ? v : defaultValue;
}

Скажу честно - это калька с реального метода getOrDefault в интерфейсе Map. Ну с той поправкой, что мапу тут передаем тоже как параметр :) Один и тот же метод вполне спокойно работает с очень разными мапами, в которых разные ключи и значения, все работает благодаря дженерикам. Немного сложнее работать с кастомными классами, но здесь на помощь приходят интерфейсы и наследование. Например если V extends MyAwesomeClass, то я смогу в таком параметризованом методе вызвать методы MyAwesomeClass. Об этом в следующем примере.

static <K, V> V getOrDefault(Map<K, V> map, K key, V defaultValue) {
    V v;
    return (v = map.get(key)) != null ? v : defaultValue;
}

Что касается твоего первого примера, потыкай вот такой код:

public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    List<Date> dates = new ArrayList<>();
    Utils.add(strings, "String");
    Utils.add(dates, new Date());
    strings.forEach(System.out::println);
    dates.forEach(System.out::println);
}

public static class Utils {
    static <T> void add(List<T> list, T t) {
        list.add(t);
    }
}

Мне кажется достаточно наглядно.

В целом, гугли generics, оно так называется. Вот очень не плохой ресурс на разные темы, есть там и статья по Дженерикам. https://www.baeldung.com/java-generics То, что указывается в <T> действительно является типом с которым орудует метод. С таким подходом ты можешь реализовать метод, который будет работать с разными объектами, это частенько необходимо. Что бы далеко не ходить, давай рассмотрим пример из Collections

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size();
    if (srcSize > dest.size())
        throw new IndexOutOfBoundsException("Source does not fit in dest");

    if (srcSize < COPY_THRESHOLD ||
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {
        for (int i=0; i<srcSize; i++)
            dest.set(i, src.get(i));
    } else {
        ListIterator<? super T> di=dest.listIterator();
        ListIterator<? extends T> si=src.listIterator();
        for (int i=0; i<srcSize; i++) {
            di.next();
            di.set(si.next());
        }
    }
}

Обрати внимание, на приписки super и extends в сигнатуре, super означает что тип должен быть родителем для T (стоять выше по цепочке наследования), extends, соответственно, что тип должен наследовать T. Как ты понимаешь, Collections.copy() благодаря такому подходу можно использовать на очень широком списке разных коллекций. Например у тебя есть классы Animal -> Cat Ты можешь сделать copy(List<Animal> animals, List<Cat> cats);

public <T, S, E> void handle(T what, S how) // Указали также тип E, которого нет в параметрах
public <T> void handle(T what, S how) // Не указали тип, который есть в параметре

public static void main(String[] args) throws Exception {
        generic(new Cat());
        generic(new Animal());
    }

    private static <T extends Animal,S> void generic(T t) {
        System.out.println(t.toString());
    }
//I am Cat
//I am Animal