day22Java-JDK(5、7)新特性演示

博客
Java-(高级)

JDK(5、7)新特性演示

JDK5新特性
	1.自动装箱和拆箱
	2.泛型
	3.增强for循环
	4.静态导入
	5.可变参数
	6.枚举
JDK6新特性(很少见所以不写)
JDK7新特性
	1.二进制字面量
	2.数字字面量可以出现下划线
	3.switch 语句可以用字符串
	4.泛型简化
	5.异常的多个catch合并
	6.try-with-resources 语句

JDK5-自动装箱和拆箱

JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型

注意一个小问题：
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。

代码演示

public class IntegerDemo {
	public static void main(String[] args) {
		// 定义了一个int类型的包装类类型变量i
		// Integer i = new Integer(100);
		Integer ii = 100;
		ii += 200;
		System.out.println("ii:" + ii);

		// 通过反编译后的代码
		// Integer ii = Integer.valueOf(100); //自动装箱
		// ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱
		// System.out.println((new StringBuilder("ii:")).append(ii).toString());

		Integer iii = null;
		// NullPointerException
		if (iii != null) {
			iii += 1000;
			System.out.println(iii);
		}
	}
}

JDK5-泛型

JDK5-增强for循环

格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
 			使用变量即可，该变量就是元素
}

好处：简化了数组和集合的遍历。
弊端： 增强for的目标不能为null。
如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。

代码演示

public class NewJDK5 {
    public static void main(String[] args) {
        //定义字符串数组
        String[] strarr = {"格雷福斯", "影流之主", "至高之拳", "落日狂沙"};

        //使用增强for
        for (String s : strarr) {
            System.out.println(s);
        }
        System.out.println("--------------------------");

        //定义一个集合
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //使用增强for遍历
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("--------------------------");

        ArrayList<String> list2 = null;
        //NullPointerException:报错空指针异常
        // 这个s是我们从list2里面获取出来的，在获取前，应该还要做一个判断(遍历的目标一定不能为null)
        // 说白了，这就是迭代器的功能
        if (list2 != null) {
            for (String s : list2) {
                System.out.println(s);
            }
        }
        System.out.println("--------------------------");

        //证明增强for是来代替迭代器的
        List<String> list3 = new ArrayList<>();

        list3.add("hello");
        list3.add("world");
        list3.add("java");

        //增强for
        for(String s: list3){
            if("world".equals(s)){
 //ConcurrentModificationException:并发修改异常(这个异常是在迭代器出现的,集合修改元素迭代器不知道,就会出现该异常)
                list3.add("javase");
            }
            System.out.println(s);
        }
    }
}

JDK5-静态导入

静态导入：
格式：import static 包名….类名.方法名;
可以直接导入到方法的级别

静态导入的注意事项：
A:方法必须是静态的
B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

代码演示

import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;
public class StaticImport {

    public static void main(String[] args) {
        //复杂的导入方式
        System.out.println(java.lang.Math.abs(-100));
        System.out.println(java.lang.Math.pow(123.45,12.43));
        System.out.println(java.lang.Math.max(20,30));
        System.out.println("-----------------------");

        //简单的导入当时
        System.out.println(Math.abs(-100));
        System.out.println(Math.pow(123.45,12.43));
        System.out.println(Math.max(20,30));
        System.out.println("-----------------------");


        //还有更简单的导入方式(静态导入)
        System.out.println(abs(-100));
        System.out.println(pow(123.45,12.43));
        System.out.println(max(20,30));

    }
}

JDK5-可变参数

可变参数：定义方法的时候不知道该定义多少个参数

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

注意：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个(如果不放在后面,前面的参数都会被可变参包含进去，就会报错)
多参数举例:
public static int getSum(int x,int… y)
调用方法的时候
get(30,40,50,60,70)
默认第一个30对应int x;
后面所有对应int… y

代码演示

public class ArgsDemo {
    public static void main(String[] args) {
        //求两个数的和
        int a = 10;
        int b = 20;
        System.out.println(getSum(a, b));//30

        //求三个数的和
        int c = 30;
        System.out.println(getSum(a,b,c));//60

        //依上类推,不同求和参数变化,就要多写几个方法.怎么写一个方法满足所有需求呢?

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

    }
    //可变参方法
    //底层是数组实现的
    public static int getSum(int... i){
        int sum = 0;

        for(int x:i){
            sum+=x;
        }
        return sum;
    }
   /* public static int getSum(int a, int b) {
        return a+b;
    }

    public static int getSum(int a, int b,int c) {
        return a+b+c;
    }*/
}

