静态导入 -->心德总结

一、JavaSe加强主要讲的是JDK 5.0新特性（有助于编写更加清晰，精悍，安全的代码。）

新特性包括：

1、静态导入

2、自动装包/拆包

3、for-each循环

4、可变参数

5、枚举

6、泛型

7、元数据

二、静态导入

1、静态导入语法用于导入指定类的某个静态属性值(方法)或全部静态属性值(方法)

2、语法：Importstatic
包名.类名.静态属性|静态方法|*（*代表所有）

3、导入语句使用import static
语句

1）导入指定类的单个静态属性:import static java.lang.System.out

2）、导入指定类静态方法: import staticjava.lang.Math.max

3）、导入指定类全部静态属性和方法: import static java.lang.Math

三、自动装箱/拆箱

1、自动装箱(autoboxing)：把一个基本数据类型直接赋给对应的包装类变量,
或者赋给 Object 变量

2、自动拆箱：把包装类对象直接赋给一个对应的基本类型变量

例子：

int m=9;

Integer n=m;（自动装箱）

int k=n;（自动拆箱）

3、典型应用：

Listlist = new ArrayList();

list.add(1);

//取出值

intj = (Integer)list.get(0);

4、代码说明：

package com.hbsi.base;
importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;
publicclass Demo2 {
/**
* @param args
*/
publicstaticvoid main(String[] args) {
//应用
List list=new
ArrayList();
list.add(1);
//list.add(new Integer(1));
list.add(2);
list.add(3);
//获取迭代器
Iterator it=list.iterator();
//遍历元素
while(it.hasNext()){
//it.next()取出的是对象
int num=(Integer)it.next();
//输出
System.out.println(num);
}
}
}
增强for循环

1、使用原因：在JDK5以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！因此JDK5中定义了一种新的语法——增强for循环，以简化此类操作。

2、增强for循环只能用在数组、或实现Iterator接口的集合类上。

3、使用 foreach
循环遍历数组和集合元素时,
无须获得数组和集合长度, 无须根据索引来访问数组元素和集合元素,
foreach 循环自动遍历数组和集合的每个元素

4、语法格式：

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


for(type varName : array | collection){

//varName
自动迭代访问每一个元素

}

5、增强for循环遍历数组集合代码说明：

1）普通遍历

publicvoid testArr(){
//定义数组
String[] name={"aa","bb","cc"};
//遍历数组
for(String str:name){
System.out.println(str);
}

}

2)如果数组中放的是类的类型对象：

需先编写java bean文件：

package com.hbsi.base;
publicclass Person {
private String
name;
privateintage;

//构造方法
public
Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
returnname;
}
publicvoid setName(String name) {
this.name = name;
}
publicint getAge() {
returnage;
}
publicvoid setAge(int age) {
this.age = age;
}
}
编写person类生成一个数组放person对象，数组是person类型的
publicvoid testArr1(){
//定义person类型的数组
Person[] persons=new Person[3];
persons[0]=new Person("张1",34);
persons[1]=new Person("张2",24);
persons[2]=new Person("张3",31);
//遍历元素
for(Person p:persons){
System.out.println(p.getName()+".."+p.getAge());
}
}
3)遍历集合（没有使用泛型）
publicvoid test3(){
List<String> list=new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for(Object
str:list){
System.out.println(str);
}
}
4）遍历集合，使用泛型
List<String>list=new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for(String
str:list){
System.out.println(str);
}
5）遍历集合，List中放置的javaBean
List<Person>List=new ArrayList();
List.add(newPerson(“aa”,23));
List.add(newPerson(“bb”,24));
List.add(newPerson(“cc”,25));
For(Personp:list)
{
System.out.println(p.getName()+” ”p.getAge());
}
6、遍历映射的元素
public void testMap(){
Map map=new
LinkedHashMap();
map.put("1","aaa");
map.put("2","bbb");
map.put("3","ccc");
1、//通过map.keySet()把键值取出，遍历
Set keys=map.keySet();
Iterator it=keys.iterator();
while(it.hasNext()){
String key=(String)it.next();
String value=(String)map.get(key);
System.out.println(key+"="+value);
}
2、//使用map.entrySet()方法
Set set=map.entrySet();
Iterator it=set.iterator();
while(it.hasNext()){
Map.Entry me=(Map.Entry)it.next();
String key=(String)me.getKey();
String value=(String)me.getValue();
System.out.println(key+"="+value);
}
3、//for循环
for(Object obj:map.entrySet()){
Map.Entry me=(Map.Entry)obj;
System.out.println(me.getKey()+"="+me.getValue());
}
可变参数
1、Java
允许定义形参长度可变的参数，从而允许为方法指定数量不确定的形参

2、在定义方法时,
在最后一个形参的类型后增加三点(…, ...位于变量类型和变量名之间，前后有无空格都可以)则表明该形参可以接受多个参数值,
多个参数值被当成数组传入

3、可变形参只能处于形参列表的最后,
所以一个方法最多只能有一个长度可变的形参

4、调用包含一个可变形参的方法时,
可以为该形参传入多个参数或一个数组

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

示例代码：

第一种：

publicint sum(String []args)//(int … args)或(int
a, int… args) {
int sum=0;
for(int i:arrs){
sum +=i;
}
return sum;
}

调用时传值：

1）int sum=sum{1,2,3,4,5};

2）int[] array={1,2,3,4,5};

Sum=sum(array);

6、可变参数的类Arrays.asList()方法。分别传多个参、传数组的情况

多个参数：
List list=Arrays.asList("1","2","3");
System.out.println(list);
传数组：
Integer[] num={1,2,3,4};
List list2=Arrays.asList(num);
System.out.println(list2);
枚举类
1、 使用枚举原因：一些方法在运行时，需要的数据不能是任意的，而必须是一定范围内的值。

2、 实现枚举类：

1）通过 private
将构造器隐藏起来

2）这个类的所有可能实例都使用 public static final
修饰

3）属性不应允许被改动,
所以应该使用 private final 修饰

3、enum
关键字用于定义枚举类

枚举类也是一种特殊形式的Java类。

4、枚举类和普通类的区别：

1）使用 enum
定义的枚举类默认继承了 java.lang.Enum
类

2）枚举类的构造器只能使用 private
访问控制符

3）枚举类的所有实例必须在枚举类中显式列出(,
分隔 ; 结尾).
列出的实例系统会自动添加public static final
修饰

5、JDK5中扩展了switch语句，它除了可以接收int, byte, char, short外，还可以接收一个枚举类型

6、若枚举只有一个成员,
则可以作为一种单例模式的实现方式

7、枚举类的属性：

1）枚举类对象的属性不应允许被改动,
所以应该使用 privatefinal 修饰

2）枚举类的使用private final
修饰的属性应该在构造器中为其赋值

3）若枚举类显式的定义了带参数的构造器,
则在列出枚举值时也必须对应的传入参数

枚举类常用的方法

8、Java中声明的枚举类，均是java.lang.Enum类的孩子，它继承了Enum类的所有方法。常用方法：

1）name():返回此枚举常量的名称，在其枚举声明中对其进行声明

2）ordinal():返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

3）valueof(Class enumClass, Stringname):返回带指定名称的指定枚举类型的枚举常量。

静态方法：

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