泛型

泛型

     JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
​​​​​

 好处 

  1.将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。，
  2，避免了强制转换麻烦。

泛型格式：
  通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？
  通常在集合框架中很常见，
  只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<>();  // 只能存放String类型的对象

        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        for(Iterator<String> it = al.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
}

比较器也有泛型

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/*
* 泛型的使用
*
* */
public class GenericDemo2 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<String>(new StringLengthCompare());

        ts.add("aaaaa");
        ts.add("bbb");
        ts.add("bcc");
        ts.add("acccc");
        ts.add("b");

        for (Iterator<String> it = ts.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
}
// 比较器也有泛型
class StringLengthCompare implements Comparator<String>{

    @Override
    public int compare(String o1, String o2) {
        // 倒序
        Integer num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
        if(num == 0){
            return o2.compareTo(o1);
        }
        return num;
    }
}

泛型类

public class GenericDemo3 {
    public static void main(String[] args) {
        Utils<Student> u = new Utils<Student>();

        u.setObject(new Student());
        Student s = u.getObject();
        System.out.println(s);
    }
}

// 泛型类
/*
什么时候定义泛型类？
    当类中要操作的引用数据类型不确定的时候，
    早期定义Object来完成扩展。
    现在定义泛型来完成扩展。
*/
class Utils<T>{

    private T qq;

    public T getObject() {
        return qq;
    }

    public void setObject(T qq) {
        this.qq = qq;
    }
}

class Student{

}
class Worker{

}

泛型方法

/ 泛型方法

/*
泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。

*/

/*
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

*/

class Demo<Q>{

    private Q obj;

    // 泛型方法
    public <T> void print(T t){
        System.out.println(t);
    }

    // 静态泛型方法  // 在类未实例化调用
    public static <T> void show(T t){
        System.out.println(t);
    }

    public Q getObject() {
        return obj;
    }

    public void setObject(Q q) {
        this.obj = q;
    }

}
public class GenericDemo4 {
    public static void main(String[] args) {
        Demo<String> d = new Demo<String>();
        d.setObject("what?");
        System.out.println(d.getObject());

        d.print("hahaha");
        d.print(new Integer(33)); // 可以是任何类型

        Demo.show(new Long(12121));
    }
}

泛型接口

// 泛型接口
interface Inter<T>{
    void show(T t);
}

class Interimple<T> implements Inter<T>{

    @Override
    public void show(T t) {
        System.out.println("show:"+t);
    }
}

public class GenericDemo5 {

    public static void main(String[] args) {
        Interimple<Integer> i = new Interimple<Integer>();
        Interimple<String> i2 = new Interimple<String>();
        i.show(2);
        i2.show("hahaha");
    }
}

泛型的限定

? 通配符。也可以理解为占位符。
泛型的限定；
        ？ extends E: 可以接收E类型或者E的子类型。上限。
        ？ super E: 可以接收E类型或者E的父类型。下限

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericDemo6 {
    public static void main(String[] args) {

        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc1"));
        al.add(new Person("abc2"));
        al.add(new Person("abc3"));
        printColl(al);
        /*
        abc1
        abc2
        abc3
        */

        ArrayList<Stu> al1 = new ArrayList<Stu>();
        al1.add(new Stu("abc--1"));
        al1.add(new Stu("abc--2"));
        al1.add(new Stu("abc--3"));
        printColl(al1);
        /*
        abc--1
        abc--2
        abc--3
        */

    }
    // <? extends Person> 可以接受Person类型 或者 它的子类
    public static void printColl(Collection<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();

        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
}

class Person{
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}
// stu 继承 Person
class Stu extends Person{
    public Stu(String name) {
        super(name);
    }
}