JDK1.5新特性

IDE -- integrity development environment

jdk1.5新特性
1.静态导入 import static java.util.Math.*;
2.可变参数
特点：1.只能出现在参数列表的最后
2./.../位于变量类型和变量名之间，前后无空格都可以
3.调用可变参数方法时，jdk隐含创建一个数组,在方法体中
以数组的形式来访问可变参数
overload(重载) vs override(重写)
3.for循环增强
for( type 变量名 : 集合变量名){...}
》迭代变量必须在()中定义
》集合变量可以使数组或实现了iterable接口的集合类
4.自动装箱、拆箱
Integer in = new Integer(3) 1.5之前必须要这样
Integer in = 3; 1.5开始可以这样
System.out.println(in + 4); //拆箱

装箱 -128~127之间的数 在第一次装箱时缓存起来，称为享元模式flyweight
Integer i1 = 12;
Integer i2 = 12;
System.out.println(i1 == i2); //true

Integer i1 = 125;
Integer i2 = 125;
System.out.println(i1 == i2 ); //false
享元模式：对于小的对象，有很多相同的东西，变为一个对象
不同的属性作为方法的参数，称为外部状态
Integer i1 = Integer.valueOf(2);
Integer i2 = Integer.valueOf(2);
System.out.println(i1 == i2); //true
5.枚举
编译阶段可以发现问题；
枚举类中元素列表必须在第一行；静态的成员变量
构造方法必须是私有的private WeekDay(){默认调用这个}  private WeekDay(int day)
public enum WeedDay(){
SUN(1),MON(),TUE,WED,THR,FRI,SAT;
private WeedDay(){}
private WeedDay(int day){}
}
抽象方法
public enum TrafficLamp{
RED{
public TrafficLamp nextLamp(){return GREEN;}
},
GREED(40){return YELLOW;},
YELLOW{};
public abstract TrafficLamp nextLamp();
private int time;
private TrafficLamp(int time){this.time = time;}
}
如果枚举只有一个成员时，就可以作为一种单例的实现方式
6.反射 java1.2就有，非1.5新特性
Class-->是用于描述众多java类的类，它的实例对象就代表字节码

Person p1 = new Person();
class cls1 = Person.class
1.p1.getClass(); 返回字节码的三种方式
2.System.class
3.Class.forName("java.lang.String");返回字节码,分两种,1.已经加载2.未加载

8个基本类型都有对应的class对象，Class cls1 = void.class
内存中只有一份字节码 isPrimitive()是否是基本类型
int.class == Integer.class //false
int.class == Integer.TYPE //true所包装的基本类型的字节码
int[].class.isPrimitive() //false
int[].class.isArray() //判断是否是数组
总之，只要是在源程序中出现的类型，都有各自的Class实例对象

反射就是把java类中的各种成分映射成为相应的java类；
Constructor类代表某个类的一个构造方法
Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
Constructor constructor = Class.forName("StringBuffer").getConstructor();

获得某个特定的构造方法
String.class.getConstructor(StringBuffer.class);//只接受一个参数的构造方法；这个方法利用了新特性可变参数

通常方式：String str = new String(new StringBuffer("abc"));
反射方式: Constructor constructor = String.class.getConstructor(new StringBuffer("abc"));
String str = (String)constructor.newInstance(new StringBuffer("abc"));
反射会导致性能下降，
class.newInstance

ReflectPoint pt1 = new ReflectPoint(3,5);
Field fieldY = pt1.getClass().getField("y");
System.out.println(fieldY.get(pt1));//此get只能返回public 的

Field fieldX = pt1.getClass().getDeclaredField("x"); //返回private的
fieldX.setAccessible(true);   //暴力反射
System.out.println(fieldX.get(pt1));
成员变量的反射案例
public class ReflectPoint{
private int x;
public int y;
public String str1 = "ball";
public String str2 = "basketball";
public String str3 = "itcast";

public ReflectPoint(int x,int y){
super();
this.x = x;
this.y = y;
}
public
}
public class test{
private static void changeStringValue(Object obj) throws Exception{
Field[] fields = obj.getClass().getFiedlds();
for(Field field : fields){
if(field.getType() == String.class){
String oldvalue = (String)field.get(obj);
String newvalue = oldvalue.replace('b','a');
field.set(obj,newvalue);
}
}
}
}
方法的反射
import java.lang.reflect.Method;

public class ReflectTest {

public static void main(String[] args) throws Exception {
String str1 = new String(new StringBuffer("abc"));
//调用str1的charAt(1)
Method methodCharAt = String.class.getMethod("charAt", int.class);
System.out.println(methodCharAt.invoke(str1, 1)); //专家模式//反射方式
System.out.println(str1.charAt(1));//通常方式
}
}

new Object[]{new String("abc"),1}
反射方式执行某个类中的main方法
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"});编译器不把参数当做数组对待，
数组的反射
int [] a1 = new int[3];
int [] a2 = new int[4];
int [][] a3 = new int[2][3];
String [] a4 = new String[]{"a","b","c"};
System.out.println(a1.getClass() == a2.getClass());
//System.out.println(a1.getClass() == a4.getClass());
//System.out.println(a1.getClass() == a3.getClass());
System.out.println(a1.getClass().getName());
System.out.println(a1.getClass().getSuperclass().getName());
System.out.println(a4.getClass().getSuperclass().getName());

Object aObj1 = a1;
Object aObj2 = a4;
//Object aObj3  = a1;
Object[] aObj4 = a3;
Object[] aObj5 = a4;
System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));
System.out.println(Arrays.asList(a4));