jdk1.5新特性

一：静态导入

import导入某一个类，或者导入某个包下的所有的类

import static https://www.360docs.net/doc/bb19017925.html,ng.Math.max;

package com.ambow;

import static https://www.360docs.net/doc/bb19017925.html,ng.Math.max;

public class StaticImport {

public static void main(String[] args){

System.out.println(max(3, 6));

System.out.println(Math.abs(3 - 6));

}

}

import static https://www.360docs.net/doc/bb19017925.html,ng.Math.*;

二：可变参数：

Overload重载

Override重写

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

...位于参数类型和参数名之间，前后有无空格都可以。

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println(add(1,2,2,2,2));

}

public static int add(int x, int...args){

int sum = 0;

sum += x;

/*for(int i : args){

sum += i;

}*/

for(int i=0;i

sum += args[i];

}

return sum;

}

三：For循环增强新式for循环

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

/*for(int i : args){

sum += i;

}*/

四：基本数据类型的自动拆箱与装箱

享源模式

Integer iObj = 3;//自动装箱

System.out.println(iObj + 5);//自动拆箱

Integer i1 = 137; -128~127之间是一样的。用new生成除外

Integer i2 = 137; -128~127之外不一样

String s1 = "abc"; 字符串是一样的用new生成除外

String s2 = "abc"; ==是比较地址 equal是比较对象值

System.out.println(i1 == i2);

System.out.println(i1.equals(i2));

System.out.println("----------------------");

System.out.println(s1 == s2);

System.out.println(s1.equals(s2));

System.out.println("----------------------");

String a1 = new String("abc");

String a2 = new String("abc");

System.out.println(a1 == a2);//地址

System.out.println(a1.equals(a2));//对象值

五：枚举的作用

定值固定的几个值

编译的时候就发现你填写的值不合法

定义一个新的类型，让这个类型定义的变量指向的值只能是固定的那些值

每一个枚举元素都是一个对象

让每个元素自己写自己的nextDay方法

抽象的方法

/**

*采用抽象方法将nextDay()中大量的if else语句分别转移成了一个独立的类*@return

*/

public abstract WeekDay nextDay();

private WeekDay(){

}

/*public static final WeekDay SUN = new WeekDay();

public static final WeekDay MON = new WeekDay();*/

/**

*让这个类的子类来创建实例对象

*这个子类没有名字：匿名类

*/

public static final WeekDay SUN = new WeekDay(){

@Override

public WeekDay nextDay() {

// TODO Auto-generated method stub

return MON;

}

};

public static final WeekDay MON = new WeekDay(){

@Override

public WeekDay nextDay() {

// TODO Auto-generated method stub

return SUN;

}

};

WeekDay_enum weekDay_enum = WeekDay_enum.FRI;

System.out.println("枚举：" + weekDay_enum);//toString方法

System.out.println("枚举：" + weekDay_https://www.360docs.net/doc/bb19017925.html,());//自己的name

System.out.println("枚举：" + weekDay_enum.ordinal());//自己的排行，索引从0开始

System.out.println("静态方法：

---------------------------------------");

System.out.println("枚举：" + weekDay_enum.getClass());

System.out.println("枚举：" + WeekDay_enum.class);

System.out.println("枚举：" + WeekDay_enum.valueOf("SUN"));

System.out.println("枚举：" + WeekDay_enum.values()[0]);

System.out.println("枚举：" + WeekDay_enum.values().length);

}

public enum WeekDay_enum{

SUN,

MON,

TUE,

WED,

THI,

FRI,

SAT;

}

实现带有构造方法的枚举

枚举中的所有其他信息都必须位于元素列表之后，

元素列表之后如果有东西的话，元素列表之后一定要有分号

构造方法必须为私有的

用到枚举类的时候调用构造方法一次性初始化枚举类内的所有枚举对象

public enum WeekDay_enum{

SUN(),

MON(),

TUE(2),调用带有参数的构造方法

WED,

THI,

FRI,

SAT;//元素列表之后如果有东西的话，元素列表之后一定要有分号

private WeekDay_enum(){//枚举中的所有其他信息都必须位于元素列表之后System.out.println("first!");//构造方法必须为私有的

}

private WeekDay_enum(int day){

System.out.println("second!");

}

}

//内部类，与成员方法、成员变量平级，可以有那4个访问修饰符

public enum TrafficLamp {

RED(30) {//RED由TrafficLamp类的一个子类（匿名类）写的，子类的代码是一个大括号，子类的名字不知道

public TrafficLamp nextLamp() {

return GREEN;

}

},

GREEN(45) {

public TrafficLamp nextLamp() {

return YELLOW;

}

},

YELLOW(15) {

public TrafficLamp nextLamp() {

return RED;

}

};

public abstract TrafficLamp nextLamp();

private int time;

private TrafficLamp(int time){

this.time = time;

}

private TrafficLamp(){

}

}

如果枚举只有一个成员，那么你就可以把它当做一种单例。

反射（不是java1.5的新特性是从java1.2开始就有的一个特性）

Class代表一类什么样的事物：

Person类

Animal类

Car类

Class 类的名字类属于哪个包类里面有哪些成员变量哪些方法父类是什么

代表内存里面的一份字节码没有构造方法

当我们在源程序里面用到某个类的时候，首先要从硬盘上把这个类的二进制代码加载到内存里面来，接着用它来创建一个个的对象

每一个份类的字节码就代表Class类的一个实例对象

1)Class cls1 = Person.class;

