十、泛型
1、ArrayList的应用
import java.util.ArrayList;
import java.util.List;
public class Person {
public static void main(String[] args){
ArrayList<Integer> listC =new ArrayList<Integer>(); //ArrayList<>类
List<String > listD =new ArrayList<String>();
listC.add(200);
listD.add("hh");
int num=listC.get(0);
System.out.println(num);//200
}
}
在这里就引入泛型，注意这里的Integer是包装类，区别于int，包装类还有Float。
2、泛型类
public class Person {
public static class FanXing<E>{ //在类里面嵌套类,静态的话可以主函数里直接使用
public E id;
public void setName(E id){
this.id = id;
}
/*
public void setName(String E){ }
public void setName(Integer E){ }
...
public void setName(Object E){ }
以前要应用重载功能写好几个函数，泛型直接写一个*/
public E getName() {
return this.id;
}
}
public static void main(String[] args){
FanXing<Integer> person = new FanXing<Integer>(); //定义了泛型参数为Integer
person.setName(new Integer(1));
System.out.println(person.getName());//1
person.setName(2);//也可以直接传入2，2直接装箱，成为new Integer(2)
System.out.println(person.getName());//2
FanXing<String> person1 = new FanXing<String>(); //定义了泛型参数为String
person1.setName("he");
System.out.println(person1.getName());//he
person1.setName(new String("s"));
System.out.println(person1.getName());//s
}
}
泛型就相当于将参数类型也作为一个参数，对于那些功能相同，只是传入数据类型不同的接口、类、方法等有着很大的简化作用，避免反复造轮子。
3、泛型方法
public class Person {
public static class FanXing<E>{ //在类里面嵌套类,静态的话可以主函数里直接使用
private E id;
public void setName(E id){
this.id = id;
}
public E getName() {
return this.id;
}
public <T> void showID(T id){ //泛型方法，输入泛型参数
System.out.println(id);
}
public <T1,T2> T1 getID(T1 id1,T2 id2){ //泛型方法，输入与输出泛型
System.out.print(id1);
System.out.print(" and ");
System.out.println(id2);
return id1;
}
public <T> E getResult(T sex){ //泛型类的成员方法 + 泛型方法
System.out.println(sex);
return this.id;
}
}
public static void main(String[] args){
FanXing<Integer> person = new FanXing<Integer>(); //定义了泛型参数为Integer
person.setName(new Integer(1)); //泛型类的成员方法
System.out.println(person.getName());//1 泛型类的成员方法
person.showID(new Integer(11111));//11111 泛型方法，也是泛型类的成员方法
person.showID("ssss");//ssss 泛型方法，也是泛型类的成员方法
Integer a = person.getID(new Integer(22222),new Float(111.1f));
//22222 and 111.1 有泛型返回值的泛型方法，也是泛型类的成员方法
System.out.println(a);//22222
Integer b = person.getResult(new Integer(33333)); //33333
System.out.println(b);//this.id is 1
}
}
泛型是不允许定义在static上面的
public static <T> getTest(T t) { }//不允许
4、泛型接口
interface File<E>
{
public void write(E e);
public E read();
}
//泛型类继承泛型接口
class Music<E> implements File<E>{ //也可以写在public class Person里面
private E data;
public void write(E e){
this.data =e;
}
public E read(){
return this.data;
}
}
//普通类继承泛型接口，E必须指定
class Video implements File<Float>{ //也可以写在public class Person里面
private Float data;
public void write(Float e){
this.data =e;
}
public Float read(){
return this.data;
}
}
//泛型类继承泛型类
class Mp3<E> extends Music<E>{
}
//普通类继承泛型类
class Mp4 extends Music<Integer>{
}
public class Person {
public static void main(String[] args){
Music<Integer> music = new Music<Integer>();
music.write(new Integer(2021));
System.out.println(music.read());//2021
Video video =new Video();
video.write(new Float(111.1f));
System.out.println(video.read());//111.1
Mp3<String> mp3 =new Mp3<String>();
mp3.write("泛型类继承泛型类成功");
System.out.println(mp3.read());//泛型类继承泛型类成功
Mp4 mp4 =new Mp4();
mp4.write(new Integer(2021));
System.out.println(mp4.read());//2021
}
- 泛型类与普通类都可以继承泛型接口
- 泛型类与普通类都可以继承泛型类
5、类型通配符
类型通配符一般是在不确定具体参数时候，使用?代替，只在声明类型、方法参数上，不能用在定义泛型类
public class Person {
public static void test(List<?> list) {
List<?> list2;
list2 = new ArrayList<String>();
list2 = new ArrayList<Integer>();
list2 = new ArrayList<Object>();
}
public static void main(String[] args) {
test(new ArrayList<String>());
test(new ArrayList<Integer>());
}
}
