java5 新特性

1.静态导入方法

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循环

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

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

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

package com.java.new_features_jdk5;
/**
* 比较常用的注释：
* SuppressWarnings 指示应该在注释元素（以及包含在该注释元素中的所有程序元素）中取消显示指定的编译器警告。
Deprecated 用"@Deprecated" 注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发出警告。
Override 表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误消息。
* @author yuahan
*
*/
public class _Annotation {
public static void main(String[] args) {
}
}

6.泛型

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)

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的输出格式，没有进行尝试。

巴特西

java5 新特性

最新文章

热门文章