泛型
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
泛型类
语法：类名
T表示类型占位符，表示一种引用类型，如果编写多个，使用逗号隔开。
创建泛型类：
public class MyGeneric<T> {}
使用泛型：
package Generic; //泛型类 //语法：类名<T> //T表示类型占位符，表示一种引用类型，如果编写多个，使用逗号隔开。 public class MyGeneric<T> { //使用泛型T // 1.创建变量 T t; // 2.作为方法的参数 public void show(T t) { //不能实例化,即不能new System.out.println(t); } // 3.泛型作为方法的返回值 public T getT() { return t; } }
测试泛型类：
package Generic; public class TestGeneric { public static void main(String[] args) { // 注意: // 1.泛型只能使用引用类型 // 2.不同泛型对象之间不能互相复制 // 使用泛型类创建字符串对象 MyGeneric<String> gen1=new MyGeneric<String>(); gen1.t="hello"; gen1.show("加油!"); String str=gen1.getT(); // 使用泛型类创建数字对象 MyGeneric<Integer> gen2=new MyGeneric<Integer>(); gen2.t=12; gen2.show(45); Integer in=gen2.getT(); } }
泛型接口
语法：接口名
注意：不能创建泛型静态常量
创建泛型接口:
package Generic; //泛型接口 //语法：接口名<T> //不能创建泛型静态常量 public interface MyInterface<T> { String name="uzi"; //在没有使用泛型接口之前并不知道类型，所以不能用new T server(T t); }
接口不能实例化，所以要创建一个接口实现类：
package Generic; public class MyInterfaceImpl1 implements MyInterface<String>{ // 在传递类型的时候确定类型为String @Override public String server(String s) { System.out.println(s); return s; } }
这里的MyInterfaceImpl1在实现MyInterface接口的时候，传递的类型确定类型为String。也可以不规定类型，接口实现类代码：
package Generic; public class MyInterfaceImpl2<T> implements MyInterface<T>{ // 在传类型的时候不确定 @Override public T server(T t) { System.out.println(t); return t; } }
测试泛型接口：
package Generic; public class TestGeneric { public static void main(String[] args) { // 测试泛型接口 MyInterfaceImpl1 impl1=new MyInterfaceImpl1(); impl1.server("ming"); MyInterfaceImpl2 impl2=new MyInterfaceImpl2(); impl2.server(1000); impl2.server("uzi"); } }
imlp1由于在实现接口类中规定了类型，所以必须是String，而impl2没有规定类型，即可以创建不同类型。
泛型方法
语法： 返回值类型
创建泛型方法：
package Generic; //泛型方法 //语法：<T> 返回值类型 public class MyGenericMethod { // 创建泛型方法 public <T> void show(T t){ System.out.println("泛型方法"+t);//无返回值 } public <T> T show2(T t){ System.out.println("泛型方法"+t);//有返回值 return t; } }
测试泛型方法：
package Generic; public class TestGeneric { public static void main(String[] args) { // 测试泛型方法 MyGenericMethod myGenericMethod=new MyGenericMethod(); myGenericMethod.show("你好啊");//不需要规定类型 myGenericMethod.show(3.14); myGenericMethod.show2(123);//类型由传递的数据决定 } }
泛型集合
即泛型在集合中的使用
泛型集合测试代码：
package Generic; import java.util.ArrayList; import java.util.Iterator; public class MyArrayList { public static void main(String[] args) { /* ArrayList arrayList=new ArrayList(); arrayList.add("uzi"); arrayList.add(22); arrayList.add("ming"); arrayList.add(23);//可以向集合中添加任何类型的数据 for (Object o : arrayList) { String str=(String) o; System.out.println(str); }//报错，因为类型不同有String类型也有int类型*/ // 使用泛型避免异常 ArrayList<String> arrayList=new ArrayList<String>(); arrayList.add("uzi"); // arrayList.add(22);//报错，只能添加String类型的 arrayList.add("ming"); ArrayList<Student> arrayList1=new ArrayList<Student>(); Student s1 = new Student("uzi", 23); Student s2 = new Student("ming", 24); arrayList1.add(s1); arrayList1.add(s2); arrayList1.add(new Student("doinb",26)) // arrayList1.add("1451"); //遍利 Iterator<Student> it = arrayList1.iterator(); while (it.hasNext()){ Student s=it.next();//拿到的类型就是Student，而不是Object，不要需要再进行强制类型转换 System.out.println(s.toString()); } } }
其中Student类代码：
package Generic; public class Student { public String name; public int age; public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
