JavaSE（2）12 集合--泛型

集合

泛型

概述

• jdk1.5之后引入的特性，提供了编译时类型安全检查机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
  • 将类型由原来的具体的类型参数化，然后在使用或调用时传入具体的类型
  • 这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法和泛型接口
• 定义格式：
  • <类型>，指定一种类型的格式，这里的类型可以被看作形参
  • <类型1,类型2…> 指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以被看作形参
  • 将来具体调用时候给定的类型可以看作是实参，且实参的类型只能是引用数据类型
• 好处：
  • 把运行期间的问题提前到编译期间
  • 避免了强制类型转换

 //泛型
    public static void main(String[] args) {
        Collection c=new ArrayList();
        c.add("zs");
        c.add("ls");
        c.add("ww");
        c.add(112);//运行时报异常 java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
       Iterator iterator = c.iterator();
        while (iterator.hasNext()){
            String next = (String) iterator.next();//需要强制转换
            System.out.println(next);
        }
    }
************************
   Collection<String> c=new ArrayList();
        c.add("zs");
        c.add("ls");
        c.add("ww");
        c.add(112);//好处一：编译时就报错add(java.lang.String in Collection cannot be appliedto(int)
         Iterator<String> iterator = c.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();//好处二：避免了类型强制转换
            System.out.println(next);
        }

泛型类

public class Demo02 {
    //泛型类
    public static void main(String[] args) {
        Teacher teacher=new Teacher();
        teacher.setName("zs");
        //teacher.setName(18); 编译报错
        System.out.println(teacher.getName());//zs
        Student student=new Student();
        student.setAge(18);
        //student.setAge("A"); 编译报错
        System.out.println(student.getAge());//18
        Generic<String> generic=new Generic<>();
        generic.setT("zs");
        System.out.println(generic.getT());//zs
        Generic<Integer> generic1=new Generic<>();
        generic1.setT(18);
        System.out.println(generic1.getT());//18

    }
}
class Teacher{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Student{
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
//泛型类
class Generic<T>{
    private T t;
    public T getT() {
        return t;
    }

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

泛型方法

• 一个泛型方法可以实现多个普通方法

        public class Demo03 {
            //泛型方法
            public static void main(String[] args) {
                Test test=new Test();
                test.show(13);
                test.show("zs");
                test.show(true);
                Generic2 generic2=new Generic2();
                generic2.show(12.5);
                generic2.show("sa");
            }
        }
        class Test{
            //方法的重载
            public void show(String str){
                System.out.println("Hello,"+str);
            }
            public void show(Integer integer){
                System.out.println("Hello,"+integer);
            }
            public void show(boolean b){
                System.out.println("Hello,"+b);
            }
        }
        //泛型类改进
//        class Generic2<T>{
//            public void show(T t){
//                System.out.println("Hello,"+t);
//            }
//
//        }
//泛型方法改进
class  Generic2{
    public<T> void show(T t){
                System.out.println("Hello,"+t);
            }
}

泛型接口

public class Demo04 implements Genetic{
            public static void main(String[] args) {
                Genetic demo04=new Demo04();
                demo04.show("zs");
                demo04.show(18);
                demo04.show(true);
            }

            @Override
            public void show(Object o) {
                System.out.println(o);
            }
        }
        //泛型接口
        interface Genetic<T> {
            public void show(T t);
        }

类型通配符

 public static void main(String[] args) {
        //类型通配符<？>
        List<?> list1=new ArrayList<Object>();
        List<?> list2=new ArrayList<Integer>();
        List<?> list3=new ArrayList<Number>();
        System.out.println("================");
        //类型通配符上限<？extends 类型>
        List<? extends Number> list4=new ArrayList<Integer>();//后面的参数类型必须是extends后参数类型或其子类
        List<? extends Number> list5=new ArrayList<Number>();
        //类型通配符上限<？super 类型>
        List<? super Number> list6=new ArrayList<Number>();//后面的参数类型必须是super后参数类型或其父类
        List<? super Number> list7=new ArrayList<Object>();
    }

可变参数

• 可变参数：又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
• 格式：修饰符 返回值类型 方法名 （数据类型…参数名）{}
• 注意事项：
  • 可变参数的变量其实是一个数组
  • 如果一个方法有多个参数，包含可变参数，可变参数必须放在最后面

 //可变参数
    public static void main(String[] args) {
        sum(1,2);
        sum(2,3,4);
        sum(3,4,5,6);
    }

//    public static void sum(int a,int b){
//        System.out.println("和为:"+(a+b));
//    }
//    public static void sum(int a,int b,int c){
//        System.out.println("和为:"+(a+b+c));
//    }
//    public static void sum(int a,int b,int c,int d){
//        System.out.println("和为:"+(a+b+c+d));
//    }
    //可变参数
    public static void sum(int ...a){
        //a 是一个数组
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum+=a[i];
        }
        System.out.println("和为:"+sum);
    }

可变参数的使用

//可变参数的使用
public class Demo07 {
    public static void main(String[] args) {
        //返回由指定数组支持的固定大小的列表,生成的集合不支持修改集合大小的操作
        List<String> list = Arrays.asList("zs","ls","ww");
        System.out.println(list);//[zs, ls, ww]
        //list.add("xx");//java.lang.UnsupportedOperationException
       // list.remove("zs");//java.lang.UnsupportedOperationException
        String xx = list.set(1, "xx");
        System.out.println(list);//[zs, xx, ww]
    }
}