Java基础学习笔记21——泛型
目录
1、泛型概述
泛型时JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型。它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?
顾名思义,就是将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中,分别被称为泛型类、泛型方法、泛型接口。
1.1、泛型的定义格式
//泛型的定义格式
<类型> :指定一种类型的格式。这里的类型可以看成是形参
<类型1,类型2,...> :指定多种类型的格式,多种类型之间用逗号隔开。这里的类型可以看成是形参
将来具体调用的时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型。
1.2、泛型的好处
- 把运行时期的问题提前到了编译期间;
- 避免了强制类型转换。
2、泛型类
2.1、泛型类的定义格式
格式:修饰符 class 类名<类型> {}
范例:public class Generic<T> {}
//此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
2.2、泛型类的代码演示
package GPackage;
//泛型类
public class Generic<T> {
private T t; //类型T作为一个参数
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
package GPackage;
public class Test {
public static void main(String[] args) {
Generic<String> g1 = new Generic<String>();
g1.setT("张三");
System.out.println(g1.getT());
Generic<Integer> g2 = new Generic<Integer>();
g2.setT(20);
System.out.println(g2.getT());
}
}
结果:
张三
20
3、泛型方法
3.1、泛型方法的定义格式
格式:修饰符 <类型> 返回值类型 方法名(类型 变量名){}
范例:public <T> void show(T t){}
3.2、泛型方法的代码演示
package GPackage;
//类中定义泛型方法
public class Generic {
public <T> void show(T t){
System.out.println(t);
}
}
package GPackage;
public class Test {
public static void main(String[] args) {
Generic g = new Generic();
g.show("张三");
g.show(20);
}
}
结果:
张三
20
4、泛型接口
4.1、泛型接口的定义格式
格式:修饰符 interface 接口名<类型> {}
范例:public interface Generic<T> {}
4.2、泛型接口的代码演示
package GPackage;
//泛型接口
public interface Generic<T> {
void show(T t);
}
package GPackage;
//泛型接口的实现类
public class GenericImpl<T> implements Generic<T>{
@Override
public void show(T t) {
System.out.println(t);
}
}
package GPackage;
public class Test {
public static void main(String[] args) {
Generic<String> g1 = new GenericImpl<String>();
g1.show("张三");
Generic<Integer> g2 = new GenericImpl<Integer>();
g2.show(20);
}
}
结果:
张三
20
5、类型通配符
为了表示各种泛型List的父类,可以使用类型通配符。
类型通配符:<?>
List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中。
如果我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类,可以使用类型通配符的上限:
类型通配符上限:<? extends 类型>
List<? extends Number>:它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限,我们也可以指定类型通配符的下限:
类型通配符下限:<? super 类型>
List<? super Number>:它表示的类型是Number或者其父类型
代码演示:
package GPackage;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
//Object是Number的父类,Number是Integer的父类
//类型通配符:<?>
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Number>();
List<?> list3 = new ArrayList<Integer>();
//类型通配符上限:<? extends 类型>
//List<? extends Number> list11 = new ArrayList<Object>(); //报错,因为上限是Number
List<? extends Number> list22 = new ArrayList<Number>();
List<? extends Number> list33 = new ArrayList<Integer>();
//类型通配符的下限:<? super 类型>
List<? super Number> list111 = new ArrayList<Object>();
List<? super Number> list222 = new ArrayList<Number>();
//List<? super Number> list333 = new ArrayList<Integer>(); //报错,因为下限是Integer
}
}
6、可变参数
可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了。
可变参数的格式:
格式:修饰符 返回值类型 方法名(数据类型... 变量名){}
范例:public static int sum(int... a){}
可变参数注意事项:
- 这里的变量a其实是一个数组;
- 如果一个方法有多个参数,含有可变参数,可变参数要放在最后。
代码演示:
package GPackage;
public class Test {
public static void main(String[] args) {
System.out.println(sum(1,2));
System.out.println(sum(1,2,3));
System.out.println(sum(1,2,3,4));
}
//可变参数。如果有多个参数,可变参数要放到最后
public static int sum(int b, int... a){
//a是一个参数数组
int sum = 0;
for(int i: a){
sum += i;
}
return sum;
}
}
结果:
3
6
10
6.1、可变参数的使用
Arrays工具类中有一个静态方法:
//返回由指定数组支持的固定大小的列表
public static <T> List<T> asList(T... a){}
返回的集合不能做增删操作,可以做修改操作
List接口中有一个静态方法:
//返回包含任意数量元素的不可变列表
public static <E> List<E> of(E... elements){}
返回的集合不能做增删改操作
Set接口中有一个静态方法:
//返回一个包含任意数量元素的不可变集合
public static <E> Set<E> of(E... elements){}
在给元素的时候,不能给重复的元素
返回的集合不能做增删操作,没有修改的方法
代码演示:
package GPackage;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
public class Test {
public static void main(String[] args) {
//public static <T> List<T> asList(T... a):返回由指定数组支持的固定大小的列表
List<String> list1 = Arrays.asList("Hello", "World", "Java");
System.out.println(list1);
//list1.add("JavaEE"); //报错:UnsupportedOperationException
//list1.remove("Java"); //报错:UnsupportedOperationException
list1.set(1, "JavaEE"); //不报错,因为list长度不变
//public static <E> List<E> of(E... elements):返回包含任意数量元素的不可变列表
List<String> list2 = List.of("Hello","World","Java","World");
System.out.println(list2);
//list2.add("JavaEE"); //报错:UnsupportedOperationException
//list2.remove("Java"); //报错:UnsupportedOperationException
//list2.set(1, "JavaEE"); //报错:UnsupportedOperationException
//public static <E> Set<E> of(E... elements):返回一个包含任意数量元素的不可变集合
//Set<String> set = Set.of("Hello","World","Java","World"); //报错:IllegalArgumentException
Set<String> set = Set.of("Hello","World","Java");
System.out.println(set);
//set.add("JavaEE"); //报错:UnsupportedOperationException
//set.remove("Java"); //报错:UnsupportedOperationException
}
结果:
[Hello, World, Java]
[Hello, World, Java, World]
[World, Java, Hello]