写到可变参数,还得要介绍Arrays工具类中的一个方法,就是把数组转为集合(其实就是可变参的应用)
public static List asList(T… a):把数组转成集合

注意事项：
虽然可以把数组转成集合，但是集合的长度不能改变。

public class ArraysDemo {
    public static void main(String[] args) {

        String[] strarr = {"hello","world","java"};
        //List<String>  list = Arrays.asList(strarr);

        //Arrays工具类asList()方法就是可变参应用
        //List<String> list1 = Arrays.asList("hello");
        //List<String> list2 = Arrays.asList("hello","world");
        
        //虽然可以把数组转成集合，但是集合的长度不能改变(意思就是返回的集合可以修改,但是做增删是不可以的)
        List<String> list3 = Arrays.asList("hello","world","java");
        
        //Unsupported Operation Exception:不受支持的操作异常 
        //list3.add("javaee");
        
        //UnsupportedOperationException:不受支持的操作异常 
        //list3.remove(1);
        for(String s:list3){
            System.out.println(s);
        }
    }
}

JDK5-枚举

JDK7-二进制字面量

public class JDK7NEW {

    public static void main(String[] args) {
        // 二进制字面量
        int x = 0b100101;
        System.out.println(x);//37
    }
}

JDK7-数字字面量可以出现下划线

出现下划线其实就是方便看的，在实际开发中没实名特别大的意义。

public class JDK7NEW {
    public static void main(String[] args) {
        // 数字字面量可以出现下划线
        int y = 1_1123_1000;
        // 不能出现在进制标识和数值之间
        int z = 0x111_222;
        // 不能出现在数值开头和结尾
        int a = 0x11_22;
        // 不能出现在小数点旁边
        double d = 12.3_4;
    }
}

JDK7-switch 语句可以用字符串

public class ProxyTest {
    public static void main(String[] args) throws Exception {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //录入数据
        System.out.println("请输入你要判断的字符串：");
        String s = sc.nextLine();

        switch (s) {
            case "hello":
                System.out.println("你输入的是hello");
                break;
            case "world":
                System.out.println("你输入的是world");
                break;
            case "java":
                System.out.println("你输入的是java");
                break;
            default:
                System.out.println("没有找到你输入的数据");
                //break;
        }
    }
}

JDK7-泛型简化

public class JDK7NEW {
    public static void main(String[] args) {
        // 泛型简化
        ArrayList<String> array = new ArrayList<>();
    }
}

JDK7-异常的多个catch合并

JDK7出现了一个新的异常处理方案：
 		try{
  
  		}catch(异常名1 | 异常名2 | ...  变量 ) {
  			...
  		}
  
注意：这个方法虽然简洁，但是也不够好。
  			A:处理方式是一致的。(实际开发中，好多时候可能就是针对同类型的问题，给出同一个处理)类似的异常使用同一种处理方案。
 			B:多个异常间必须是平级关系。

代码演示

public class ExceptionDemo {
    public static void main(String[] args) {
        method();
    }
    public static void method() {
        int a = 10;
        int b = 0;
        int[] arr = {1, 2, 3};

        try {
            System.out.println(a / b);
            System.out.println(arr[3]);
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException ae) {
            System.out.println("出问题了");
        }
        System.out.println("over");
    }
}

JDK7-try-with-resources 语句

try(必须是java.lang.AutoCloseable的子类对象){…}
好处：
		资源自动释放，不需要close()了
		把需要关闭资源的部分都定义在括号就ok了
		主要是流体系的对象是这个接口的子类(看JDK7的API)

代码演示

public class JDK7NEW {
    public static void main(String[] args) {
        // try(必须是java.lang.AutoCloseable的子类对象){…}
        try {
            FileReader fr = new FileReader("a.txt");
            FileWriter fw = new FileWriter("b.txt");
            int ch = 0;
            while ((ch = fr.read()) != -1) {
                fw.write(ch);
            }
            fw.close();
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 改进版的代码
        try (FileReader fr = new FileReader("a.txt");
             FileWriter fw = new FileWriter("b.txt");) {
            int ch = 0;
            while ((ch = fr.read()) != -1) {
                fw.write(ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}