JAVA5新特性
1>Java在逐渐与C++融合
2>五小点，四大点
一、五小点
1、自动封箱AutoBoxing/自动解封
自动封箱和自动拆箱，它实现了简单类型和封装类型的相互转化时，实现了自动转化。
byte b -128~127
Byte b 在以上数量的基础上多一个null
简单类型和封装类型之间的差别
封装类可以等于null ，避免数字得0时的二义性。
Integer i=null；
int ii=i； //会抛出NullException 异常。相当于 int ii=i.intValue();
Integer i=1； //相当于Integer i=new Integer(1);
i++; // i = new Integer(i.intValue()+1);
在基本数据类型和封装类之间的自动转换
5.0之前
Integer i=new Integer（4）；
int ii= i.intValue();
5.0之后
Integer i=4；
Long l=4.3;
public void m(int i){......}
public void m(Integer i){......}
以上两个函数也叫方法重载
自动封箱解箱只在必要的时候才进行。能不封箱找到匹配的就不封箱。
注意：Integer 和 int 的默认值是不一样的，Integer 是null（对象嘛），int 是0（基本数据类型嘛）；
2、静态引入 StaticImport
使用类中静态方法时不用写类名
System.out.println(Math.round(PI));
可以用以下代码实现：
import static java.lang.System.*; //注意，要写" 类名.* "
import static java.lang.Math.*;
out.println(round(PI));
注意：静态引入的方法不能重名
3、for-each
统一了遍历 数组 和遍历 集合 的方式
for(Object o:list){ //Object o 表示每个元素的类型 ，list 表示要遍历的数组或集合的名字
System.out.println(o); //打印集合或数组中的每个元素
}
4、可变长参数
处理方法重载中，参数类型相同，个数不同的情况
public void m(int... is){.....}
int... is 相当于一个 int[] is
编译器会把给定的参数封装到一个数组中，再传给方法
在一个方法中只能有一个可变长参数，而且，必须放在最后一个参数的位置
5、格式化输入/输出
java.util.Formatter类 对格式的描述
System.out.printf("Hello %s",str); //打印字符串类型的变量，用一个占位符
格式化I/O(Formatted I/O)
java.util.Sacner类可以进行格式化的输入，可以使用控制台输入，结合了BufferedReader和StringTokener的功能。
二、四大点
1、枚举(Enum)
枚举是一个类，并且这个类的对象是现成的，在定义类的时候，即定义好了对象
程序员要使用的时候，只能从中选择，无权创建
enum 枚举名{
枚举值1(..)，枚举值2(..)，.....;
}
（1） 在5.0之前使用模式做出一个面向对象的枚举
final class Season{
public static final Season SPRING=new Season();
public static final Season WINTER=new Season();
public static final Season SUMMER=new Season();
public static final Season AUTUMN=new Season();
private Season(){}
}
完全等价于
enum Season2{
SPRING(..),//枚举值
SUMMER(..),
AUTUMN(..),
WINTER(..)
}
枚举本质上也是一个类，Enum是枚举的父类。
这个类编译以后生成一个.class类
这个类有构造方法，但是是私有的
枚举中的values()方法会返回枚举中的所有枚举值
枚举中可以定义方法和属性，最后的一个枚举值要以分号和类定义分开，枚举中可以定义的构造方法。
枚举不能继承类（本身有父类），但可以实现接口，枚举不能有子类也就是final的，枚举的构造方法是private（私有的）。
枚举中可以定义抽象方法，可以在枚举值的值中实现抽象方法。
枚举值就是枚举的对象，枚举默认是final，枚举值可以隐含的匿名内部类来实现枚举中定义抽象方法。
（2）枚举类(Enumeration Classes)和类一样，具有类所有特性。Season2的父类是java.lang.Enum;
隐含方法： 每个枚举类型都有的方法。
Season2[] ss=Season2.values(); ----获得所有的枚举值
for(Season2 s:ss){
System.out.println(s.name()); ----- 打印枚举值
System.out.println(s.ordinal()); ----- 打印枚举值的编号
}
（3） enum可以switch中使用（不加类名）。
switch( s ){
case SPRING:
…………….
case SUMMER:
…………….
…………..
}
（4）枚举的有参构造
enum Season2{
SPRING(“春”),-------------------------------逗号
SUMMER(“夏”),-----------------------------逗号
AUTUMN(“秋”),-----------------------------逗号
WINTER(“冬”);------------------------------ 分号
private String name;
Season2(String name){ //构造方法必须是私有的,可以不写private,默认就是私有的
this.name=name;
}
String getName(){
return name;
}
}
Season2.SPRING.getName() ---------------------春
（5）枚举中定义的抽象方法，由枚举值实现：
enum Operation{
ADD('+'){
public double calculate(double s1,double s2){
return s1+s2;
}
},
SUBSTRACT('-'){
public double calculate(double s1,double s2){
return s1-s2;
}
},
MULTIPLY('*'){
public double calculate(double s1,double s2){
return s1*s2;
}
}，
DIVIDE('/'){
public double calculate(double s1,double s2){
return s1/s2;
}
}；
char name;
public char getName(){
return this.name;
}
Operation(char name){
this.name=name;
}
public abstract double calculate(double s1 ,double s2);
}
有抽象方法枚举元素必须实现该方法。
Operator[] os = Operator.values();
for(Operator o:os){
System.out.println("8 "+o.name()+" 2="+o.calculate(8,2));
}
for(Operator o:os){
System.out.println("8 "+o.getName()+" 2="+o.calculate(8,2));
}
运行结果：
8 ADD 2=10.0
8 SUBSTRACT 2=6.0
8 MULTIPLY 2=16.0
8 DIVIDE 2=4.0
8 + 2=10.0
8 - 2=6.0
8 * 2=16.0
8 / 2=4.0
2、泛型 (Generic)
(1)增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。
而在java se5.0之前必须在运行期动态进行容器内对象的检查及转换，泛型是编译时概念，运行时没有泛型
减少含糊的容器，可以定义什么类型的数据放入容器
(2)List<Integer> aList = new ArrayList<Integer>();
aList.add(new Integer(1));
// ...
Integer myInteger = aList.get(0); //从集合中得到的元素不必强制类型转换
支持泛型的集合，只能存放制定的类型，或者是指定类型的子类型。
HashMap<String,Float> hm = new HashMap<String,Float>();
不能使用原始类型
GenList<int> nList = new GenList<int>(); //编译错误
编译类型的泛型和运行时类型的泛型一定要一致。没有多态。
List<Dog> as = new ArrayList<Dog>();
List<Animal> l = as; //error Animal与Dog的父子关系不能推导出List<Animal> 与 List<Dog> 之间的父子类关系
（3）泛型的通配符"?"
? 是可以用任意类型替代。
<?> 泛型通配符表示任意类型
<? extends 类型> 表示这个类型是某个类型或接口的子类型。
<? super 类型> 表示这个类型是某个类型的父类型。
import java.util.*;
import static java.lang.System.*;
public class TestTemplate {
public static void main(String[] args) {
List<Object> l1=new ArrayList<Object>();
List<String> l2=new ArrayList<String>();
List<Number> l3=new ArrayList<Number>(); //Number --- Object的子类，所有封装类的父类
List<Integer> l4=new ArrayList<Integer>();
List<Double> l5=new ArrayList<Double>();
print(l1);
print(l2);
print(l3);
print(l4);
print(l5);
}
static void print(List<? extends Number> l){ //所有Number及其子类 l3,l4,l5通过
for(Number o:l){
out.println(o);
}
}
static void print(List<? extends Comparable> l){……} //任何一个实现Comparable接口的类 l2,l4,l5通过
static void print(List<? super Number> l){……} //所有Number及其父类 l1,l3通过
// "?"可以用来代替任何类型, 例如使用通配符来实现print方法。
public static void print(GenList<?> list){……} //表示任何一种泛型
}
（4）泛型方法的定义 --- 相当于方法的模版
把数组拷贝到集合时，数组的类型一定要和集合的泛型相同。
<...>定义泛型，其中的"..."一般用大写字母来代替，也就是泛型的命名，其实，在运行时会根据实际类型替换掉那个泛型。
在方法的修饰符和返回值之间定义泛型
<E> void copyArrayToList(E[] os,List<E> lst){……}
static <E extends Number & Comparable> void copyArrayToList(E[] os,List<E> lst){……} //定义泛型的范围 类在前接口在后
static<E , V extends E> void copyArrayToList(E[] os,List<E> lst){……} //定义多个泛型
"super"只能用在泛型的通配符上，不能用在泛型的定义上
import java.util.*;
public class TestGenerics3 {
public static void main(String[] args) {
List<String> l1=new ArrayList<String>();
List<Number> l2=new ArrayList<Number>();
List<Integer> l3=new ArrayList<Integer>();
List<Double> l4=new ArrayList<Double>();
List<Object> l5=new ArrayList<Object>();
String[] s1=new String[10];
Number[] s2=new Number[10];
Integer[] s3=new Integer[10];
Double[] s4=new Double[10];
Object[] s5=new Object[10];
copyFromArray(l1,s1);
copyFromArray(l2,s2);
copyFromArray(l3,s3);
copyFromArray(l4,s4);
copyFromArray(l5,s5);
}
//把数组的数据导入到集合中
public static <T extends Number&Comparable> void copyFromArray(List<T> l,T[] os){
for(T o:os){
l.add(o);
}
}
}
受限泛型是指类型参数的取值范围是受到限制的. extends关键字不仅仅可以用来声明类的继承关系, 也可以用来声明类型参数(type parameter)的受限关系.
泛型定义的时候，只能使用extends不能使用 super，只能向下，不能向上。
调用时用<?>定义时用 <E>
（5）泛型类的定义
类的静态方法不能使用泛型，因为泛型类是在创建对象的时候产生的。
class MyClass<E>{
public void show(E a){
System.out.println(a);
}
public E get(){
return null;
}
}
受限泛型
class MyClass <E extends Number>{
public void show(E a){
}
}
3、注释(Annotation)
(1)、定义：Annotation描述代码的代码（区：描述代码的文字）
给机器看 给人看的
(2)、注释的分类：
1>、标记注释：没有任何属性的注释。@注释名
2>、单值注释：只有一个属性的注释。@注释名(value=___)
在单值注释中如果只有一个属性且属性名就是value，则“value＝”可以省略。
3>、多值注释：有多个属性的注释。多值注释又叫普通注释。
@注释名（多个属性附值，中间用逗号隔开）
(3)、内置注释：
1>、Override（只能用来注释方法）
表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
2>、Deprecated
用 @Deprecated 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。
3>、SuppressWarnings（该注释无效）
指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。
(4)、自定义注释
自定义注释
public @interface Test{
}
在自定义注释时，要用注释来注释（描述）注释。
@target()，用来描述（注释）注释所能够注释的程序员元素。
@Retention(),描述（注释）注释要保留多久。
注释的属性类型可以是
8种基本类型
String
Enum
Annotation
以及它们的数组
(5)、注释的注释：java.lang. annotation包中======元注释
（1）、Target：指示注释类型所适用的程序元素的种类。
例：@Target(value = {ElementType.METHOD});
说明该注释用来修饰方法。
（2）、Retention：指示注释类型的注释要保留多久。如果注释类型声明中不存在 Retention 注释，则保留策略默认为 RetentionPolicy.CLASS。
例：Retention(value = {RetentionPolicy.xxx}
当x为CLASS表示保留到类文件中，运行时抛弃。
当x为RUNTIME表示运行时仍保留
当x为SOURCE时表示编译后丢弃。
（3）、Documented：指示某一类型的注释将通过 javadoc 和类似的默认工具进行文档化。应使用此类型来注释这些类型的声明：其注释会影响由其客户端注释的元素的使用。
（4）、Inherited：指示注释类型被自动继承。如果在注释类型声
明中存在 Inherited 元注释，并且用户在某一类声明中查询该注释类型，同时该类声明中没有此类型的注释，则将在该类的超类中自动查询该注释类型。
注：在注释中，一个属性既是属性又是方法。
■ 标注：描述代码的文字
描述代码的代码。给编译器看的代码，作用是规范编译器的语法。
class Student{
@Override
public String toString(){
return “student”;
}
}
■ 注释类型 java.lang
1、标记注释（没有属性）
@Override
2、单值注释
@注释名(a="liucy")
@注释名（prameter=10）
int parameter
特例:
@注释名 (value=“134” )
等价于 @注释名 (“134” )
3.普通注释（多值注释）
(key1=value,……)
@__(a="liucy,b=10)
■ @Override 只能放在方法前面
@Deprecated 用于描述过期
@SuppressWarnings 抑制警告
@SuperessWarning({“ddd”,”aaa”,”ccc”}) //JVM还没有实现这个注释
4、Java5.0中的并发
1>、所在的包：Java.util.concurrent
2>、重写线程的原因：
（1）何一个进程的创建（连接）和销毁（释放资源）的过程都 是一个不可忽视的开销。
（2）run方法的缺陷：没有返回值，没有抛例外。
3>、对比1.4和5.0的线程
5.0 1.4
ExecutorService 取代 Thread
Callable Future 取代 Runnable
Lock 取代 Synchronized
SignalAll 取代 notifyAll()
await() 取代 wait()
三个新加的多线程包
Java 5.0里新加入了三个多线程包：java.util.concurrent, java.util.concurrent.atomic,
java.util.concurrent.locks.
java.util.concurrent包含了常用的多线程工具，是新的多线程工具的主体。
这样Java创建线程有 3 种方式：
1. 继承Thread基类。实现run()方法，run()方法就是线程执行流。
启动：
a. 创建Thread子类的对象。
b. 调用该对象的start()方法来启动它。
2. 实现Runnable接口。实现run()方法，run()方法就是线程执行流。
启动：
a. 创建Runnable实现类的对象。
b. 以Runnable实现类的对象作为target参数，创建Thread对象
c. 调用Thread对象的start()方法来启动它。
前面两种方式的线程执行体（也就是run()方法）不能声明抛出异常，也不能有返回值。
3. 实现Callable接口（它是Runnable的增强版）。
实现call()（run()的增强版）方法，call()方法就是线程执行流。
a. 创建Callable实现类的对象。
b. 将Callable实现类的对象包装FutureTask，它代表了call()方法的返回值将来才会返回。
c. 以FutureTask的对象作为target参数，创建Thread对象
d. 调用Thread对象的start()方法来启动它。
实现Runnable接口和实现Callable接口本质相同，
通常我们认为通过实现实现Runnable接口或实现Callable接口的多线程实现方式比较理想。