java5 新特性

1.静态导入方法

Java代码


package com.java.new_features_jdk5;

/**

*

* 一般我们导入一个类都用 import com.....ClassName;而静态导入是这样：import static com.....ClassName.*;

* 这里的多了个static，还有就是类名ClassName后面多了个 .* ，意思是导入这个类里的静态方法。当然，也可以只导入某个静态方法，只要把 .* 换成静态方法名就行了。

* 然后在这个类中，就可以直接用方法名调用静态方法，而不必用ClassName.方法名 的方式来调用。

* 这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(...);就可以将其写入一个静态方法print(...)，在使用时直接print(...)就可以了。

* 但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便。

* @author yuahan

*

*/

public class _Static_Import {

public static void main(String[] args) {

}

}

2.新增加的for循环

Java代码


package com.java.new_features_jdk5;

import java.util.ArrayList;

import java.util.List;

/**

* 增强的for循环，可以使用在数组和容器中

* @author yuahan

*

*/

public class _For {

@SuppressWarnings("serial")

public static void main(String[] args) {

int[] array = {1,2,3,4,5,6,7,8,9,10};

for(int num : array){

System.out.print(num + " ");

}

System.out.println();

List<Integer> list = new ArrayList<Integer>(){{

this.add(1);

this.add(2);

this.add(3);

this.add(4);

this.add(5);

this.add(6);

this.add(7);

this.add(8);

this.add(9);

this.add(10);

}};

for(int num : list){

System.out.print(num + " ");

}

}

}

3.枚举 Enum

Java代码


package com.java.new_features_jdk5;

/**

*

* 你可以将枚举类型视为特殊的类，因此几乎可以像创建普通类那样创建枚举。

* 枚举类型有附加的特性，有EnumMap和EnumSet两个类。实例化方法中都需要传入枚举类型的类类型，如：

* EnumSet<_Enum> set = EnumSet.noneOf(_Enum.class);

EnumMap<_Enum,String> map = new EnumMap<_Enum,String>(_Enum.class);

枚举可以有自己的构造方法，不过构造方法只能私有，这样外部是不能构造出新的枚举中的实例，而只是调用其中的实例。

* @author yuahan

*

*/

public enum _Enum {

Better(90),

Good(80),

Ok(70),

Bad(60),

Worse;

private int value;

private _Enum() {

this.value = 30;

}

private _Enum(int value) {

this.value = value;

}

public int getValue() {

return value;

}

public void setValue(int value) {

this.value = value;

}

public static _Enum[] getEnumValues(){

return _Enum.values();

}

public static void _ValuesOf(){

// _Enum test = _Enum.valueOf("test");//error

// System.out.println(test);

_Enum Better = _Enum.valueOf("Better");

System.out.println(Better);

}

public static void main(String[] args) {

for(_Enum mark : _Enum.getEnumValues()){

switch(mark){

case Better:

System.out.println(_Enum.Better);

break;

case Good:

System.out.println(_Enum.Good);

break;

case Ok:

System.out.println(_Enum.Ok);

break;

case Bad:

System.out.println(_Enum.Bad);

break;

case Worse:

System.out.println(_Enum.Worse);

break;

}

}

_Enum._ValuesOf();

System.out.println(_Enum.Better.getValue());

}

}

4.反射 Reflect

Java代码


package com.java.new_features_jdk5;

import java.lang.reflect.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.Arrays;

/**

* Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。

* Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性

* JavaDoc 中对每个类和其中的方法有非常详细介绍。主要有：

* Class ------- java.lang

* Package ------- java.lang

*

* Array

* Field

* Method

* Modifier

* Constructor

* @author yuahan

*

*/

