5.泛型学习

1. 泛型概述和好处

1. 泛型概述：泛型是JDK5中引入的特性，它提供了编译时类型安全监测机制，该机制允许在编译时监测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

• 参数化类型：将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类，方法，接口中，分别被称为泛型类，泛型方法，泛型接口。

2. 泛型定义格式：

• <类型>：指定一个类型的格式。这里的类型可以看成是形参。
• <类型1，类型2，……类型n>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
• 具体调用的时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型。

3. 泛型的好处

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换

2.泛型类

泛型类的定义格式：

• 格式：修饰符class 类名<类型>{ }

• 范例：public class Generic{ }

  此处T可以随便写为任意标识，常见的如T,E,K,V等形式的参数常用于表示泛型。

//student类
package Generic.study01;

public class student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

//teacher类
package Generic.study01;

public class teacher {
    private Integer age;

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

//泛型类
package Generic.study01;

public class Generic <T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

//测试类
package Generic.study01;

/*测试类*/
public class GenericDemo {
    public static void main(String[] args) {
        student s = new student();
        s.setName("小明");
        System.out.println(s.getName());

        teacher t = new teacher();
        t.setAge(19);
//        t.setAge("19");//会报错
        System.out.println(t.getAge());
        System.out.println("================");

//        泛型类对象
        Generic<String> generic = new Generic<String>();
        generic.setT("小明");
        System.out.println(generic.getT());

        Generic<Integer> generic1 = new Generic<Integer>();
        generic1.setT(30);
        System.out.println(generic1.getT());
    }
}

3.泛型方法

泛型方法的定义格式

• 格式：修饰符<类型> 返回值类型 方法名（类型 变量名）{ }
• 范例：public void show(T t){ }

//Generic类
package Generic.study02;

/*public class Generic {
   public void show(String s){
        System.out.println(s);
    }
    public void show(Integer i){
        System.out.println(i);
    }
    public void show(boolean b){
        System.out.println(b);
    }

}*/
/*//泛型类改进
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);
    }
}

//Generic测试类
package Generic.study02;

public class GenericDemo {
    public static void main(String[] args) {
        /*
        Generic generic = new Generic();
        generic.show("小明");
        generic.show(30);
        generic.show(true);
//        generic.show(23.32);//会报错
        */
/*//      泛型类改进
        Generic<String> g1 = new Generic<String>();
        g1.show("hello");
        Generic<Integer> g2 = new Generic<Integer>();
        g2.show(30);
        Generic<Boolean> g3 = new Generic<Boolean>();
        g3.show(true);*/

        //泛型方法改进
        Generic g = new Generic();
        g.show("明明");
        g.show(40);
        g.show(true);
        g.show(3.1415926939654315383054341202199707192717);
    }
}

4.泛型接口

泛型接口的定义格式

• 格式：修饰符 interface 接口名 <类型>{ }
• 范例： public interface Generic{ }

//Generic接口
package Generic.study03;

public interface Generic<T> {
    void show(T t);
}

//Generic类
package Generic.study03;

public class GenericImpl<T> implements Generic<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

//测试类
package Generic.study03;

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl();
        g1.show("明明");

        Generic<Integer> g2 = new GenericImpl<Integer>();
        g2.show(30);

        Generic<Boolean> g3 = new GenericImpl<Boolean>();
        g3.show(false);
    }
}

5. 类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符：<?>
• List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中。

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限。

• 类型通配符上限：<?extends 类型>
• List<?extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符下限：<?super 类型>
• List<? super Number>:它表示的类型是Number或者其父类型

package Generic.study04;

import java.util.ArrayList;
import java.util.List;

/*为了表示各种泛型List的父类，可以使用类型通配符
- 类型通配符：<?>
- List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
- 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中。

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限。
- 类型通配符上限：<?extends 类型>
- List<?extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
- 类型通配符下限：<?super 类型>
- List<? super Number>:它表示的类型是Number或者其父类型*/
public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();

//      Object是Number的父类，Number是Integer的父类
        //类型通配符上限：<?extends 类型>
        List<? extends Number> list4 = new ArrayList<Integer>();
        List<? extends Number> list5 = new ArrayList<Number>();
//        List<?extends Number> list6 = new ArrayList<Object>();//报错，超出了Number的上限

        //类型通配符下限：<?super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<?super Number> list9 = new ArrayList<Integer>();//报错，超出了Number的下限

    }
}

7.可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数的个数就可变了。

• 格式：修饰符 返回值类型 方法名(数据类型…变量名){ }

package Generic.study05;

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(1,10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(30,40,50,60));
    }
  /*  public static int sum(int b , int...a){
        return 0;
    }
//    如果一个方法有多个参数，包含可变参数，可变参数要放到最后*/
    public static int sum(int...a){
        int sum = 0;
        for (int i:a){
            sum+=i;
        }
        return sum;
    }
}

可变参数注意事项

• 这里的变量其实是一个数组
• 如果一个方法有多个参数，包含可变参数，可变参数要放到最后

8.可变参数的使用

Arrays工具类中有一个静态方法：

• public static <E> List<T> asList(T…a):返回由指定数组支持的固定大小的列表。
• 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法（java9才支持）：

• public static <E> List<E> of(E…elements):返回包含任意数量元素的不可变列表。

• 返回的集合不能做增删改操作

Set接口中有一个静态方法：

• public static <E> Set<E> of (E…elements):返回一个包含任意数量元素的不可变集合。
• 在给元素的时候，不能给重复的元素
• 返回的集合不能做增删操作，没有修改的方法

public class ArgsDemo02 {
    public static void main(String[] args) {
        //public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
//        List<String> list = Arrays.asList("hello", "world", "java");
//
        list.add("javaee"); //UnsupportedOperationException
        list.remove("world"); //UnsupportedOperationException
//        list.set(1,"javaee");
//
//        System.out.println(list);

        //public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可变列表
//        List<String> list = List.of("hello", "world", "java", "world");
//
        list.add("javaee");//UnsupportedOperationException
        list.remove("java");//UnsupportedOperationException
        list.set(1,"javaee");//UnsupportedOperationException
//
//        System.out.println(list);

        //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");

//        set.add("javaee");//UnsupportedOperationException
//        set.remove("world");//UnsupportedOperationException

        //System.out.println(set);
    }
}