2)P1.getClass();由对象得到它所属于的（内存中已有，直接找到返回）

3)Class.forName(“com.ambow.Person”);得到这个类的字节码（加载这个类所对应的字节码到虚拟机

或者直接查询这个字节码（要看内存中是否已有），并返回这个字节码）

8个基本的数据类型void 它们都有对应的Class对象

所以有9个预定义的Class对象

基本类型对应的包装类型里面都定义了一个常量，代表这个包装类型所包装的基本类型的字节码。

Void也有void.TYPE

System.out.println("int[]是否是基本类型："+ int[].class.isPrimitive());

System.out.println("int[]是否是数组类型：" +

int[].class.isArray());

System.out.println("int[]与String[]所对应的字节码类型是否相同：" + (String[].class.isPrimitive() == int[].class.isPrimitive()));

反射：java类中的各种成分分别映射成相应的java类

Field Method Constructor Package

各个类的每一个不同的方法都分别对应Method类的一个对象

Constructor

数组类型一致个数固定

Constructor constructor =

String.class.getConstructor(StringBuffer.class);

System.out.println(constructor);

/**

*构造方法的反射调用

*使用constructor去创建一个Constructor所属类String的对象

*/

String string_jz = constructor.newInstance(new StringBuffer("abc"));

System.out.println(string_jz);

System.out.println("所属类：" + constructor.getDeclaringClass());//得到constructor所属类

System.out.println("修饰符：" + constructor.getModifiers());

ReflectPoint pt1 = new ReflectPoint(3,5);

//field_y只代表这个类所对应的字节码字段，没有对应到对象身上

Field field_y = ReflectPoint.class.getField("y");

System.out.println("field_y字段在pt1对象上所对应的值：" +

field_y.getInt(pt1));

//Field field_x = ReflectPoint.class.getField("x");//这里会抛出异常，只能得到可见的字段，这个得不到x字段

//System.out.println("field_x字段在pt1对象上所对应的值：" +

field_x.getInt(pt1));

Field field_x = ReflectPoint.class.getDeclaredField("x");//只要

是类里面声明过的，管它可见还是不可见，都能够得到，但是不一定能够去访问取值field_x.setAccessible(true);//设置可以去取值可以去访问

System.out.println("field_x字段在pt1对象上所对应的值："+ field_x.getInt(pt1));

Method

Method method_charAt = String.class.getMethod("charAt",

int.class);

//在pt1.str1字符串对象上调用charAt这个方法（Method method_charAt），并传递参数1

method_charAt.invoke(pt1.str1, 1);

System.out.println(method_charAt.invoke(pt1.str1, 1));

method_charAt.invoke(null, 1);//不通过方法，是静态的，静态方法的调用不需要对象

System.out.println(aa.getClass().getSuperclass().getName());

Array还可以插队，有顺序

HashSet插入数据之前先判断集合中是否已经有该数据。根据hashcode值进行判断是否相等，集合中是否已经有该数据

数据插入后

在数据插入后，Hashset中参与hashcode值计算的变量尽量不要修改，否者hashcode值变了很容易造成内存泄露，

Collection collections = new HashSet();

ReflectPoint pt1 = new ReflectPoint(3,3);

collections.add(pt1);

pt1.setX(7);

collections.remove(pt1);（没有删掉）

由此可见，java中也有内存泄露！！hashset 流没有关闭输入流输出流链接（系统所关联的资源操作系统的资源）

IntroSpector------主要用于对JavaBean进行操作

如果第二个字母是小写，则把第一个字母设置为小写

如果第二个字母是大写，则第一个字母保持原样！

Beanutils工具包

注解：

@Override

/**

*equals(ReflectPoint obj)不能写成这个，写成这个的话此方法根本得不到调用 * 集合调用的是父类的equals方法equals(Object obj)

*/

public boolean equals(Object obj) {

注解类

应用了注解类的类

对应用了注解类的类进行反射的类

一个注解的生命周期有三个阶段，

source 源文件

class 类文件

runtime 运行时

@Retention(RetentionPolicy.RUNTIME)//元注解元数据元信息信息的信息public@interface ItcastAnnotation {

ArrayList 泛型类型

E称为类型变量或类型参数

ArrayList参数化的类型

ArrayList中的Integer称为类型参数的实例或实际类型参数

<>念typeof

泛型中的问号“？”通配符

限定通配符的上边界：

限定通配符的下边界：

限定通配符总是包含自己

java.util

接口 Map.Entry

Entry定义成了Map内部的一个类完整名称是：Map.Entry

java.util

类 ArrayList

Serializable, Cloneable, Iterable, Collection, List,

RandomAccess

java.util

接口 Set

Collection, Iterable

除了在应用泛型时可以用extends限定符，在定义泛型时也可以用extends限定符。并且还可以用&定义多个限定

还可以对异常采用泛型

通配符方案比泛型更有效

类型推断：

根据调用泛型方法时实际传递的参数类型或返回值的类型来推断

前面是在方法上定义泛型

下面在类上定义泛型：

Create read update delete

CRUD

类加载器

Java虚拟机

Java虚拟机当中有多个类加载器，系统默认提供三个主要的类加载器，每个类加载器负责加载特定位置的类

BootStrap（已经内嵌在java虚拟机内核里面了）

ExtClassLoader C:\Program Files\Java\jdk1.5.0_14\jre\lib\ext *.jar

AppClassLoader C:\Program Files\Java\jdk1.5.0_14\jre\lib rt.jar