java基础之泛型详解

　Set接口的实现类ArrayList详解

(一).泛型介绍:

　　　　  泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
  　　　　　　(i).格式：<数据类型>      此处的数据类型只能是引用类型。
 　　　　　　 (ii).好处：
    　　　　　　　　A:把运行时期的问题(判断数据类型)提前到了编译期间
   　　　　　　　　 B:避免了强制类型转换
     　　　　　　　  C:优化了程序设计

(二).泛型类：把类定义在泛型上

　　

ObjectTool.java;

/*
 * 泛型类：把泛型定义在类上
 */
public class ObjectTool<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

ObjectToolDemo.java

/*
 * 泛型类的测试
 */
public class ObjectToolDemo {
    public static void main(String[] args) {
        //类不是泛型情况下，要用同类型来接收
        /* ObjectTool ot = new ObjectTool();
         ot.setObj(new String("张三"));
         String s = (String) ot.getObj();
        System.out.println("姓名是：" + s);
        
        ot.setObj(new Integer(30));
         Integer i = (Integer) ot.getObj();
         System.out.println("年龄是：" + i);

         ot.setObj(new String("李四"));
         // 报ClassCastException异常
         Integer ii = (Integer) ot.getObj();
         System.out.println("姓名是：" + ii);*/

        //泛型类应用
        ObjectTool<String> ot = new ObjectTool<String>();
        // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
        ot.setObj(new String("张三"));
        String s = ot.getObj();
        System.out.println("姓名是：" + s);

        ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        // ot2.setObj(new String("张三"));//这个时候编译期间就过不去
        ot2.setObj(new Integer(27));
        Integer i = ot2.getObj();
        System.out.println("年龄是：" + i);
    }
}

 

(三).泛型定义在方法上:

　　

ObjectTool.java;

public class ObjectTool<T> {
    /*
     * 非泛型方法的定义，不同类型要写不同的方法
    public void show(String s) {
        System.out.println(s);
    }

    public void show(T t) {
        System.out.println(t);
    }
}
*/
/*
 * 泛型方法：把泛型定义在方法上
 */
public class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

ObjectToolDemo.java;

public class ObjectToolDemo {
    public static void main(String[] args) {
        // ObjectTool ot = new ObjectTool();
        // ot.show("hello");
        // ot.show(100);
        // ot.show(true);

        // ObjectTool<String> ot = new ObjectTool<String>();
        // ot.show("hello");
        //
        // ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        // ot2.show(100);
        //
        // ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>();
        // ot3.show(true);

        // 定义泛型方法后
        ObjectTool ot = new ObjectTool();
        ot.show("hello");
        ot.show(100);
        ot.show(true);
    }
}

(四).泛型定义在接口上:
　　　直接上代码，上了你就明白了

Inter.java;
/*
 * 泛型接口：把泛型定义在接口上
 */
public interface Inter<T> {
    public abstract void show(T t);
}

InterImpl.java;

//普通的方式和泛型接口实现
//实现类在实现接口的时候
//第一种情况：已经知道该是什么类型的了

//public class InterImpl implements Inter<String> {
//
//    @Override
//    public void show(String t) {
//        System.out.println(t);
//    }
// }

//第二种情况：还不知道是什么类型的,根据自己的需求来变化
public class InterImpl<T> implements Inter<T> {

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

(五).泛型高级(通配符):

　　

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

/*
 * 泛型高级(通配符)
 * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
 * ? extends E:向下限定，E及其子类
 * ? super E:向上限定，E极其父类
 */
public class GenericDemo {
    public static void main(String[] args) {
        // 泛型如果明确的写的时候，前后必须一致
        Collection<Object> c1 = new ArrayList<Object>();
        // Collection<Object> c2 = new ArrayList<Animal>();//出错
        // Collection<Object> c3 = new ArrayList<Dog>();//出错
        // Collection<Object> c4 = new ArrayList<Cat>();//出错

        // ?表示任意的类型都是可以的
        Collection<?> c5 = new ArrayList<Object>();
        Collection<?> c6 = new ArrayList<Animal>();
        Collection<?> c7 = new ArrayList<Dog>();
        Collection<?> c8 = new ArrayList<Cat>();

        // ? extends E:向下限定，E及其子类,上界最高也只能到E
        // Collection<? extends Animal> c9 = new ArrayList<Object>();//出错
        Collection<? extends Animal> c10 = new ArrayList<Animal>();
        Collection<? extends Animal> c11 = new ArrayList<Dog>();
        Collection<? extends Animal> c12 = new ArrayList<Cat>();

        // ? super E:向上限定，E及其父类，下界最低也要有E
        Collection<? super Animal> c13 = new ArrayList<Object>();
        Collection<? super Animal> c14 = new ArrayList<Animal>();
        // Collection<? super Animal> c15 = new ArrayList<Dog>();//出错
        // Collection<? super Animal> c16 = new ArrayList<Cat>();//出错
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}