泛型类的定义格式:
- 格式:
修饰符 class 类名<类型>{}
- 范例:
public class Generic<T>{}
此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
例:
创建泛类
public class Generic<T> {
private T t;
public void setT(T t){
this.t = t;
}
public T getT(){
return t;
}
}
Demo:
//创建对象
Generic<String> g1 = new Generic<String>();
g1.setT("haha");
System.out.println(g1.getT());//输出 haha
//创建对象
Generic<Integer> g2 = new Generic<Integer>();
g2.setT(10);
System.out.println(g2.getT());//输出 10
泛型方法
- 格式:
修饰符<类型> 返回值类型方法名(类型 变量名){}
- 范例:
public <T> void show(T t){}
public class Generic<T> {
public void show(T t){
System.out.println(t);
}
}
改进:
public class Generic {
public <T> void show(T t){
System.out.println(t);
}
}
Demo:
Generic<String> g1 = new Generic<String>();
g1.show("haha");
Generic<Integer> g2 = new Generic<Integer>();
g2.show(18);
//改进后
Generic g = new Generic();
g.show("haha");
泛型接口
定义格式:
- 格式:
修饰符 interface 接口名<类型>{ }
- 范例:
public interface Generic<T>{ }
接口:
public interface Generic<T> {
void show(T t);
}
实现类:
public class GenericImlp<T> implements Generic<T> {
@Override
public void show(T t){
System.out.println(t);
}
}
Demo:
public class Demo {
public static void main(String[] args) {
Generic<String> g1 = new GenericImlp<String>();
g1.show("haha");
Generic<Integer> g2 = new GenericImlp<Integer>();
g2.show(1314);
}
}
输出:
haha
1314
类型通配符
为了表示各种泛型 List 的父类,可以使用类型通配符
- 类型通配符
<?>
- List<?>:表示元素类型未知的List,它的元素可以匹配任何元素
- 这种带通配符的 List 仅代表它是各种泛型 List 的父类,并不能吧元素添加到其中
如果说我们不希望List<?>是如何泛型 List 的父类,只希望它代表某一类泛型 List 的父类,可以使用类型通配符的上限
- 类型通配符上限:
<? extends 类型>
- List<? extends Number>:它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限,我们也可以指定类型通配符的下限
- 类型通配符下限:
<? super 类型>
- List<? super Number>:它表示的类型是
Number或者其父类型
//类型通配符
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Number>();
List<?> list3 = new ArrayList<Integer>();
System.out.println("------------------");
//类型通配符上限:<? extends 类型>
//List<? extends Number> list4 = new ArrayList<Object>();//报错,Object是Number的父类
List<? extends Number> list5 = new ArrayList<Number>();
List<? extends Number> list6 = new ArrayList<Integer>();
System.out.println("------------------");
//类型通配符下限:<? super 类型>
List<? super Number> list7 = new ArrayList<Object>();
List<? super Number> list8 = new ArrayList<Number>();
//List<? super Number> list9 = new ArrayList<Integer>();//报错,Integer是Number的子类
可变参数
可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了
- 格式:
修饰符 返回值类型 方法名(数据类型... a){ }
- 范例:
public static int sum(int... a){ }
例:
public class Demo {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
System.out.println(sum(10,20,30,40));
System.out.println(sum(10,20,30,40,50));
System.out.println(sum(10,20,30,40,50,60));
System.out.println(sum(10,20,30,40,50,60,70));
}
public static int sum(int... a){//a其实是一个数组,用来存储参数
int sum = 0;
for(int i:a){
sum += i;
}
return sum;
}
}
输出:
30
60
100
150
210
280
关于不可变参数和可变参数同时出现时。
public static int sum(int... a,int b){//报错
......
}
public static int sum(int b,int... a){//正常
......
}
不可变参数要放在可变参数前面
可变参数的使用
Arrays工具类中有一个静态方法:
- public static List asList(T… a):返回由指定数组支持的固定大小的列表
- 返回的集合不能做增删操作,可以做修改操作
List接口中有一个静态方法:
- public static List of(E… element):返回包含任意数量元素的不可变列表
- 返回的集合不能做增删改操作
Set接口中有一个静态方法:
- public static Set of(E… elements):返回一个包含任意数量元素的不可变集合
- 在给元素的时候,不能给重复的元素
- 返回的集合不能做增删操作,没有修改的方法