泛型

• Java泛型是jdk1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递
• 常见形式有泛型类、泛型接口、泛型方法
• 语法：<T,…> T称为类型占位符，表示一种引用类型
• 好处：提高代码的重要性；防止类型转换异常，提高代码的安全性

泛型类：

//泛型类：类名<T>，T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
public class MyGeneric<T>{
    //使用泛型T(不能实例化)
    //创建变量
    T t;
    //作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    //泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

public class TestGeneric{
    public static void main(String[] args){
        
        //使用泛型类创建对象
        //泛型只能是引用类型，不同泛型类型对象之间不能相互赋值
        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t = "hello";
        myGeneric.show("大家好"); //大家好
        String s = myGeneric.getT();
        System.out.println(s); //hello
        
        MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
        myGeneric2.t = 100;
        myGeneric2.show(200); //200
        Integer i = myGeneric2.getT();
        System.out.println(i); //100
    }
}

泛型接口：

//泛型接口：接口名<T>,不能创建泛型静态常量
public interface MyInterface<T>{
    String name = "张三";
    T server(T t);
}

public class MyInterfaceImpl implements MyInterface<String>{
    @Override
    public String server(String t){
        System.out.println(t);
        return t;
    }
}

public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T server(T t){
        System.out.println(t);
        return t;
    }
}

public class TestGeneric{
    public static void main(String[] args){
        
    	MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.server("你好"); //你好
        
        MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<Integer>();
        impl2.server(1000); //1000
    }
}

泛型方法：

//泛型方法：<T> 方法返回值类型
public class MyGenericMethod{
    //泛型方法
    public <T> T show(T t){
        System.out.println("泛型方法" + t);
        return t; 
    }
}

public class TestGeneric{
    public static void main(String[] args){
    	MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show("你好，Java");
        myGenericMethod.show(100);
        myGenericMethod.show(3.14);
    }
}

• 泛型集合
  • 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
  • 特点：
    • 编译时即可检查，而非运行时抛出异常
    • 访问时，不必类型转换（拆箱）
    • 不同泛型之间引用不能相互赋值，泛型不存在多态

ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("aaa");
arrayList.add("bbb");
//arrayList.add(10); //编译报错
//增强for
for(String s : arrayList){
    System.out.println(s);
}

ArrayList<Student> arrayList2 = new ArrayList<Student>();
Student s1 = new Student("张三",20);
Student s2 = new Student("李四",21);
Student s3 = new Student("王五",22);
arrayList2.add(s1);
arrayList2.add(s2);
arrayList2.add(s3);
//迭代器
Iterator<Student> it = arrayList2.iterator();
while(it.hasNext()){
    Student s = it.next();
    System.out.println(s.toString());
}