java5.0的新特性
自动装箱和自动拆箱
自动封箱和自动拆箱，它实现了简单类型和封装类型的相互转化时，实现了自动转化。
自动封箱解箱只在必要的时候才进行。还有其它选择就用其它的
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);
在基本数据类型和封装类之间的自动转换
5.0之前
Integer i=new Integer（4）；
int ii= i.intValue();
5.0之后
Integer i=4；
Long l=4.3;
静态引入
静态成员的使用，使用import static 引入静态成员，也就是可以用静态引入是导入包中的某个类的静态成员，在使用时不用再写类名。
很简单的东西，看一个例子：
没有静态导入
Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
有了静态导入
import static java.lang.Math.*;
sqrt(pow(x, 2) + pow(y, 2));
其中import static java.lang.Math.*;就是静态导入的语法，它的意思是导入Math类中的所有static方法和属性。这样我们在使用这些方法和属性时就不必写类名。
需要注意的是默认包无法用静态导入，另外如果导入的类中有重复的方法和属性则需要写出类名，否则编译时无法通过。
增强的for循环
for-each循环实现了对数组和集合的便利的统一，解决遍历数组和遍历集合的不统一。
import java.util.*;
import java.util.Collection;
public class Foreach
{
private Collection<String> c = null;
private String[] belle = new String[4];
public Foreach()
{
belle[0] = "西施";
belle[1] = "王昭君";
belle[2] = "貂禅";
belle[3] = "杨贵妃";
c = Arrays.asList(belle);
}
public void testCollection(){
for (String b : c){
System.out.println("曾经的风化绝代:" + b);
}
}
public void testArray(){
for (String b : belle){
System.out.println("曾经的青史留名:" + b);
}
}
public static void main(String[] args){
Foreach each = new Foreach();
each.testCollection();
each.testArray();
}
}
对于集合类型和数组类型的，我们都可以通过foreach语法来访问它。上面的例子中，以前我们要依次访问数组，挺麻烦：
for (int i = 0; i < belle.length; i++){
String b = belle[i];
System.out.println("曾经的风化绝代:" + b);
}
现在只需下面简单的语句即可：
for (String b : belle){
System.out.println("曾经的青史留名:" + b);
}
对集合的访问效果更明显。以前我们访问集合的代码：
for (Iterator it = c.iterator(); it.hasNext();){
String name = (String) it.next();
System.out.println("曾经的风化绝代:" + name);
}
现在我们只需下面的语句：
for (String b : c){
System.out.println("曾经的风化绝代:" + b);
}
Foreach也不是万能的，它也有以下的缺点：
在以前的代码中,我们可以通过Iterator执行remove操作。
for (Iterator it = c.iterator(); it.hasNext();){
it.remove();
}
但是，在现在的for-each版中，我们无法删除集合包含的对象。你也不能替换对象。
同时，你也不能并行的for-each多个集合。所以，在我们编写代码时，还得看情况而使用它。
可变长的参数
使用条件：只在必要的时候进行。同时有参数为数组，就不能使用变长参数，有变长参数，就不能使用数组，不能共存。一个方法最多只能有一个变长参数，而且是最后一个参数。
5.0之前
public static void main(String[] args){
}
JVM收到数据封装在数组里，然后传入方法
5.0之后
public static void m(String... s){
System.out.println("m(String)" +s);
}
调用m(String… s)
for(String s2:s){
System.out.println(s2);
}
格式化输出
格式化I/O(Formatted I/O)
java.util.Sacner类可以进行格式化的输入，可以使用控制台输入，结合了BufferedReader和StringTokener的功能。
增加了类似C的格式化输入输出，简单的例子：
public class TestFormat{
public static void main(String[] args){
int a = 150000, b = 10;
float c = 5.0101f, d = 3.14f;
System.out.printf("%4d %4d%n", a, b);
System.out.printf("%x %x%n", a, b);
System.out.printf("%3.2f %1.1f%n", c, d);
System.out.printf("%1.3e %1.3e%n", c, d*100);
}
}
输出结果为：
150000 10
249f0 a
5.01 3.1
5.010e+00 3.140e+02
类型安全的枚举
枚举也是一个类型，枚举中的对象只能定义一次并在定义时给其初始化，定义之后不能再改变其值，只能从枚举中选择其一。
enum 枚举名{
枚举值1(..)，枚举值2(..)，.....;
}
在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是枚举的父类。
枚举中的values()方法会返回枚举中的所有枚举值
枚举中可以定义方法和属性，最后的一个枚举值要以分号和类定义分开，枚举中可以定义的构造方法。
枚举可以实现接口，枚举不能有子类也就是final的，枚举的构造方法是private（私有的），枚举中可以定义抽象方法，可以在枚举值的值中实现抽象方法，枚举值就是枚举的对象，枚举默认是final，枚举值可以隐含的匿名内部类来实现枚举中定义抽象方法。
枚举类(Enumeration Classes)和类一样，具有类所有特性。Season2的父类是java.lang.Enum;
隐含方法： Season2[] ss=Season2.values(); 每个枚举类型都有的方法。enum可以switch中使用（不加类名）。
switch( s ){
case SPRING:
…………….
case SUMMER:
…………….
…………..
}
枚举的有参构造
enum Season2{
SPRING(“春”),-------------------------------逗号
SUMMER(“夏”),-------------------------------逗号
AUTUMN(“秋”),-------------------------------逗号
WINTER(“冬”);-------------------------------分号
private String name;
Season2(String name){
this.name=name;
}
String getName(){
return name;
}
}
Season2.SPRING.getName() ---------------------春
枚举的高级用法：
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;
}
}；
public abstract double calculate(double s1 ,double s2);
}
有抽象方法枚举元素必须实现该方法。
java5.0中的泛型
说明
增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。而在java se5.0之前必须在运行期动态进行容器内对象的检查及转换，泛型是编译时概念，运行时没有泛型
减少含糊的容器，可以定义什么类型的数据放入容器
List<Integer> aList = new ArrayList<Integer>();
aList.add(new Integer(1));
// ...
Integer myInteger = aList.get(0);
支持泛型的集合，只能存放制定的类型，或者是指定类型的子类型。
我们可以看到，在这个简单的例子中，我们在定义aList的时候指明了它是一个只接受Integer类型的ArrayList，当我们调用aList.get(0)时，我们已经不再需要先显式的将结果转换成Integer，然后再赋值给myInteger了。而这一步在早先的Java版本中是必须的。也许你在想，在使用Collection时节约一些类型转换就是Java泛型的全部吗？远不止。单就这个例子而言，泛型至少还有一个更大的好处，那就是使用了泛型的容器类变得更加健壮：早先，Collection接口的get()和Iterator接口的next()方法都只能返回Object类型的结果，我们可以把这个结果强制转换成任何Object的子类，而不会有任何编译期的错误，但这显然很可能带来严重的运行期错误，因为在代码中确定从某个Collection中取出的是什么类型的对象完全是调用者自己说了算，而调用者也许并不清楚放进Collection的对象具体是什么类的；就算知道放进去的对象“应该”是什么类，也不能保证放到Collection的对象就一定是那个类的实例。现在有了泛型，只要我们定义的时候指明该Collection接受哪种类型的对象，编译器可以帮我们避免类似的问题溜到产品中。我们在实际工作中其实已经看到了太多的ClassCastException。
用法
声明及实例化泛型类：
HashMap<String,Float> hm = new HashMap<String,Float>();
编译类型的泛型和运行时类型的泛型一定要一致。没有多态。
不能使用原始类型
GenList<int> nList = new GenList<int>(); //编译错误
Java SE
java核心笔记 这是很基础的笔记 我自己整理的
4星 · 超过85%的资源 需积分: 9 162 浏览量
2008-10-16
18:04:10
上传
评论
收藏 49KB RAR 举报 
JavaNote.rar （17个子文件） 
JavaNote 
java13.txt 8KB java10.txt 3KB java03.txt 3KB java16.txt 12KB java09.txt 2KB java07.txt 11KB java14.txt 9KB java02.txt 6KB java15.txt 3KB java04.txt 5KB java06.txt 3KB java05.txt 6KB java17.txt 7KB java01.txt 6KB java12.txt 4KB java11.txt 6KB java08.txt 6KB资源评论
wenggenghong4562012-10-31这个资料挺有用的，不过不是很全面
