为什么要使用泛型

泛型的引入

1）编译时，检查添加元素的类型，提高了安全性

2）减少了类型转换的次数，提高效率

3）不在提示编译警告

 泛型解决的问题

1）不能对加入到集合中的数据类型进行约束

2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

用代码来理解

import java.util.ArrayList;

public class Generic01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(new Dog("小黄",10));
        list.add(new Dog("小黑",16));
        list.add(new Dog("小蓝",15));


        //这里使用传统方法 添加Dog类 却传进来了一个Cat类,不可取
        list.add(new Cat("小花",20));
        for (Object o :list) {
            Dog dog =(Dog) o;
            System.out.println(dog.getName()+"-"+dog.getAge());
        }


    }
}

class Cat{
    public String name;
    public int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog{
    public String name;
    public int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

泛型的理解

1）泛型可以理解成一种数据类型

2）泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型的安全问题

3）Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会出产生                                   ClassCastException异常，同时，代码更加简洁，健壮

4）泛型的作用是：可以在类声明时通过一个标识表示 类中的某个属性的类型，或者是某个         方法的返回值类型，或者是参数类型

泛型的声明

interface 接口<T>{}和class 类<k,v>{}

//比如：List,ArrayList

说明：

1）其中，T,K,V不代表值，而是表示类型

2）任意字母都可以，常用T表示，是Type的缩写

3）在指定范围具体类型后，可以传入该类型或者该子类类型

4 ）List <Integer> list1 =new ArrayList<Integer>();  第二个Integer一般省略

5）不能传入基本数据类型，只能传入引用类型 (例子：不能传入int,只能传入integer)

泛型例题（原理）（细节） (比较)

import java.util.*;
@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));

        //遍历
        for (Student student : students) {
            System.out.println(student);
        }

        //使用泛型方式给HashMap 放入3个学生对象
        //K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
            public class HashMap<K,V>  {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("hsp", new Student("hsp", 28));

        //迭代器 EntrySet
        /*
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
         */
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("==============================");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}
class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
	//省略getter、setter、toString方法
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class GenericDetail {
    public static void main(String[] args) {
        //给泛型指向数据类型 要求使用引用数据类型，而不能使用基本数据类型
        ArrayList<Integer> l = new ArrayList<>();
        //ArrayList<int> l2 = new ArrayList<int>();错误 不能为基本数据类型

        //2、因为E指定了A 类型，构造器传入了new A()
           //在泛型制定具体类型后，可以传入该类型或者其子类型
        C<A> ac = new C<A>(new A());
        C<A> ab = new C<A>(new B());
        //错误，因为E指向的是A 不是B。继承后正确 因为B为A的子类型


        //3.泛型的使用形式
        ArrayList<Integer> li = new ArrayList<>();
        List<Integer> li2 = new ArrayList<>();

        //在实际开发中 我们往往会简写
        //编译器会进行类型判断  后面的可以省略
        ArrayList<Object> list = new ArrayList<>();
        List<Integer> list1 =  new ArrayList<>();
        ArrayList<B> bs = new ArrayList<>();

        //4.如果是这样写 泛型默认是Object
        ArrayList arrayList = new ArrayList();


    }
}
class A{

}
class B extends A{

}
class C<E>{
    E e;

    public C(E e) {
        this.e = e;
    }
}

import javax.swing.plaf.basic.BasicTreeUI;
import java.util.ArrayList;
import java.util.Comparator;

/**
 * 
 * 定义Employee类 （包含生日日期 需要自己定义）
 * 创建三个对象 并把这些对象放入ArrayList集合中排序
 *排序按照名字排序 名字相同 按照日期排序
 */
public class GenericExercise {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {

        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee("jack",24444,new MyDate(2000,10,3)));
        list.add(new Employee("tom",25000,new MyDate(2002,10,3)));
        list.add(new Employee("li",29555,new MyDate(2003,10,3)));
        list.add(new Employee("li",30000,new MyDate(2003,10,2)));
        System.out.println("employee ="+list);
        System.out.println("==对雇员进行排序==");
        list.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                //先对传入的参数进行验证
                if(!(o1 instanceof Employee && o2 instanceof Employee)){
                    System.out.println("类型不正确");
                    return 0;
                }
                int i =o1.getName().compareTo(o2.getName());
                //比较姓名相同
                if (i != 0) {
                    return  i;
                }
                //如果name相同 比较birthday
                int yearMinus =o1.getBirthday().getYear()-o2.getBirthday().getYear();
                if (yearMinus!=0){
                    return yearMinus;
                }
                int monthMinus =o1.getBirthday().getMonth()-o2.getBirthday().getMonth();
                if (monthMinus!=0){
                    return monthMinus;
                }
                return o1.getBirthday().getDay()-o2.getBirthday().getDay();
            }
        });
        System.out.println(list);
    }
}

