泛型
泛型概述
泛型：
本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的典本的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
泛型定义格式：
<类型>：指定一种类型的格式。这里的类型可以看成是形参
<类型1,类型2..＞：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
泛型的好处
把运行时期的问题提前到了编译期间
避免了强制类型转换
package com.ye.myGeneric.itheima01; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /* 需求：Collection集合存储字符串并遍历 */ public class GenericDemo { public static void main(String[] args) { //创建集合对象 // Collection c = new ArrayList(); Collection<String> c = new ArrayList<String>(); c.add("双笙"); c.add("叶子"); c.add("元汐"); // // Iterator it = c.iterator(); Iterator<String> it = c.iterator(); while (it.hasNext()){ // String s = (String)it.next();//ClassCastException String s = it.next(); System.out.println(s); } } }
泛型类
泛型类的定义格式：
格式：修饰符class类名<类型>{}
范例：public class Generic<T>{}
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//测试方法
package com.ye.myGeneric.itheima02; public class GenericDemo { public static void main(String[] args) { Student s = new Student(); s.setName("双笙"); System.out.println(s.getName()); Teacher t = new Teacher(); t.setAge(20); System.out.println(t.getAge()); System.out.println("============"); Generic<String> g1 = new Generic<String>(); g1.setT("陈元汐"); System.out.println(g1.getT()); Generic<Integer> g2 = new Generic<Integer>(); g2.setT(20); System.out.println(g2.getT()); } }
学生类和老师类
package com.ye.myGeneric.itheima02; public class Student { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
package com.ye.myGeneric.itheima02; public class Teacher { private Integer age; public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } }
不同数据类型的数据需要多个不同的类来实现
而用泛型类只需要一个即可
package com.ye.myGeneric.itheima02; public class Generic <T>{ private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } }
需要固定泛型类的数据类型只需要更改泛型类中的<T>即可
泛型方法
泛型方法使得该方法能够独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能够做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。
泛型方法的定义格式：
格式：修饰符<类型＞返回值类型方法名(类型 变量名）{}
范范例：public <T> void show t){}
测试类
package com.ye.myGeneric.itheima03; public class GenericDemo { public static void main(String[] args) { // Generic g = new Generic(); // g.show("双笙"); // g.show(20); // g.show(true); // Generic<String> g1 = new Generic<String>(); // g1.show("双笙"); // // Generic<Integer> g2 = new Generic<Integer>(); // g2.show(20); // // Generic<Boolean> g3 = new Generic<Boolean>(); // g3.show(true); Generic g1 = new Generic(); g1.show("双笙"); g1.show(20); g1.show(true); g1.show(13.14); } }
package com.ye.myGeneric.itheima03; //public class Generic { // public void show(String s){ // System.out.println(s); // } // public void show(Integer i){ // System.out.println(i); // } // public void show(Boolean b){ // System.out.println(b); // } //} //泛型类改进 //public class Generic <T>{ // public void show(T t){ // System.out.println(t); // } //} //泛型方法改进 public class Generic { public <T> void show(T t){ System.out.println(t); } }
泛型接口
泛型接口的定义格式：
格式：修饰符interface接口名<类型>{}
package com.ye.myGeneric.itheima04; public interface Generic <T>{ void show(T t); }
package com.ye.myGeneric.itheima04; public class GenericImpl<T> implements Generic<T>{ @Override public void show(T t) { System.out.println(t); } }
package com.ye.myGeneric.itheima04; public class GenericDemo { public static void main(String[] args) { Generic<String> g1 = new GenericImpl<String>(); g1.show("双笙"); Generic<Integer> g2 = new GenericImpl<Integer>(); g2.show(20); Generic<Boolean> g3 = new GenericImpl<Boolean>(); g3.show(true); } }
类型通配符
为了表示各种泛型List的父类，可以使用类型通配符：
类型通配符：<?>
List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
//如果不希望List<?>是任何泛型的父类，只希望代表某一类泛型List的父类，可以使用类型通配符的上限。
类型通配符上限：<?extends类型>
List<? extends Number>：表示的类型是Number或者其子类型
//除了可以指定类型通配符的上限，也可以指定类型通配符的下限：
类型通配符下限：<?super类型>
List<?super Number>：表示的类型是Number或者其父类型
package com.ye.myGeneric.itheima05; import java.util.ArrayList; import java.util.List; /* 类型通配符：<?> List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中 类型通配符上限：<?extends类型> List<? extends Number>：表示的类型是Number或者其子类型 类型通配符下限：<?super类型> List<?super Number>：表示的类型是Number或者其父类型 */ public class GenericDemo { public static void main(String[] args) { //类型通配符：<？> List<?> list1 = new ArrayList<Object>(); List<?> list2 = new ArrayList<Number>(); List<?> list3 = new ArrayList<Integer>(); System.out.println("==============="); //类型通配符上限：<？ extends类型> // List<? extends Number> list4 = new ArrayList<Object>(); List<? extends Number> list5 = new ArrayList<Number>(); List<? extends Integer> list6 = new ArrayList<Integer>(); //类型通配符下限：<?super类型> List<? super Number> list7 = new ArrayList<Object>(); List<? super Number> list8 = new ArrayList<Number>(); //List<? super Number> list9 = new ArrayList<Integer>(); } }
可变参数
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
格式：修饰符返回值类型方法名（数据类型…变量名)（}
范例：public staticint sum(int..a) {}
可变参数注意事项
这里的变量其实是一个数组
如果一个方法有多个参数，包含可变参数，可变参数要放在最后
package com.ye.myGeneric.itheima06; public class ArgsDemo { public static void main(String[] args) { System.out.println(sum(10,20)); System.out.println(sum(10,20,30)); System.out.println(sum(10,20,30,40)); System.out.println(sum(10,20,30,40,50)); } public static int sum(int...a){ int sum = 0; for (int i : a) { // sum = sum + i; sum += i; } return sum; } }
可变参数
Arrays工具类中有一个静态方法：
public static <T> List<T> asList (T... a)：返回由指定数组支持的固定大小的列表
List接口中有一个静态方法：
public static <E> List<E> of (E... elements)：返回包含任意数量元素的不可变列表
Set接口中有一个静态方法：
public static <E> Set<E> of (E... elements）：返回一个包含任意数量元素的不可变集合
注：of方法只有在jdk9上才能使用
package com.ye.myGeneric.itheima06; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Set; /* Arrays工具类中有一个静态方法： public static <T> List<T> asList (T... a)：返回由指定数组支持的固定大小的列表 //of方法只有在jdk9才能使用 List接口中有一个静态方法： public static <E> List<E> of (E... elements)：返回包含任意数量元素的不可变列表 Set接口中有一个静态方法： public static <E> Set<E> of (E... elements）：返回一个包含任意数量元素的不可变集合 */ public class ArgsDemo02 { public static void main(String[] args) { // public static <T> List<T> asList (T... a)：返回由指定数组支持的固定大小的列表 // List<String> list = Arrays.asList("双笙","叶子","元汐"); // list.add("小九");//UnsupportedOperationException // list.remove("叶子");//UnsupportedOperationException // list.set(1,"小九"); // // System.out.println(list); } }
