java基础学习——泛型

1.泛型概述：

        泛型：时JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

        它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

        一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

        顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型        

        这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

2.泛型定义格式：     

        <类型>：指定一种类型的格式。这里的类型可以看成是形参

        <类型1，类型2...> ：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参

        将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型 

代码演示：

package com.aynu29;

//需求：Collection集合存储字符串并遍历

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

public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
//        Collection c=new ArrayList<>();
        Collection<String> c=new ArrayList<String>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
//        c.add(100);

        //编辑集合
//        Iterator it = c.iterator();
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
//            Object obj = it.next();
//            System.out.println(obj);
//            String s=(String) it.next();    //ClassCastException
            String s = it.next();
            System.out.println(s);
        }
    }
}

hello
world
java

泛型的好处：

        把运行时期的问题提前到了编译期间

        避免了强制类型转换

3.泛型类：

        泛型类的定义格式：

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

                范例：public class Generic<T>{ }

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

4.泛型方法：

        泛型方法的格式：

                格式：修饰符<类型>返回值类型 方法名（类型，变量名）{ }

                范例：public <T> void show(T t){ }

package com.aynu31;

//测试类

public class GenericDemo {
    public static void main(String[] args) {
//        Generic g=new Generic();
//        g.show("郭帅龙");
//        g.show(30);
//        g.show(true);
//        g.show(13.14);

//        Generic<String> g1=new Generic<String>();
//        g1.show("郭帅龙");
//
//        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(30);
        g.show(true);
        g.show(13.14);
    }
}

package com.aynu31;

/*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);
    }
}

        郭帅龙
        30
        true
        13.14
 

5.泛型接口： 

 泛型接口的定义格式：

        格式：修饰符 interface 接口名<类型>{ }

        范例：public interface Generic <T>{ }

代码演示：

package com.aynu31;

//测试类

public class GenericDemo2 {
    public static void main(String[] args) {
        Generic1<String> g1=new Generic1Impl<String>();
        g1.show("郭帅龙");

        Generic1<Integer> g2=new Generic1Impl<Integer>();
        g2.show(30);
    }
}

package com.aynu31;

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

package com.aynu31;

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

        郭帅龙
        30

 6.类型通配符：

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

        类型通配符：<?>

        List<?>：表示元素类型未知的List,它的元素可以匹配任何的类型

        这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

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

        类型通配符上限：<? extends 类型>

        List<? extends Number>：它表示的类型是Number或者其子类型

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

        类型通配符下限<? super 类型>

        List<? super Number>：它表示的类型是Number或者其父类型

package com.aynu32;

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

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

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

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

public class GenericDemo {
    public static void main(String[] args) {
        // 类型通配符：<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("--------");

        // 类型通配符上限：<? extends 类型>
//        List<? extends Number> list4=new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("--------");

        // 类型通配符下限<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<? super Number> list9=new ArrayList<Integer>();

    }
}

 7.可变参数：

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

        格式：修饰符 返回值类型 方法名（数据类型......变量名）{ }

        范例：public static int sum(int......a){ }

可变参数注意事项

        这里的变量其实是一个数组

        如果一个方法有多个参数，包含可变参数，可变参数要放在最后

package com.aynu32;

//测试类

public class ArgsDemo {
    public static void main(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));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));
        System.out.println(sum(10,20,30,40,50,60,70,80,90,100));

    }

//    public static int sum(int b,int... a){
//        return 0;
//    }

    public static int sum(int... a){
//        System.out.println(a);
//        return 0;

        int sum=0;
        for (int i:a){
            sum+=i;
        }
        return sum;
    }
}

30
60
100
150
210
280
550 

8.可变参数的使用： 

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

        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)：返回一个包含任意数量元素的不可变集合

        在给元素的时候，不能给重复的元素

        返回的集合不能做增删操作，没有修改操作

package com.aynu32;

//Arrays工具类中有一个静态方法：
//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)：返回一个包含任意数量元素的不可变集合

import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class ArgsDemo2 {
    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集合可以存在重复元素
        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集合不能调用set方法，不能存在重复元素
//        set.add("javaee");      //UnsupportedOperationException
//        set.remove("java");         //UnsupportedOperationException

        System.out.println(set);

    }
}

 [hello, java, world]