Day16.泛型

1 泛型

1. 概念：是一个未知的数据类型，是一个参数化类型
2. 使用场景：
   （1）如果需要给一个类型定义属性，但是这个类型中的属性不确定，可以使用泛型来代替定义。
   （2）如果需要定义一个方法，但是该方法的参数列表类型和返回值类型不确定，可以使用泛型来定义。

2 泛型应用之：泛型类的定义和使用【掌握】

1. 概念：使用泛型定义的类型
2. 格式：

class 类名<泛型>{  

} 

3. 注意事项：
   （1）如果要在类中使用某个泛型的话，需要先在类上进行声明，声明之后才可以使用
   （2）类中使用了几个泛型，需要在类上声明几个泛型
   （3）泛型符号：只要是一个合法的标识符即可
   一般使用大写的字母来表示（E Q K V A）
   （4）在使用带着泛型的类型时，要给一个确定的类型
   一旦确定泛型的类型，以后该对象中泛型都是这一个类型
   （5）在使用带着泛型的类型时，泛型前后类型要保持一致
   Java语言支持泛型的推断：如果前面的类型中确定了泛型，后面的可以不用写，只需要跟上一个<>即可。
   （6）泛型只能表示引用数据类型，不能表示基本数据类型

代码

package demos2_jeneric;

public class Demo01 {
    public static void main(String[] args) {
        //1、如果在使用类型时，没有指定泛型的类型，默认使用object类型
        //2、如果在使用类型时，确定了泛型的类型（Integer）,以后类中定义的泛型都是为Integer
        Person<Integer,String> p = new Person<>();
        p.setName("张三");
//        p.setHeight(180);//Integer in = String.valueOf(180)   Object o = in;
        p.setHeight(180);
        String name = p.getName();
        Integer height = p.getHeight();
        System.out.println(name + "..." + height);

        Person<Double,Integer> p2 = new Person<>();
        p2.setName("李四");
//        p2.setHeight(180.5);//Double  ===> Object
        p2.setHeight(180.6);
        String name2 = p2.getName();
        Double height2 = p2.getHeight();
        System.out.println(name2 + "..." + height2);

    }
}
//在类中想要使用某些泛型，需要先在；类上声明该泛型
class Person<A,B>{
    private String name;
    //如果属性的类型不确定，可以使用泛型来定义不确定的类型
    //泛型如何定义：使用一个合法的标识符
    private A height;
    private B age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setHeight(A height){
        this.height = height;
    }
    public  A getHeight(){
        return height;
    }
}

3 泛型应用之：泛型方法的定义和使用【掌握】

1. 概念：使用泛型定义的方法
2. 格式：

修饰符 <泛型的声明> 方法名(){
} 

3. 注意事项：
   （1）如果定义的泛型方法是一个静态方法，需要先在方法上声明泛型才能使用
   （2）如果定义的泛型方法是一个非静态方法，既可以自己声明，也可以使用类上声明 的泛型
   （3）定义的泛型根据后续传入参数的类型决定

代码

package demos2_jeneric;

import java.util.Arrays;

public class Demo02<A> {
    public static void main(String[] args) {

//        Integer[] arr = {1,2,3,4,5};
//        Double[] arr = {10.1,20.1,30.1,40.1};
        Stu[] stus = {new Stu("张三",23),new Stu("李四",24),new Stu("王五",25)};
        changeIndex(stus,0,2);
        System.out.println(Arrays.toString(stus));
    }
    //可以交换任意类型的数组
    //具体是哪一个数据类型，确定吗？不确定，使用来定义
    //当前方法是一个静态方法：只能在方法上声明泛型，不能使用类上声明的
    //定义泛型之后，后续传递哪一个类型的参数，方法中的泛型就是哪一个类型
    public static <E> void changeIndex(E[] arr,int x,int y){
        E temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
    //如果方法是一个非静态方法，既可以使用类上声明的泛型，也可以自己声明泛型
    public void print(A e){
        System.out.println(e);
    }
}
class Stu{
    String name;
    int age;

    public Stu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4 泛型应用之：集合对泛型的使用

1. 概述：学习的集合是支持泛型的
   可以使用泛型，也可以不使用泛型
   如果定义集合之后，没有使用泛型：元素在集合中都是Object接收
   如果定义集合之后，使用了泛型，元素在集合中就是定义的类型
2. 使用泛型定义集合的特点：
   （1）如果定义的集合使用了泛型，那么当前集合中只能添加对应类型的元素；
   （2）如果集合定义了泛型，添加元素之后，不会再默认向上转型
   （3）使用集合元素特有的方法时，不需要向下转型，直接使用即可
   集合转数组遍历补充

代码

package demos2_jeneric;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo04 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("xyz");
        list.add("aaa");
        //转数组，返回的数组类型指定为object类型
//        Object[] obs = list.toArray();
//        for (int i = 0; i < obs.length; i++) {
//            String str = (String)obs[i];
//        }

        //转数组，自己准备数组存储元素
        //如果准备的数组空间够存，就存入准备的数组中
        //如果准备的数组空间不够村，就返回一个新的数组来存储数据
        //好处：不需要向下转型
        String[] strs = new String[list.size()];
        String[] strs2 = list.toArray(strs);
        System.out.println(strs == strs2);
        for (int i = 0; i < strs2.length; i++) {
            String str = strs2[i];
            System.out.println(str);
        }
    }

    private static void test03(ArrayList<String> list) {
        for(int i = 0; i <= list.size()-1; i++){
            String str = list.get(i);
            System.out.println(str);
        }
    }

    private static void test02(ArrayList<String> list) {
        for(String str: list){
            System.out.println(str);
        }
    }

    private static void test01(ArrayList<String> list) {
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
    }
}

5 泛型通配符【了解】

1. 概念：在定义一个不确定的数据类型时，不仅可以使用泛型定义，也可以使用泛型的通 配符。
2. 分类：
   ?：类型通配符，所有的类型
   ? extends E：类型通配符上限，表示类型E的子类或者E类型
   ? super E：类型通配符下限，表示类型E的父类泛型或者E类型

代码

    public static void getList(ArrayList<?> list){
//?：Integer  String  Number  Object
    }
public static void getList2(ArrayList<? extends Number> list){
//? extends Number :Integer  Number
    }
public static void getList3(ArrayList<? super Number> list){
//? super Number:Number  Object
    }