静态导入 -->心德总结

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