class Employee{
    public String name;
    public int sal;
    public MyDate birthday;

    public Employee(String name, int sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "\nEmployee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

 自定义泛型

语法

class 类名 <T,R>{ }

理解

1）普通成员可以使用泛型

2）使用泛型的数组，不能初始化,因为不知道什么数据类型

3）静态方法不能使用类的泛型

4）泛型类的类型，是在创建对象时确定的

5）如果创建对象时，没有指定类型，默认为Object

 必须get

import java.util.Arrays;
@SuppressWarnings({"all"})
public class CustomGeneric_ {
    public static void main(String[] args) {
        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);
    }
}
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开空间
    T[] ts;
    public Tiger(String name) {
        this.name = name;
    }
    public Tiger(R r, M m, T t) {//构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }
    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }
    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    //方法使用泛型
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public R getR() {
        return r;
    }
    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }
    public M getM() {//返回类型可以使用泛型.
        return m;
    }
    public void setM(M m) {
        this.m = m;
    }
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

 自定义泛型接口

语法

interface 接口名 <T,R>{}

理解

1）接口中，静态成员也不能使用泛型

2）泛型接口的类型，在继承接口或者实习方法时确定

3）没有指定类型，默认为Object

 必须get

public class CustomInterfaceGeneric {
    public static void main(String[] args) {
    }
}
//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}
//当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
//在实现IUsu接口的方法时，使用String替换U, Double替换R
class XX implements IA {
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {}
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {}
}
//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class YY implements IUsb<Integer, Float> {
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {}
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {}
}
//没有指定类型，默认为Object
//建议直接写成 IUsb<Object,Object>
class ZZ implements IUsb { //等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {}
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {}
}
interface IUsb<U, R> {
    int n = 10;
    //U name; 不能这样使用
    //普通方法中，可以使用接口泛型
    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);
    //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

自定义泛型方法

语法

修饰符 <T,R> 返回类型 方法名（参数列表）{}

理解

1）泛型方法，可以定义在普通类中，也可以定义在泛型类中

2）当泛型方法被调用时，类型会确定

3）public void eat(E e){},修饰符后没有<T,R>eat 方法不是泛型方法，只是用了泛型

这个挺简单的

public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马",100);//当调用方法时，传入参数，编译器就会确定类型
        System.out.println("==========");
        car.fly(100,399.0);

        fish<Integer,String> fish1 = new fish<>();
        fish1.hello("jack",22.9f);
    }
}

//1.泛型方法 可以定义在普通类中，也可以定义在泛型类中
//2.泛型方法被调用的时候必须要先声明

class Car{//普通类
    public void run(){

    }
    //T,R就是泛型
    //是提供给fly方法使用的
    public <T,R>void fly(T t,R r){//泛型方法

        System.out.println(t.getClass());//这里的T由上面给的参数决定
        System.out.println(r.getClass());//这里的R由上面给的参数决定
    }

}
class fish<T,R>{//泛型方法
    public void run(){

    }
    public <U,M>void eat(U u,M m){//泛型方法

    }
    //说明
    //1.下面hi方法不是泛型方法
    //2.是hi方法使用了类声明的泛型
    public  void hi(T t){}

    //泛型方法可以使用类声明的泛型 也可以使用自己声明的泛型
    public <K>void hello(R r ,K k){
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

泛型的继承和通配符

1）泛型不具备继承性

2）<?>:支持任何泛型类型

3）<? extends A>:支持A类以及A类的子类，规定了泛型的上限

4）<? super  A>:支持A类以及A类的父类，规定了泛型的下限

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * 泛型的继承和通配符
 */

public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×

        //冒泡排序

        //插入排序

        //....
    }

    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }

    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}