木心

毕竟几人真得鹿，不知终日梦为鱼

导航

JDK5的新特性

本篇博客内容

　　一、自动装箱和自动拆箱

　　二、泛型

　　三、增强for循环

　　四、静态导入

　　五、可变参数

　　六、枚举

 

一、自动装箱和自动拆箱  <=返回目录

 　　java有8种基本数据类型  byte、short、int、long、float、double、char、boolean，

　　对应的有8种包装类型  Byte、Short、Integer、Long、Float、Double、Character、Boolean。

　　所谓自动装箱就是：将基本数据类型的值直接赋值给对应包装类型的变量，java自动进行转换。（自动装箱：基本数据类型 ==> 包装类型）

　　自动拆箱：将包装类型的值赋给基本数据类型的变量，java自动进行转换。（自动拆箱： 包装类型 ==> 基本数据类型）

// 自动装箱
Integer a = 1;
// 执行上面那句代码的时候，系统为我们执行了： 
// Integer a = Integer.valueOf(1); // 装箱 int ==> Integer

// 自动拆箱
int b = a;
// 执行上面那句代码的时候，系统为我们执行了：
// int b = a.intValue(); // 拆箱 Integer ==> int
Integer i = 1;
i += 1; // 先拆 i+1，再装i=i+1
//执行上面那句代码的时候，系统为我们执行了：
i = Integer.valueOf(i.intValue() + 1);

 

二、泛型  <=返回目录

　　泛型（一）泛型类和泛型方法

　　泛型（二）封装工具类CommonUtils-把一个Map转换成指定类型的javabean对象

　　泛型（三）模拟commons-dbutils

　　泛型（四）类型通配符

　　泛型（五）

 

三、增强for循环   <=返回目录

 　　使用增强for时，先对要进行遍历的数据进行判空判断。

package com.oy.test;

public class Test {

    public static void main(String[] args) {
        String[] strArray = new String[] {"a", "b", "c"};
        // printArray(strArray);
        printArray2(strArray);
        
        Integer[] intArray = new Integer[] {1, 2 ,3};
        // printArray(intArray);
        printArray2(intArray);
        
        // printArray种使用增强for的代码不严谨，比如：
        Object[] objArray = null;
        // printArray(objArray); // 报错NullPointerException
        printArray2(objArray);
    }
    
    // 使用增强for的代码不严谨
    private static void printArray(Object[] objArray) {
        for (Object str : objArray) {
            System.out.println(str);
        }
    }
    
    // 改进
    private static void printArray2(Object[] objArray) {
        if (objArray != null && objArray.length > 0) {
            for (Object str : objArray) {
                System.out.println(str);
            }
        }
    }
}

 

四、静态导入  <=返回目录

 　　自定义工具类，包含一个静态方法

package com.oy.util;

import java.util.UUID;
public class Utils {
    // 获取UUID，32位字符串
    public static String uuid() {
        return UUID.randomUUID().toString().replace("-", "").toUpperCase();
    }
}

 

　　静态导入格式: import 包名.类名.方法名;

package com.oy.test;

// import com.oy.util.Utils; // 原来是导入类
// 静态导入是：导入方法
// 静态导入格式: import 包名.类名.方法名;
import static com.oy.util.Utils.uuid;

public class Test {
    public static void main(String[] args) {
        String str = uuid();
        System.out.println(str);
    }
    
}

 

五、可变参数  <=返回目录

 　　可变参数本质是一个数组

public class Test {

    public static void main(String[] args) {
        System.out.println(add(1)); // 1
        System.out.println(add(1, 2)); // 3
        System.out.println(add(1, 2, 3)); // 6
        
        System.out.println(add(new int[] {1, 2})); // 3
        
        // System.out.println(add(1, new int[] {2, 3})); // 报错
    }
    
    private static int add(int... intArray) {
        int sum = 0;
        for (int i : intArray) {
            sum += i;
        }
        return sum;
    }
}

 

　　可变参数只能作为方法的最后一个参数

public class Test {

    public static void main(String[] args) {
        System.out.println(add(1)); // 1
        System.out.println(add(1, 2)); // 3
        System.out.println(add(1, 2, 3)); // 6
        
        System.out.println(add(1, new int[] {2, 3})); // 6
    }
    
    // 可变参数只能作为方法的最后一个参数
    // private static int add(int a, int... intArray, int b) { // 报错
    private static int add(int a, int... intArray) {
        int sum = 0;
        sum += a;
        for (int i : intArray) {
            sum += i;
        }
        return sum;
    }
}

 

六、枚举  <=返回目录

6.1、什么是枚举：

　　将变量的值罗列出来，变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。回想单例设计模式：单例类是一个类只有一个实例。那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。

 

6.2、自己实现枚举类

　　最简单的枚举类

package com.oy.test;

/**
 * @author oy
 * @date 2019年5月26日 下午10:58:44
 * @version 1.0.0
 */
public class Direction {
    public static final Direction FRONT = new Direction();
    public static final Direction BEHIND = new Direction();
    public static final Direction LEFT = new Direction();
    public static final Direction RIGHT = new Direction();
    
    private Direction () {}
}

 

　　添加一个字段

package com.oy.test;

public class Direction2 {
    public static final Direction2 FRONT = new Direction2("front");
    public static final Direction2 BEHIND = new Direction2("behind");
    public static final Direction2 LEFT = new Direction2("left");
    public static final Direction2 RIGHT = new Direction2("right");

    // private Direction2 () {}

    private String name;
    public String getName() {
        return name;
    }

    private Direction2(String name) {
        this.name = name;
    }

}

 

　　 添加一个抽象方法

