Java 泛型
结论: 暂时不指定类型, 调用再决定类型
原则: 如果泛型方法可以取代将整个类泛型化, 那就应该只使用泛型方法
1 package 泛型; 2 3 class Teacher { // 教师类的描述 4 } 5 6 class Student { // 学生类的描述 7 } 8 9 //class Tool { // 以前都这么搞 10 // private Object obj; 11 // 12 // public Object getObject() { 13 // return obj; 14 // } 15 // public void setObject(Object obj) { 16 // this.obj = obj; 17 // } 18 //} 19 20 class Utils<T> { // 限定类型 21 private T t; 22 23 public T getObject() { 24 return t; 25 } 26 27 public void setObject(T t) { 28 this.t = t; 29 } 30 } 31 32 public class 演变 { 33 34 public static void main(String[] args) { 35 36 // Tool t = new Tool(); 37 // t.setObject(new Teacher()); 38 // Student s = (Student) t.getObject(); // 编译会通过 39 40 /** 41 * 1.将运行时期出现问题 ClassCastException, 转移到了编译时期 42 * 2.避免了强制转换麻烦 43 */ 44 Utils<Teacher> u = new Utils<Teacher>(); 45 u.setObject(new Teacher()); 46 Student s = u.getObject(); // 编译会报错 47 } 48 }
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); } }
1 package 泛型; 2 3 import java.util.*; 4 5 public class 通配符 { 6 7 public static void main(String[] args) { 8 9 ArrayList<String> al = new ArrayList<String>(); 10 11 al.add("孑小"); 12 al.add("孑小"); 13 al.add("孑小"); 14 printColl(al); 15 16 ArrayList<Integer> al_1 = new ArrayList<Integer>(); 17 18 al_1.add(28); 19 al_1.add(28); 20 al_1.add(28); 21 // printColl_1(al_1); 22 printColl(al_1); 23 24 } 25 26 // public static void printColl(ArrayList<String> al) { 27 // for (Iterator<String> it = al.iterator(); it.hasNext();) { 28 // System.out.println(it.next()); 29 // } 30 // } 31 // public static void printColl_1(ArrayList<Integer> al) { 32 // for (Iterator<Integer> it = al.iterator(); it.hasNext();) { 33 // System.out.println(it.next()); 34 // } 35 // } 36 37 public static void printColl(ArrayList<?> al) { 38 for (Iterator<?> it = al.iterator(); it.hasNext();) { 39 System.out.println(it.next()); 40 } 41 } 42 }
1 package 泛型; 2 3 import java.util.*; 4 5 public class 泛型上下限 { 6 public static void main(String[] args) { 7 8 ArrayList<Person> al = new ArrayList<Person>(); 9 al.add(new Person("孑小")); 10 al.add(new Person("孑小")); 11 al.add(new Person("孑小")); 12 printColl(al); 13 printColl_1(al); 14 15 ArrayList<Student> al_1 = new ArrayList<Student>(); 16 al_1.add(new Student("孑小")); 17 al_1.add(new Student("孑小")); 18 al_1.add(new Student("孑小")); 19 printColl(al_1); 20 printColl_1(al_1); 21 } 22 23 // ? extends E 上限,接收E类型或E类型的子类型 24 public static void printColl(ArrayList<? extends Person> al) { 25 for (Iterator<? extends Person> it = al.iterator(); it.hasNext();) { 26 System.out.println(it.next().getName()); 27 } 28 } 29 30 // ? super E 下限,接收E类型或E类型的父类型 31 public static void printColl_1(ArrayList<? super Student> al) { 32 for (Iterator<? super Student> it = al.iterator(); it.hasNext();) { 33 System.out.println(((Person) it.next()).getName()); 34 } 35 } 36 }