Java 泛型

结论: 暂时不指定类型, 调用再决定类型

原则: 如果泛型方法可以取代将整个类泛型化, 那就应该只使用泛型方法

package 泛型;

class Teacher {    // 教师类的描述
}

class Student {    // 学生类的描述
}

//class Tool {    // 以前都这么搞
//    private Object obj;
//
//    public Object getObject() {
//        return obj;
//    }
//    public void setObject(Object obj) {
//        this.obj = obj;
//    }
//}

class Utils<T> { // 限定类型
    private T t;

    public T getObject() {
        return t;
    }

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

public class 演变 {

    public static void main(String[] args) {

//        Tool t = new Tool();
//        t.setObject(new Teacher());
//        Student s = (Student) t.getObject();    // 编译会通过

        /**
         * 1.将运行时期出现问题 ClassCastException, 转移到了编译时期
         * 2.避免了强制转换麻烦
         */
        Utils<Teacher> u = new Utils<Teacher>();
        u.setObject(new Teacher());
        Student s = u.getObject();                // 编译会报错
    }
}

package 泛型;

/**
 * 泛型类定义的泛型, 在整个类中有效
 */
//class Utils1<T> {
//
//    public void show(T t) {
//        System.out.println("show:    " + t);
//    }
//
//    public void print(T t) {
//        System.out.println("print:    " + t);
//    }
//
//}

/**
 * 不同方法可以操作不同类型
 */
class Utils1 {

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

    public <T> void print(T t) {
        System.out.println("print:    " + t);
    }

    /**
     * 静态方法不可以访问类上定义的泛型, 可以将泛型定义在方法上。
     */
    public static <T> void method(T t) {
        System.out.println("method:    " + t);
    }

}

public class 高阶 {

    public static void main(String[] args) {

//        Utils<String> u = new Utils<String>();
//        u.show("孙旌棋");
//        u.print(863523704);// 这样不OK, 写了直接挂

        Utils1 u = new Utils1();
        u.show("孑小");
        u.print(28);
    }
}

package 泛型;

import java.util.*;

public class 通配符 {

    public static void main(String[] args) {

        ArrayList<String> al = new ArrayList<String>();

        al.add("孑小");
        al.add("孑小");
        al.add("孑小");
        printColl(al);

        ArrayList<Integer> al_1 = new ArrayList<Integer>();

        al_1.add(28);
        al_1.add(28);
        al_1.add(28);
//      printColl_1(al_1);
        printColl(al_1);

    }

//    public static void printColl(ArrayList<String> al) {
//        for (Iterator<String> it = al.iterator(); it.hasNext();) {
//            System.out.println(it.next());
//        }
//    }
//    public static void printColl_1(ArrayList<Integer> al) {
//        for (Iterator<Integer> it = al.iterator(); it.hasNext();) {
//            System.out.println(it.next());
//        }
//    }

    public static void printColl(ArrayList<?> al) {
        for (Iterator<?> it = al.iterator(); it.hasNext();) {
            System.out.println(it.next());
        }
    }
}

package 泛型;

import java.util.*;

public class 泛型上下限 {
    public static void main(String[] args) {

        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("孑小"));
        al.add(new Person("孑小"));
        al.add(new Person("孑小"));
        printColl(al);
        printColl_1(al);

        ArrayList<Student> al_1 = new ArrayList<Student>();
        al_1.add(new Student("孑小"));
        al_1.add(new Student("孑小"));
        al_1.add(new Student("孑小"));
        printColl(al_1);
        printColl_1(al_1);
    }

    // ? extends E 上限,接收E类型或E类型的子类型
    public static void printColl(ArrayList<? extends Person> al) {
        for (Iterator<? extends Person> it = al.iterator(); it.hasNext();) {
            System.out.println(it.next().getName());
        }
    }

    // ? super E 下限,接收E类型或E类型的父类型
    public static void printColl_1(ArrayList<? super Student> al) {
        for (Iterator<? super Student> it = al.iterator(); it.hasNext();) {
            System.out.println(((Person) it.next()).getName());
        }
    }
}