泛型类和泛型接口等

泛型代码第一小块

package day0822;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Objects;

/**
 * 泛型
 *
 * 注意: jdk7之后, 泛型类创建对象的时候, 可以只在变量声明的位置指明泛型类型
 * 泛型类   用的最多
 * 泛型接口
 * 泛型方法
 */
public class Demo10 {
    public static void main(String[] args) {
        MyArrayList<String> myArrayList = new MyArrayList<>();
        myArrayList.add("张三");
        myArrayList.add("东晓");

        String data = myArrayList.get(1);
        System.out.println("data = " + data);

        MyArrayList<Integer> myArrayList2 = new MyArrayList<>();
        myArrayList2.add(100);
        myArrayList2.add(101);

        Integer score = myArrayList2.get(0);
        System.out.println("score = " + score);

（上下代码有联系）

package day0822;

//E element
//T type
public class MyArrayList<E> {

    private Object[] elements = new Object[10];
    private int size;

    public boolean add(E data){
        elements[size++] = data;
        return true;
    }

    public E get(int index) {
        return (E) elements[index];
    }

    public int size(){
        return size;
    }
}

输出结果：

泛型代码第二小块

 		MyNode myNode = new MyNode("张三", 100);
        MyNode<String, Integer> myNode = new MyNode<>("张三", 200);

        String key = myNode.getKey();
        System.out.println("key = " + key);

        Integer value = myNode.getValue();
        System.out.println("value = " + value);

（上下代码有联系）

package day0822;

public class MyNode<K, V>{
    private K key;
    private V value;

    public MyNode(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey(){
        return key;
    }

    public V getValue(){
        return value;
    }
}

泛型方法

 String name = MyCollection.max("张三", "李四");
        System.out.println("name = " + name);

（这两个代码有联系）

package day0822;

import java.util.List;

public class MyCollection {

    public static <E> E max(E data, E data2){
        //比较两个数值中的最大值
        return data;
    }

    public static <E> void sort(List<E> list) {
        //排序
    }
}

泛型通配符<?>

任意类型，如果没有明确，那么就是Object以及任意的Java类了
	? extends E  相比而言重要一点
	向下限定，E及其子类
	? super E  用的非常少
	向上限定，E及其父类

 public static void main(String[] args) {
        ArrayList<String> arrayList1 = new ArrayList<>();
        ArrayList<Integer> arrayList2 = new ArrayList<>();
        print(arrayList1);
        print(arrayList2);

        ArrayList<Animal> humans = new ArrayList<>();
        print(humans);

    }

    public static void print(List<? super Human> list){
        System.out.println("list = " + list);
    }

因为List<? super Human> ，所以 ArrayList humans = new ArrayList<>();

（上下这两段代码有联系）

class Animal {}

class Human extends Animal{}

class Student extends Human {}