package com.oy.test;

public abstract class Direction3 {
    public static final Direction3 FRONT = new Direction3("front") {

        @Override
        void show() {
            System.out.println("front show...");
        }

    };
    public static final Direction3 BEHIND = new Direction3("behind") {

        @Override
        void show() {
            System.out.println("behind show...");
        }

    };
    public static final Direction3 LEFT = new Direction3("left") {

        @Override
        void show() {
            System.out.println("left show...");
        }

    };
    public static final Direction3 RIGHT = new Direction3("right") {

        @Override
        void show() {
            System.out.println("right show...");
        }

    };

    // private Direction2 () {}

    private String name;
    public String getName() {
        return name;
    }

    private Direction3(String name) {
        this.name = name;
    }

    abstract void show();
}

　　

　　测试

public class Test {

    public static void main(String[] args) {
        Direction d1 = Direction.FRONT;
        System.out.println(d1);
        
        Direction2 d2 = Direction2.FRONT;
        System.out.println(d2);
        System.out.println(d2.getName()); // front
        
        Direction3 d3 = Direction3.FRONT;
        System.out.println(d3);
        System.out.println(d3.getName()); // front
        d3.show(); // front show...
    }
}

 

6.3、enum

　　enum 的全称为 enumeration， 是 JDK 1.5  中引入的新特性，存放在 java.lang 包中。

　　只有枚举项的枚举类

public enum Direction {
    FRONT, BEHIND, LEFT, RIGHT;
}

　　

　　添加一个字段

public enum Direction {
    FRONT("front"), BEHIND("behind"), LEFT("left"), RIGHT("right");
    
    private String name;
    public String getName() {
        return name;
    }
    
    private Direction(String name) {
        this.name = name;
    }
}

 

　　添加一个抽象方法

public enum Direction {
    FRONT("front") {
        @Override
        void show() {
            System.out.println("front show...");
        }
    }, BEHIND("behind") {
        @Override
        void show() {
            System.out.println("behind show...");
        }
    }, LEFT("left") {
        @Override
        void show() {
            System.out.println("left show...");
        }
    }, RIGHT("right") {
        @Override
        void show() {
            System.out.println("right show...");            
        }
    };
    
    private String name;
    public String getName() {
        return name;
    }
    
    private Direction(String name) {
        this.name = name;
    }
    
    abstract void show();
}

　　

6.4、使用枚举的注意事项

　　定义枚举类要用关键字enum；
　　所有枚举类都是Enum的子类；
　　枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略；
　　枚举类可以有构造器，但必须是private的，它默认的也是private的。枚举项的用法比较特殊：枚举(“”)；
　　枚举类也可以有抽象方法，但是枚举项必须重写该方法；


6.5、枚举在switch语句中的使用

package com.oy.test;

public class Test {

    public static void main(String[] args) {
        print(Direction.RIGHT);
    }

    private static void print(Direction d) {
        switch (d) { // 括号里面是枚举类型
        case FRONT: // 这里不需要Direction.FRONT
            System.out.println(d.getName());
            break;
        case BEHIND:
            System.out.println(d.getName());
            break;
        case LEFT:
            System.out.println(d.getName());
            break;
        case RIGHT:
            System.out.println(d.getName());
            break;
        default:
            break;
        }
    }
}

 

6.6、枚举类的常用方法

　　int compareTo(E o)
　　String name(): 返回次枚举常量的名称
　　int ordinal(): 返回此枚举常量的编号
　　String toString()： 返回此枚举常量的名称
　　<T> T valueOf(Class<T> type, String name)
　　values() : 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

public class Test {
    public static void main(String[] args) {
        // int compareTo(E o)
        Direction d1 = Direction.FRONT; // 编号0
        Direction d2 = Direction.BEHIND; // 编号1
        Direction d3 = Direction.LEFT; // 编号2
        Direction d4 = Direction.RIGHT; // 编号3
        
        System.out.println(d1.compareTo(d1)); // 0-0=0
        System.out.println(d1.compareTo(d2)); // 0-1=-1
        System.out.println(d1.compareTo(d3)); // 0-2=-2
        System.out.println(d1.compareTo(d4)); // 0-3=-3
        
        // String name(): 返回此枚举常量的名称
        System.out.println("d2.name: " + d2.name()); // BEHIND
        
        // int ordinal(): 返回此枚举常量的编号
        System.out.println("d3.ordinal: " + d3.ordinal()); // 2
        
        // String toString()
        System.out.println("d2.toString: " + d2.toString()); // BEHIND
        
        // <T> T valueOf(Class<T> type, String name)
        //java.lang.IllegalArgumentException: No enum constant com.oy.test.Direction.LEFT1
        // Direction d5 = Direction.valueOf("LEFT1");
        Direction d5 = Direction.valueOf("LEFT");
        System.out.println("d5: " + d5);
        
        // 遍历枚举类
        Direction[] directs = Direction.values();
        int i = 0;
        for (Direction dire : directs) {
            System.out.println("directs[" +  (i++) + "]=" + dire.toString());
        }
    }
}

 

　　结果：

0
-1
-2
-3
d2.name: BEHIND
d3.ordinal: 2
d2.toString: BEHIND
d5: LEFT
directs[0]=FRONT
directs[1]=BEHIND
directs[2]=LEFT
directs[3]=RIGHT

 

参考：

　　（1）详解Java的自动装箱与拆箱(Autoboxing and unboxing)

　　（2）java enum(枚举)使用详解 + 总结

 

posted on 2019-05-25 23:21  wenbin_ouyang  阅读(262)  评论(0)  编辑  收藏  举报