泛型
泛型介绍
- 泛型又称参数化类型,是jdk5.0出现的新特性,解决数据类型的安全性问题。
- 在类声明或实例化时只要指定好需要的具体的类型即可。
- Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生。
- 泛型的作用:可以在类声明时通过一个标识表示类中某个属性的类型,或者某个方法的返回值类型,或是参数类型。
# 常见的泛型的类型表示
上面的 T 仅仅类似一个形参的作用,名字实际上是可以任意起的,但是我们写代码总该是要讲究可读性的。常见的参数通常有 :
E - Element (在集合中使用,因为集合中存放的是元素)
T - Type(表示Java 类,包括基本的类和我们自定义的类)
K - Key(表示键,比如Map中的key)
V - Value(表示值,如Map中的value)
? - (表示不确定的java类型)
泛型使用细节
package com.study.srv.demo15;
import java.util.ArrayList;
/**
* @author Wen先森
* @version 1.0
* @date 2022/4/11 17:23
*/
public class Demo04 {
public static void main(String[] args) {
//1.用泛型指向数据类型时,要求是引用类型,不能是基本类型
ArrayList<String> list = new ArrayList<>();
// ArrayList<int> ints = new ArrayList<int>();
//2.在给泛型指定了具体类型之后,可以传入该类型或者其他子类类型。
Son<A> aSon = new Son<A>(new A());
Son<A> bSon = new Son<A>(new B());
aSon.f();
bSon.f();
//3.泛型的使用形式
ArrayList<Integer> list1 = new ArrayList<Integer>();
//在实际开发中,我们往往简写,编译器会自动进行类型判断。
ArrayList<Integer> list2 = new ArrayList<>();
//4.如果不写<>。泛型默认是Object
ArrayList list3 = new ArrayList();
}
}
class A{}
class B extends A{}
class Son<E>{
E e;
public Son(E e) {
this.e = e;
}
public void f(){
System.out.println(e.getClass());
}
}
自定义泛型
基本语法:
class 类名<T,R...>{//...表示可以有多个泛型
成员
}
- 普通成员可以使用泛型(属性、方法)。
- 使用泛型的数组,不能初始化(因为数组在new时不能确定类型,无法开辟空间)。
- 静态方法中不能使用类的泛型(因为静态是和类相关的,在类加载时,对象还没有创建而泛型则是在类创建定义的时候才会指定类型)。
- 泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型)。
- 如果在创建对象时,没有指定类型,默认object。
自定义泛型接口
基本语法:
interface 接口名<T,R...>{
}
- 接口中,静态成员也不能使用泛型(这和泛型类的规定一样)。
- 泛型接口的类型,在继承接口或者实现接口时确定。
- 没有指定类型,默认为object。
- 泛型方法,可以定义在普通类中,也可以定义在泛型类中。
- 当泛型方法被调用时,类型会确定。
- 当public void eat(E e){},修饰符没有<T,R...>eat方法不是泛型方法,而是使用了泛型。
package com.study.srv.demo15;
/**
* @author Wen先森
* @version 1.0
* @date 2022/4/24 14:21
* 泛型方法使用
*/
public class Demo09 {
public static void main(String[] args) {
Car car = new Car();
System.out.println("调用car.f1方法:");
car.f1("测试",12);
System.out.println("调用car.f1方法:");
car.f1(12.00,'c');
Pig<String, Integer> pig = new Pig<>();
System.out.println("调用pig.f1方法:");
pig.f1(2,33);
System.out.println("调用pig.f2方法:");
pig.f2("?");
System.out.println("调用pig.f3方法:");
pig.f3('l',"随便");
}
}
class Car{
public void run(){
//普通方法
}
//1.<M,N>就是泛型
//2.提供给f1方法使用的
public <M,N> void f1(M m,N n){
//泛型方法
System.out.println(m.getClass());
System.out.println(n.getClass());
}
}
class Pig<T,R>{//泛型类
public void run(){
//普通方法
}
public <L,J> void f1(L l,J j){
//泛型方法
System.out.println(l.getClass());
System.out.println(j.getClass());
}
//1.f2不是泛型方法
//2.而是f2使用了类声明的泛型
public void f2(T t){
System.out.println(t.getClass());
}
//泛型方法,可以使用类声明的泛型,也可以使用自己声明的泛型。
public<K,J> void f3(K k,J j){
System.out.println(k.getClass());
System.out.println(j.getClass());
}
}
泛型的继承和通配符
- 泛型不具备继承性
- <?>:支持任意泛型类型
- <?extends A>:支持A类以及A类的子类,规定了泛型的上线
- <? super A>:支持A类以及A类的父类,不限于直接父类,规定了泛型的下限
package com.study.srv.demo15;
import java.util.ArrayList;
import java.util.List;
/**
* @author Wen先森
* @version 1.0
* @date 2022/4/24 16:17
*/
public class Demo10 {
public static void main(String[] args) {
Object o = new String("xx");
//泛型没有继承性
//List<Object> list = new ArrayList<String>();
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<A1> list3 = new ArrayList<>();
List<B1> list4 = new ArrayList<>();
List<C1> list5 = new ArrayList<>();
//如果是List<?>c,可以接受任意的泛型数据
printCollection1(list1); //√
printCollection1(list2); //√
printCollection1(list3); //√
printCollection1(list4); //√
printCollection1(list5); //√
//如果是List<? extends A1>c,表示上限,可以接受A1或者A1的子类
// printCollection2(list1); //×
// printCollection2(list2); //×
printCollection2(list3); //√
printCollection2(list4); //√
printCollection2(list5); //√
//如果是List<? super A1>c,表示下限,可以接受A1或者A1的父类,不限于直接父类
printCollection3(list1); //√
// printCollection3(list2); //×
printCollection3(list3); //√
// printCollection3(list4); //×
// printCollection3(list5); //×
}
public static void printCollection1(List<?> c) {
for (Object object : c) {
System.out.println(object);
}
}
public static void printCollection2(List<? extends A1> c) {
for (Object object : c) {
System.out.println(object);
}
}
public static void printCollection3(List<? super A1> c) {
for (Object object : c) {
System.out.println(object);
}
}
}
class A1{}
class B1 extends A1{}
class C1 extends B1{}