[置顶] 静态导入 -->心德总结

一、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文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便。