泛型
1、创建集合对象，不使用泛型
好处：集合不使用泛型，默认的类型就是object类型，可以存储任意类型的数据。
弊端：不安全，会引发异常。
2、创建集合对象，使用泛型
好处：为了避免类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候就会报错）。
弊端：泛型是什么类型，就只能存储什么类型。
/**
* @program: intellij idea
* @description:定义一个含有泛型的类。泛型可以接受任意的数据类型。
* 创建对象的时候确定泛型的数据类型。
* @author: lixy
* @create: 2020-05-02 11:05
**/
public class MyGeneric<T> {
private T name;
public MyGeneric() {
}
public MyGeneric(T name) {
this.name = name;
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
}
//不写泛型默认是object类型
MyGeneric myGeneric = new MyGeneric();
myGeneric.setName("heihei");
Object obj = myGeneric.getName();
//使用泛型，创建对象时确定类型,泛型使用Integer类型
MyGeneric<Integer> stringMyGeneric = new MyGeneric<Integer>();
stringMyGeneric.setName(1);
Integer name = stringMyGeneric.getName();
System.out.println(name);
含有泛型的方法
/**
* @program: intellij idea
* @description:定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间。
* 含有泛型的方法，在调用方法的时候确定泛型的数据类型
* 传递什么类型的参数，泛型就是什么类型
* @author: lixy
* @create: 2020-05-02 16:03
**/
public class MyGenericMethod {
//定义一个含有泛型的方法
public <T> void method(T t){
System.out.println(t);
}
//定义一个含有泛型的静态方法
public static <T> void method02(T t){
System.out.println(t);
}
}
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.method(1);
myGenericMethod.method("hahha");
//静态方法
MyGenericMethod.method02(5);
MyGenericMethod.method02("静态方法");
运行结果：
1
hahha
5
静态方法
/**
* @program: intellij idea
* @description:定义含有泛型的接口
* @author: lixy
* @create: 2020-05-02 16:28
**/
public interface GenericInterface <T> {
public abstract void method(T t);
}
//第一种泛型接口的使用方式：定义接口的实现类，实现接口，指定接口的泛型
public class GenericInterfaceImpl implements GenericInterface<String> {
@Override
public void method(String s) {
System.out.println(s);
}
}
/**
* @program: intellij idea
* @description:第二种泛型接口的使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
* 就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
* @author: lixy
* @create: 2020-05-02 16:40
**/
public class GenericInterfaceImpl02<T> implements GenericInterface<T> {
@Override
public void method(T t) {
System.out.println(t);
}
}
GenericInterfaceImpl genericInterface = new GenericInterfaceImpl();
genericInterface.method("jiekou1");
GenericInterfaceImpl02<Integer> impl02 = new GenericInterfaceImpl02<>();
impl02.method(555);
运行结果：
jiekou1
555