public class _Reflect {

private int id;

private String name;

private String[] hobbies;

public _Reflect(){}

public _Reflect(int id){

this.id = id;

}

public _Reflect(int id, String name, String[] hobbies) {

super();

this.id = id;

this.name = name;

this.hobbies = hobbies;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String[] getHobbies() {

return hobbies;

}

public void setHobbies(String[] hobbies) {

this.hobbies = hobbies;

}

public static void main(String[] args) throws Exception{

//---------------------------------basic---------------------------------

System.out.println(_Reflect.class.getSimpleName());

System.out.println(_Reflect.class.getName());

System.out.println(_Reflect.class.getPackage());

System.out.println(_Reflect.class.getSuperclass().getName());

System.out.println(int[].class.getName());

System.out.println(_Reflect[].class.getName());

// //--------------------------------- Method ---------------------------------

Method[] methods = _Reflect.class.getMethods();

for(Method method : methods){

System.out.println(method + ": " +method.getDeclaringClass().getName());

}

// //--------------------------------- isXXX ---------------------------------

System.out.println(Comparable.class.isInterface());

System.out.println(int.class.isPrimitive());

System.out.println(int[].class.isArray());

// //--------------------------------- Modifier 修饰符 ---------------------------------

System.out.println(Modifier.isPublic(_Reflect.class.getModifiers()));

Class<?>[] classes = null;

System.out.println(Modifier.isPublic(_Reflect.class.getMethod("getId",classes).getModifiers()));

//isAssignableFrom isInstance

System.out.println(Number.class.isAssignableFrom(Integer.class));

System.out.println(Number.class.isInstance(1));

//---------------------------------Field---------------------------------

_Reflect _Reflect = new _Reflect();

System.out.println(_Reflect.getId());

System.out.println(_Reflect.getName());

System.out.println(Arrays.toString(_Reflect.getHobbies()));

Field[] fields = _Reflect.class.getDeclaredFields();

for(Field field : fields){

if(field.getType() == int.class){

field.setAccessible(true);

field.setInt(_Reflect, 1);

}else if(field.getType() == String.class){

field.setAccessible(true);

field.set(_Reflect, "1");

}else if(field.getType() == String[].class){

field.setAccessible(true);

field.set(_Reflect, new String[]{"1","1"});

}

}

System.out.println(_Reflect.getId());

System.out.println(_Reflect.getName());

System.out.println(Arrays.toString(_Reflect.getHobbies()));

// //---------------------------------new instance---------------------------------

Constructor<_Reflect> constructor = _Reflect.class.getConstructor(new Class[]{int.class,String.class,String[].class});

_Reflect _reflect = constructor.newInstance(new Object[]{1,"1",new String[]{"1","1"}});

System.out.println(_reflect.getId());

System.out.println(_reflect.getName());

System.out.println(Arrays.toString(_Reflect.getHobbies()));

Class<?> clazz = Class.forName("com.java.new_features_jdk5._Reflect");

_Reflect clazzes = (_Reflect)clazz.newInstance();

System.out.println(clazzes.getId());

System.out.println(clazzes.getName());

System.out.println(Arrays.toString(clazzes.getHobbies()));

//---------------------------------Array---------------------------------

//---------------------------------0---------------------------------

int[] ints0 = (int[])Array.newInstance(int.class, 3);

Array.setInt(ints0, 0, 0);

Array.setInt(ints0, 1, 1);

Array.setInt(ints0, 2, 2);

// //Array.setInt(ints, 3, 3); //java.lang.ArrayIndexOutOfBoundsException

System.out.println(Arrays.toString(ints0));

//---------------------------------1---------------------------------

int[][][] ints3 = (int[][][])Array.newInstance(int.class,2,3,4);

System.out.println(ints3.length);

System.out.println(ints3[0].length);

System.out.println(ints3[0][0].length);

int[][] ints3_1_row0_content = new int[][]{{1,2,3,4},{1,2,3,4},{1,2,3,4}};

int[][] ints3_1_row1_content = new int[][]{{11,22,33,44},{11,22,33,44},{11,22,33,44}};

Array.set(ints3, 0, ints3_1_row0_content);

Array.set(ints3, 1, ints3_1_row1_content);

System.out.println(Arrays.deepToString(ints3));

//---------------------------------2---------------------------------

int[][] ints2 = (int[][])Array.newInstance(int.class, 4,4);

for (int i=0; i<4; i++) {

ints2[i] = (int[]) Array.newInstance(int.class, i + 1);//重新创建每个第一位数组的长度

}

for(int[] array : ints2){

for(int content : array){

System.out.print(content + ",");

}

System.out.println();

}

//---------------------------------4---------------------------------

int[][][] ints4 = new int[1][2][3];

Class<?> clazzz = ints4.getClass();

int dim = 0;

while(clazzz.isArray()){

dim ++;

clazzz = clazzz.getComponentType();

}

System.out.println(dim);

System.out.println(ints4.getClass().isArray());

System.out.println(ints4.getClass().getComponentType().getName());

System.out.println(ints4.getClass().getComponentType().getComponentType().getName());

System.out.println(ints4.getClass().getComponentType().getComponentType().getComponentType().getName());

// System.out.println(ints2.getClass().getComponentType().getComponentType().getComponentType().getComponentType().getName());//java.lang.NullPointerException

}

}

5.注解 Annotation

Java代码


package com.java.new_features_jdk5;

/**

* 比较常用的注释：

* SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。

Deprecated 用"@Deprecated" 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。

Override 表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。

* @author yuahan

*

*/

public class _Annotation {

public static void main(String[] args) {

}

}

6.泛型

Java代码


package com.java.new_features_jdk5;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

/**

* Java语言的泛型类似于C++中的模板. 但是这仅仅是基于表面的现象。Java语言的泛型基本上完全在编译器中实现的，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。 这种实现称为"擦除"（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）

需要注意的地方：

* 1. 泛型不是协变的

协变:Java 语言中的数组是协变的（covariant），也就是说， 如果 Integer 扩展了 Number，那么不仅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求Number[] 的地方完全可以传递或者赋予 Integer[]。

但是，泛型并不是协变的。 如果Number是Integer的超类型，但是，如果需要List<Integer>的时候， 并不容许传递List<Number>，它们并不等价。

不允许的理由很简单，这样会破坏要提供的类型安全泛型。

如：

public static void main(String[] args) {

List<Integer> list=new ArrayList<Integer>();

List<Number> list2=list;//编译错误.

list2.add(new Float(19.0f));

}

2. 延迟构造

因为可以擦除功能，所以List<Integer>和List<String>是同一个类，编译器在编译List<V>的时候，只生成一个类。所以，运行时，不能区分List<Integer>和List<String>(实际上，运行时都是List,类型被擦除了),

用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息，这给泛型容器类和希望创建保护性副本的泛型类提出了难题。

3. 不能用通配符来帮助构造一个类（容器，数组等），因为根本不知道类型，不能确定该构造函数是否存在

class Foo{

public void doSomething(Set<?> set){

Set<?> copy = new HashSet<?>(set);//编译出错，不能用通配符类型的参数调用泛型构造函数

}

}

或者

class ArrayList<V>{

V[] content;

public ArrayList() {

content = new V[10];//编译出错，不能实例化用类型参数表示的类型数组

}

}

不过可以用Object类帮助实现，不过看上去很不舒服。

class Foo{

public void doSomething(Set<?> set){

Set<?> copy = new HashSet<Object>(set);

}

}

或者

class ArrayList<V>{

V[] content;

public ArrayList() {

content = (V[])new Object[10];

}

}

4. 擦除

因为泛型基本上都是在JAVA编译器中而不是运行库中实现的，所以在生成字节码的时候，差不多所有关于泛型类型的类型信息都被“擦除”了， 换句话说，编译器生成的代码与手工编写的不用泛型、检查程序类型安全后进行强制类型转换所得到的代码基本相同。

擦除意味着，一个类不能同时实现 Comparable<String>和Comparable<Number>,因为事实上，两者都在同一个接口中，指定同一个compareTo()方法。

5. 泛型的规则和限制

(1 泛型的参数类型只能是类（ class ）类型，而不能是简单类型。

比如， <int> 是不可使用的。

(2 可以声明多个泛型参数类型，比如 <T, P,Q…> ，同时还可以嵌套泛型，例如： <List<String>>.

(3 泛型 的参数 类 型可以使用 extends 语 句，例如 <T extends superclass> 。

(4 泛型的参数类型可以使用 super 语句，例如 < T super childclass> 。

(5 泛型还可以使用通配符，例如 <? e xtends ArrayList>

* @author yuahan

*

*/

public class _Generic <T> {

public void array2Collection(T[] array, Collection<T> collection){

if(array != null && collection != null){

for(T content : array ){

collection.add(content);

}

}

}

public static void main(String[] args) {

_Generic<Integer> generic = new _Generic<Integer>();

Integer[] array = new Integer[]{1,2,3,4};

List<Integer> list = new ArrayList<Integer>();

generic.array2Collection(array, list);

System.out.println(list);

}

}

7.可变参数(Vararg)

Java代码


package com.java.new_features_jdk5;

/**

*

* 可变参数可以解决代码冗余的问题。

* 如：

* public int max(int i, int j);

* public int max(int i, int j, int k);

* 可以简化成

* public int max(int... num);

*

* 可以将可变参数视为长度可变的数组。不过需要注意以下问题 ：

* 1. 变长参数一定要放在最后面

max(int ... nums, int temp)// error

* 2. 可变参数不能与数组参数并存

max(int[] nums)//error

* @author yuahan

*

*/

public class _Var_Arg {

public static int max(int ... nums){

int max = Integer.MIN_VALUE;

for(int num : nums){

if(num >= max){

max = num;

}

}

return max;

}

public static void main(String[] args) {

int max1 = _Var_Arg.max(1,2,3,4,5);

int max2 = _Var_Arg.max(new int[]{1,2,3,4,5});

System.out.println(max1);

System.out.println(max2);

}

}

8.格式化输入输出
不太喜欢c的输出格式，没有进行尝试。