java基础--高薪技术--JDK1.5新特性

一、JDK1.5新特性

1.JDK1.5

(1)装箱和拆箱

A.自动装箱

Integer num = 12; //就是自动把int类型的12 转为Integer类型

B.自动拆箱

System.out.println(num + 10);

C.基本数据类型的对象缓存

Integer num1 = 12;
Integer num2 = 12;		这块相等，<=127都是真的
System.out.println(num1 == num2);

Integer num3 = 129;                这块不相等，因为是对象
Integer num4 = 129;
System.out.println(num3 == num4);

Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12)  ;   这块的道理同上
System.out.println(num5 == num6);

(2)泛型

A.概述

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中非法输入，编译器编译带类型说明的集合时会去掉“类型”信息，使程序运行效率不受影响

B.格式

<数据类型>  

注意：该数据类型只能是引用类型

C.好处

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

b.避免了强制类型转换

c.优化了程序设计，解决了黄色警告线问题，让程序更安全

D.泛型的前世今生

a.泛型的由来

Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题

b.泛型类

/*
 * 泛型类：把泛型定义在类上
 */
public class ObjectTool<T> {
	private T obj;

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}
}

c.泛型方法

/*
 * 泛型方法：把泛型定义在方法上
 */
public class ObjectTool {
	public <T> void show(T t) {
		System.out.println(t);
	}
}

d.泛型接口

/*
 * 泛型接口：把泛型定义在接口上
 */
public interface Inter<T> {
	public abstract void show(T t);
}

e.泛型高级通配符

?:任意类型，如果没有明确，那么就是Object以及任意的Java类了

? extends E:向下限定，E及其子类

? super E:向上限定，E极其父类

E.我们在哪里使用呢?

一般是在集合中使用

(3)增强for

A.语法

for(type 变量名：集合变量名){...}

B.注意事项

a.迭代变量必须在()中定义

b.集合变量可以是数组或者实现了Iterable接口的集合类

C.举例

	public static int add(int x,int ...args) {
		int sum = x;
		for(int arg:args) {
			sum += arg;
		}
		return sum;
	}

(4)静态导入

A.import语句可以导入一个类或某个包中的所有类

B.import static 语句导入一个类中的某个静态方法或所有静态方法

C.语句举例

import static java.lang.Math.sqrt;
import static java.lang.Math.*;

(5)可变参数

A .特点

a.只能出现在参数列表的最后；

b.  ...位于变量类型和变量名之间，前后有无空格都可以
c.调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体重以数组的形式访问可变参数

B.例子

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(add(1,2,3,5));
		System.out.println(add(2,3,5));		
	}
	
	public static int add(int x,int ...args) {
		int sum = x;
		for(int i=0;i<args.length;i++) {
			sum += args[i];
		}
		return sum;
	}

(6)枚举

A.概述

是指将变量的值一一列出来，变量的值只限于列举出来的值的范围内。举例：一周只有七天，一年只有12个月。

一个类有限个数的实例，才能使枚举类

B.格式

public enum 枚举类名{

枚举项1，枚举项2...;

}

C.注意

a.枚举类可以有构造器，但必须是private的，她默认的也是private的

b.枚举类也可以有抽象方法，但是枚举项必须重写该方法

D.常用方法

int compareTo(E o)

String name()

int ordinal()

String toString()

<T> T valueOf(Class<T> type.String name)

values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

E.例子

/*
 * 通过JDK5提供的枚举来做枚举类
 */
public enum Direction3 {
	FRONT("前") {
		@Override
		public void show() {
			System.out.println("前");
		}
	},
	BEHIND("后") {
		@Override
		public void show() {
			System.out.println("后");
		}
	},
	LEFT("左") {
		@Override
		public void show() {
			System.out.println("左");
		}
	},
	RIGHT("右") {
		@Override
		public void show() {
			System.out.println("右");
		}
	};

	private String name;

	private Direction3(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public abstract void show();
}

二、JDK1.7新特性(了解)

(1)二进制字面量

可以用二进制来表示整数(byte,short,int和long) ；语句简单只要在二进制数组前面加0b或者0B

(2)用_分隔数据

注意：

不能出现在进制标识和数值之间

不能出现在数值开头和结尾

不能出现在小数点旁边

(3)switch语句可以用字符串

(4)泛型推断(菱形泛型)

(5)多catch的使用

就是多个catch合并

(6)自动释放资源的用法(try-with-resources语句)

A.格式：

try(必须是java.lang.AutoCloseable的子类对象){...}

B.好处

资源自动释放，不需要close()

把需要关闭资源的部分都定义在这里就OK了

主要是流体系的对象是这个接口的子类

public class Demo {
	public static void main(String[] args) {
		// 二进制字面量
		int x = 0b100101;
		System.out.println(x);
		// 数字字面量可以出现下划线
		int y = 1_1123_1000;
		// 不能出现在进制标识和数值之间
		int z = 0x111_222;
		// 不能出现在数值开头和结尾
		int a = 0x11_22;
		// 不能出现在小数点旁边
		double d = 12.3_4;
		// switch 语句可以用字符串
		
		// 泛型简化
		ArrayList<String> array = new ArrayList<>();
		// 异常的多个catch合并
		method();
	}

	private static void method() {
		// try-with-resources 语句
		// 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();
		}

		// jdk1.7可用的代码版本
		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();
		}
	}
}