十、泛型

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>());
    }
}