泛型的几种用法与集合安全问题

泛型

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

泛型类

• 泛型类：

  语法：类名 <T>
  T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开

1. 泛型只能是引用类型
2. 不同泛型类型对象之间不能相互复制

package com.list.demo.generic;

public class GenericClass<T> {
/*
* 泛型类：
* 语法：类名<T>
T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
* */
//    1.使用泛型T
//    1.创建变量
T t;

//    2.泛型作为方法的参数
public void setT(T t) {
this.t = t;
}

//    3.泛型作为方法的返回值
public T getT(){
return t;
}
}

package com.list.demo;

import com.list.demo.generic.GenericClass;

public class Demo4 {
public static void main(String[] args) {
//        注意：1.泛型只能是引用类型 2.不同泛型类型对象之间不能相互复制
GenericClass<String> stringGenericClass = new GenericClass<>();
stringGenericClass.setT("泛型");
System.out.println(stringGenericClass.getT());

GenericClass<Integer> integerGenericClass = new GenericClass<>();
integerGenericClass.setT(100);
System.out.println(integerGenericClass.getT());
}
}

泛型接口

• 泛型接口：

  语法：接口名<T>

  注意：不能创建泛型静态变量

package com.list.demo.generic;

/*
* 泛型接口：
* 语法：接口名<T>
注意：不能创建泛型静态变量
* */
public interface GenericInterface<T> {
//    static T t;  // 会报错，因为静态变量是先加载的，无法预知类型
T server(T t);
}

package com.list.demo;

import com.list.demo.generic.GenericInterface;

public class Demo6Impl<T> implements GenericInterface<T> {
@Override
public T server(T t) {
return t;
}
}

package com.list.demo;

import com.list.demo.generic.GenericInterface;

public class Demo5Impl implements GenericInterface<String>{
@Override
public String server(String s) {
return s;
}
public static void main(String[] args) {
Demo5Impl demo5 = new Demo5Impl();
System.out.println(demo5.server("你好"));

Demo6Impl<Integer> integerDemo6 = new Demo6Impl<>();
System.out.println(integerDemo6.server(100));
}
}

泛型方法

• 泛型方法： 语法 <T> 返回值类型

package com.list.demo;

public class Demo7 {

public static void main(String[] args) {

Demo7 demo7 = new Demo7();
demo7.show("你好");  // 泛型方法不需要我们传参数类型，它会根据我们传的参数自动匹配
demo7.show(100);
demo7.show(3.14);

get(1);
get("！！！");
get(3.1415926535);

}

public static <T> T get(T t) {
System.out.println(t);
return t;
}

public <T> T show(T t) {
System.out.println(t);
return t;
}
}

泛型集合

• 概念：参数化类型，类型安全的集合，强制集合元素的类型一致。

• 特点：

  编译时即可检查，而非运行时抛出异常
• 访问时，不必进行类型转换（拆箱）
• 不同泛型之间引用不能相互赋值，泛型不存在多态。

package com.list.demo;

import java.util.ArrayList;

public class Demo8 {
public static void main(String[] args) {

ArrayList arrayList = new ArrayList<>();

arrayList.add(10);
arrayList.add(3.14);
arrayList.add("10");

for (int i = 0; i <arrayList.size() ; i++) {
//            ClassCastException  这种集合是不安全的
String s = (String) arrayList.get(i);
System.out.println();
}
}
}

• 为了使得我们的集合更加安全，程序更加健壮，我们要将泛型加上

package com.list.demo;

import java.util.ArrayList;

public class Demo9 {
public static void main(String[] args) {

ArrayList<Integer> integers = new ArrayList<>();
integers.add(100);
//        integers.add(3.14); // 报错
//        integers.add("100");  // 报错
integers.add(50);
integers.add(80);

for (int i = 0; i < integers.size(); i++) {
Integer integer = integers.get(i);
System.out.println(integer);
}

}
}