16.泛型Generic，JDK1.5增强for，静态导入

ONE.泛型

1.泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法时才去明确的特殊类型
2.格式
<数据类型>
注意：该数据类型只能是引用类型
3.好处
1）把运行时期的问题提前到了编译期间
2）避免了强制类型转换
3）优化了程序设计，解决了黄色警告线问题，使程序更安全
4.泛型的前世今生
1）泛型的由来
2）泛型类
3）泛型方法
4）泛型接口
5）泛型高级通配符
?
? extends E
? super E

TWO.增强for循环

1.是for循环的一种，代码内部的实现其实还是迭代器，用来替代迭代器
2.格式
for（元素类型 元素名称 ： 数组或者Collection的对象）{
使用该元素即可，该元素其实就是Collection中的元素
}
3.好处
简化了数组和集合的遍历
4.弊端
增强for循环的目标不能为null，建议在使用前，先判断是否为null

THREE.静态导入

1.静态导入可以从方法层级导入，但是需要注意的是方法必须是静态的，而且，如果导入的方法和本类中的方法同名，就不好区分，还要加上前缀，所以我们一般不用静态导入，但是要能看懂
2.格式
import static 包名…类名.方法名

package cn.itcast_02;

/*
 * 静态导入：
 * 格式：import static 包名….类名.方法名;
 * 可以直接导入到方法的级别
 * 
 * 静态导入的注意事项：
 *      A:方法必须是静态的
 *      B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
 */
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;

//错误
//import static java.util.ArrayList.add;

public class StaticImportDemo {
    public static void main(String[] args) {
        // System.out.println(java.lang.Math.abs(-100));
        // System.out.println(java.lang.Math.pow(2, 3));
        // System.out.println(java.lang.Math.max(20, 30));
        // 太复杂，我们就引入到import

        // System.out.println(Math.abs(-100));
        // System.out.println(Math.pow(2, 3));
        // System.out.println(Math.max(20, 30));
        // 太复杂，有更简单

//      System.out.println(abs(-100));
        System.out.println(java.lang.Math.abs(-100));
        System.out.println(pow(2, 3));
        System.out.println(max(20, 30));
    }

    public static void abs(String s){
        System.out.println(s);
    }
}

FOUR.可变参数

1.如果我们在写方法的时候，参数个数不明确，就应该定义可变参数
2.格式
修饰符 返回值类型 方法名（数据类型…变量）{}
需要注意的是：
1）该变量其实是一个数组名
2）一个方法有多个参数，并有可变参数时，可变参数要放最后面

package cn.itcast_03;

/*
 * 可变参数：定义方法的时候不知道该定义多少个参数
 * 格式：
 *      修饰符 返回值类型 方法名(数据类型…  变量名){
 * 
 *      }
 * 
 *      注意：
 *          这里的变量其实是一个数组
 *          如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
 */             
public class ArgsDemo {
    public static void main(String[] args) {
        // 2个数据求和
        int a = 10;
        int b = 20;
        int result = sum(a, b);
        System.out.println("result:" + result);

        // 3个数据的求和
        int c = 30;
        result = sum(a, b, c);
        System.out.println("result:" + result);

        // 4个数据的求和
        int d = 30;
        result = sum(a, b, c, d);
        System.out.println("result:" + result);

        // 需求：我要写一个求和的功能，到底是几个数据求和呢，我不太清楚，但是我知道在调用的时候我肯定就知道了
        // 为了解决这个问题，Java就提供了一个东西：可变参数
        result = sum(a, b, c, d, 40);
        System.out.println("result:" + result);

        result = sum(a, b, c, d, 40, 50);
        System.out.println("result:" + result);
    }

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

        int s = 0;

        for(int x : a){
            s +=x;
        }

        return s;
    }

    // public static int sum(int a, int b, int c, int d) {
    // return a + b + c + d;
    // }
    //
    // public static int sum(int a, int b, int c) {
    // return a + b + c;
    // }
    //
    // public static int sum(int a, int b) {
    // return a + b;
    // }
}

FIVE.案例

1.集合的嵌套遍历

package cn.itcast_12;
/*
 * 需求：集合的嵌套遍历，把集合放入一个集合中
 * 例子：一个年级，两个班。每个班都有学生
 */
import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<ArrayList<Student>> alal = new ArrayList<ArrayList<Student>>();
        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("风清扬",33));
        al1.add(new Student("罗海威",27));
        al1.add(new Student("林青霞",22));
        ArrayList<Student> al2 = new ArrayList<Student>();
        al2.add(new Student("黑桐谷歌",17));
        al2.add(new Student("两仪式",19));
        al2.add(new Student("苍崎青子",33));
        alal.add(al1);
        alal.add(al2);
        //这一步遍历，牢记增强for的格式即可，
        //for（数据类型  遍历的元素 ： 集合名）
        for(ArrayList<Student> big : alal) {
            for(Student s : big) {
                System.out.println(s);
            }
        }
    }
}

2.产生10个1-20之间的随机数，要求随机数不能重复

package cn.itcast_12;

import java.util.ArrayList;
import java.util.Random;

/*
 * 获取10个1-20之间的随机数，要求不能重复
 */
public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList<Integer> al = new ArrayList<Integer>();
        Random r = new Random();
        while (al.size() < 10) {
            int x = r.nextInt(20) + 1;
            if (!al.contains(x)) {
                al.add(x);
            }
        }
        for(Integer i : al) {
            System.out.println(i);
        }
    }
}

3.键盘录入多个数据，以0结束，并在控制台输出最大值

package cn.itcast_12;

import java.util.ArrayList;
import java.util.Scanner;

/*
 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据的最大值
 */
public class ArrayListTest3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> arr = new ArrayList<Integer>();
        while (true) {
            int x = sc.nextInt();
            if (x == 0) {
                break;
            } else {
                arr.add(x);
            }

        }
        //集合转数组
        Integer[] arr3 = new Integer[arr.size()];
        arr.toArray(arr3);
        int max = arr3[0];
        for (int i = 1; i < arr3.length; i++) {
            if (arr3[i] > max) {
                max = arr3[i];
            }
        }
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < arr3.length - 1; i++) {
            sb.append(arr3[i]);
            sb.append(",");
        }
        sb.append(arr3[arr3.length - 1]);
        sb.append("]");
        System.out.println(sb + "Max=" + max);
    }

}