泛型就是参数化类型
?适用于多种数据类型执行相同的代码
?泛型中的类型在使用时指定,即便用时已确认类型
?泛型归根究竟就是“模版”,所以写框架中一般都会运用到。
优点:使用泛型时,在实际使用之前类型就已经确定了,不需要强制类型转换。
泛型主要使用在集合中
public void TestArrayList() { List list = new ArrayList(); list.add("string1"); list.add("string2"); list.add(100);//假如使用泛型(List<String>) ,此处通不过编译 for (int i = 0; i < list.size(); i++) { String name = (String) list.get(i); // 此处会报异常java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String System.out.println("name:" + name); } }通过泛型,可以在编译阶段发现问题,避免出现类型出错的异常。
自己设置泛型
泛型字母
形式类型参数(formal type parameters)即泛型字母
命名泛型字母可以随便指定,尽量使用单个的大写字母(有时候多个泛型类型时会加上数字,比方T1,T2)
常见字母(见名知意)
?T Type
?K V Key Value
?E Element
- 当类被使用时,会使用具体的实际类型参数(actual type argument)代替
泛型类
? 只能用在成员变量上,只能使用引用类型
注意:
? 泛型的类型参数只能是类类型,不能是简单类型。
? 不能对确切的泛型类型使用instanceof操作。这样的操作(if(ex_num instanceof Generic<Number>){ })是非法的,编译时会出错。
/** * 自己设置泛型类 * * 定义"模版"的时候,泛型用泛型字母:T 代替 * 在使用的时候指定实际类型 * * @author Administrator * @param <T> */public class Student<T> { private T javase; //private static T javaee; // 泛型不能使用在静态属性上 public Student() { } public Student(T javase) { this(); this.javase = javase; } public T getJavase() { return javase; } public void setJavase(T javase) { this.javase = javase; } }/** * 自己设置泛型的使用 * 在公告时指定具体的类型 * 不能为基本类型 * */class Demo02 { public static void main(String[] args) { //Student<int> Student = new Student<int>(); //不能为基本类型,编译时异常 Student<Integer> student = new Student<Integer>(); student.setJavase(85); System.out.println(student.getJavase()); }}泛型接口
?只能用在笼统方法上
/** * 自己设置泛型接口 * * 接口中泛型字母只能使用在方法中,不能使用在全局常量中 * * @author Administrator * @param <T> */public interface Comparator<T1,T2> { //public static final T1 MAX_VALUE = 100; //接口中泛型字母不能使用在全局常量中 //T1 MAX_VALUE; public static final int MAX_VALUE = 100; void compare(T2 t); T2 compare(); public abstract T1 compare2(T2 t);}泛型方法
?返回值前面加上 <T>
import java.io.Closeable;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.util.List; /** * 非泛型类中定义泛型方法 * @author Administrator * */public class Method { // 泛型方法,在返回类型前面使用泛型字母 public static <T> void test1(T t){ System.out.println(t); } // T 只能是list 或者者list 的子类 public static <T extends List> void test2(T t){ t.add("aa"); } // T... 可变参数 ---> T[] public static <T extends Closeable> void test3(T...a) { for (T temp : a) { try { if (null != temp) { temp.close(); } } catch (Exception e) { e.printStackTrace(); } } } public static void main(String[] args) throws FileNotFoundException { test1("java 是门好语言"); test3(new FileInputStream("a.txt")); }}泛型的继承
/** * 泛型继承 * * 保留父类泛型 ----》泛型子类 * 不保留父类泛型 -----》子类按需实现 * * 子类重写父类的方法,泛型类型随父类而定 子类使用父类的属性,该属性类型随父类定义的泛型 * * @author Administrator * * @param <T1> * @param <T2> */public abstract class Father<T1, T2> { T1 age; public abstract void test(T2 name);} // 保留父类泛型 ----》泛型子类// 1)一律保留class C1<T1, T2> extends Father<T1, T2> { @Override public void test(T2 name) { }} // 2) 部分保留class C2<T1> extends Father<T1, Integer> { @Override public void test(Integer name) { }} // 不保留父类泛型 -----》子类按需实现// 1)具体类型class C3 extends Father<String, Integer> { @Override public void test(Integer name) { }} // 2)没有具体类型// 泛型擦除:实现或者继承父类的子类,没有指定类型,相似于Objectclass C4 extends Father { @Override public void test(Object name) { }}泛型通配符
- ?未知类型 类型参数赋予不确定值,任意类型, 只能用在公告类型、方法参数上,不能用在定义泛型类上
/** * 泛型的通配符 类型不确定,用于公告变量或者者形参上面 * * 不能使用在类上 或者者 new 创立对象上 * @author Administrator * */public class Demo04 { // 用在形参上 public static void test(List<?> list) { List<?> list2; // 用在公告变量上 list2 = new ArrayList<String>(); list2 = new ArrayList<Integer>(); list2 = new ArrayList<Object>(); } public static void main(String[] args) { test(new ArrayList<String>()); test(new ArrayList<Integer>()); }}Generic<Integer>不能被看作为`Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本(由于参数类型是不确定的),不同版本的泛型类实例是不兼容的。
泛型上下边界 extends/super
上限(extends)
指定的类必需是继承某个类,或者者实现了某个接口(不是implements),即<=
- ? extends List
下限(super)
即父类或者本身
- ? super List
/** * extends:泛型的上限 <= 一般用于限制操作 不能使用在增加数据上,一般都是用于数据的读取 * * supper:泛型的上限 >= 即父类或者自身。一般用于下限操作 * * @author Administrator * @param <T> */ public class Test<T extends Fruit> { private static void test01() { Test<Fruit> t1 = new Test<Fruit>(); Test<Apple> t2 = new Test<Apple>(); Test<Pear> t3 = new Test<Pear>(); t1.getCustFruit(new ArrayList<Fruit>()); Apple apple=t2.getCustFruit(new ArrayList<Apple>()); Pear pear=t2.getCustFruit(new ArrayList<Pear>()); } private static void test02(List<? extends Fruit> list) { } private static void test03(List<? super Apple> list) { } //在泛型方法中增加上下边界限制的时候,必需在权限公告与返回值之间的<T>上增加上下边界,即在泛型公告的时候增加 public <T1 extends Fruit> T1 getCustFruit(List<T1> list){ if(list!=null&&list.size()>0) { return list.get(0); }else{ return null; } } public static void main(String[] args) { // 调用test02(),测试 extends <= test02(new ArrayList<Fruit>()); test02(new ArrayList<Apple>()); test02(new ArrayList<ReadApple>()); // test02(new ArrayList<Object>()); Object 不是 Fruit 的子类 ,编译不通过 // 调用test03() ,测试super >= test03(new ArrayList<Apple>()); test03(new ArrayList<Fruit>()); //test03(new ArrayList<ReadApple>()); ReadApple < apple,所以不能放入 } } class Fruit { } class Apple extends Fruit { } class Pear extends Fruit { } class ReadApple extends Apple { }