java泛型

package generic;

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

/**
 * 1，泛型：标签，泛化类型
 * 2，作用：安全  省心
 * @author Administrator
 *
 */
public class Test01 {
    
    public static void main(String[] args) {
        /**
         * JDK1.5之后，泛型
         */
        List<String> list = new ArrayList<String>();
        //安全，add的时候会类型检查
        list.add("牛贝");
        list.add("张三");
        //list.add(100);//类型检查
        
        //省心
        String ele = list.get(0);
        System.out.println(ele);
        
        //jdk1.5之前
        List list2 = new ArrayList();
        list2.add(100);
        list2.add("大表哥");
        
        //取出数据
        Object obj = list2.get(0);    
        Integer num = (Integer)obj; //麻烦
        
        //不安全
        num = (Integer)list2.get(1);// java.lang.ClassCastException
        if(list2.get(1) instanceof Integer){//需要手动类型转换
            num = (Integer)list2.get(1);//才能保证安全
        }
    }
}

package generic;

public class Student {
    /**
     * javase成绩
     * 需求：
     * 成绩可能是 整数、小数、成绩等级如A、B、C
     * 所以写成Object
     */
    private Object javase;

    public Student(){
    }
    public Student(Object javase) {
        super();
        this.javase = javase;
    }

    public Object getJavase() {
        return javase;
    }

    public void setJavase(Object javase) {
        this.javase = javase;
    }
}

package generic;

public class StudentApp {

    public static void main(String[] args) {
        Student stu = new Student(80);//存入整数
        Object javase = stu.getJavase();
        //类型检查 处理转换异常
        if(javase instanceof Integer){
            Integer score = (Integer)javase;//强制类型转换
        }
        stu = new Student("优秀");
        javase = stu.getJavase();
        if(javase instanceof String){
            String score = (String)javase;
        }
    }
}

package generic;
/**
 * 自定义泛型类：
 * 1，<> -->单个字母，尽可能见名知意
 * 2，T   Type
 *    K V  Key Value
 *    E  Element
 * 3，注意泛型不能使用在静态属性上
 */
//T  type ，类型
public class MyStudent<T> {
    private T javase;
//    private static T test;//静态编译错误

    public MyStudent(){}
    public MyStudent(T javase) {
        super();
        this.javase = javase;
    }

    public T getJavase() {
        return javase;
    }

    public void setJavase(T javase) {
        this.javase = javase;
    }
}

package generic;

public class MyStudentApp {

    public static void main(String[] args) {
        MyStudent<Integer> stu = new MyStudent<Integer>();
        //安全：类型检查
        stu.setJavase(80);
        //省心：
        Integer javase = stu.getJavase();
    }
}

package generic;
/**
 * 泛型接口：
 * 泛型不能使用在全局常量上
 * 
 * @param <T>
 */
public interface Comparator<T> {

    //全局常量
    /*public static final*/ int MAX_VALUE = 1024;
    //公共抽象方法
    /*public abstract */T compare(T t);
}

package generic;

import java.io.Closeable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * 非泛型类定义泛型方法
 * 定义：在返回类型前加 <字母>
 * @author Administrator
 *
 */
public class Method {

    //泛型方法
    public static <T> void test(T t){
        System.out.println(t);    
    }
    //泛型继承一个接口
    public static <T extends List> void test(T t){
        t.add("123");
        t.add(456);
        System.out.println(t.get(0));
    }
    
    /**
     * Closeable接口，有close()方法，释放资源
     * @param a 可变参数，类似数组用法
     */
    public static <T extends Closeable> void test(T... a){
        for (T temp : a) {
            if(temp != null){
                try {
                    temp.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static void main(String[] args) throws FileNotFoundException {
        test("我是泛型方法");
        
        List list = new ArrayList<>();
        list.add("我是有继承泛型方法啊！");
        test(list);
        
        test(new FileInputStream("a.txt"));
    }
}