泛型

1.泛型

1. 泛型的概述与好处

泛型的概述

• 泛型：是JDK5中引入的特性。它提供了编译时类型安全检测机制，该机制允许在编译是检测到非法的类型。
• 它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，就是将类型由原来的具体的类型参数化，猿猴在使用调用时传入具体的类型
• 这种参数类型可以用在类，方法，接口中，分别被称为泛型类，泛型方法，泛型接口。
• 格式：< 类型 > 指定一种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成形式。
• 将来具体调用的时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处

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

2. 泛型类

• 格式：修饰符 class 类名< 类型 >{}
• eg:public class Generic< T >{} 此处T可以随便写为任意标识，常见的T，E，K，V等形式的参数常用于表示泛型。

public class Demo {
    public static void main(String[] args) {
        Generic<String> g1=new Generic<String>();
        g1.setT("java");
        Generic<Integer> g2=new Generic<Integer>();
        g2.setT(60);
        System.out.print(g1.getT()+","+g2.getT());
    }
}
//输出：java,60
public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

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

3. 泛型方法

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

public class Demo{
    public static void main(String[] args) {
        Generic g=new Generic();
        g.show("java");
        g.show(60);
        System.out.print(g+" ");
    }
}
//输出：java  60
public class Generic{
    public <T> void show(T t){
        System.out.println(t);
    }
}

4. 泛型接口

• 格式：修饰符 interface 接口名< 类型 >{}
• eg:public interface Generic< T >()

public class Demo{
    public static void main(String[] args) {
        Generic g=new Generic();
        g.show("java");
        g.show(60);
        Gener<String> g2=new Generic<String>();
        g2.show("java");
        Gener<Integer> g3=new Generic<Integer>();
        g3.show(60);
    }
}
public interface Gener<T> {
    void show(T t);
}public class Generic<T> implements Gener<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
//第一种输出：java  60
//第二种输出：java  60

2. 类型通配符

1.类型通配符

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

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

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

• 类型通配符上限：< ?extands类型 >

• eg: List< ？extends Number >：他表示的类型是number或其子类型，number是这个类型的父类型。

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

• 类型通配符上限：< ?super 类型 >
• eg: List< ?super Number>:

3. 可变参数

概述

• 可变参数又称参数个数可变，用做方法的形参出现，那么参数个数就是可变的了。
• 格式：修饰符 返回值类型 方法名（数据类型…变量名）{}
• eg:public static int sum (int…a){}

public class ArgsDemo{
public static void mian(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));
}
public static int sum(int... a){
int sum=0;
for(int i=a){
sum+=i;
}
return sum;
}
}
//输出：30  60  100  150

可变参数注意事项

• 这里的变量其实是一个数组（a）
• 如果一个方法有多个参数，包含可变参数，可变参数要放在最后。例如public static int sum(int b,int… a){}

可变参数的使用
Arrarys工具中有一个静态方法：
public static < T > List< T > asList(T… a):返回指定数组支持的固定大小的列表。
*返回的集合不能做增删操作，可以做修改操作。

List接口中有一个静态方法：
public static < E > LIst< E > of(E… elements):返回包含任意数量元素的不可变列表。
*返回的集合不能做增删改操作

Set接口中有一个静态方法：
public static < E > Set< E > of(E… elements):返回一个包含任意数量元素的不可变集合。

• 再给元素的时候，不能给重复元素
• 返回的集合不能增删，没有修改的方法。

public class AegsDemo{
public static void mian(String[] aegs){
//public static < T > List< T > asList(T... a):返回指定数组支持的固定大小的列表。
List<String> list=Arrary.asList("java","c++","html");
list.add("hello");//UnsupportedOperationException
list.remove("c++");//UnsupportedOperationException
list.set(1,"javase");
System.out.println(list);

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

//public static < E > Set< E > of(E... elements):返回一个包含任意数量元素的不可变集合。
Set<String> set=Set.of("hello","world","java","world");
list.add("hello");//UnsupportedOperationException
list.remove("c++");//UnsupportedOperationException
System.out.println(set);
}
}