java加强之jdk1.5新特性

jdk1.5新特性：

1、静态导入

package jdk_5new;
/**
* 静态导入是jdk1.5新特性，可以直接导入类中的静态方法
*/
import static java.lang.Math.max;
import static java.lang.Math.abs;

public class StaticImport {

public static void main(String[] args) {
System.out.println(Math.max(3,8));
System.out.println(Math.abs(-21));
}

}

2、可变参数(参数个数不确定)

oveload与override(当父类一个方法定义为private，子类中定义一个与之相同的方法，算不算是重写呢？不算！算是一个全新的方法)

package jdk_5new;

/**
* @author Administrator
*
*/
public class VariableParameter {

public static void main(String[] args) {
System.out.println(add(2,3));
System.out.println(add(2,3,4));
}

public static int add(int x, int...args){
int sum = x;
for(int i=0;i<args.length;i++){
sum = sum+args[i];
}
return sum;
}
}

3、增强的for循环

package jdk_5new;

public class ExtendedFor {
public static void main(String[] args) {
System.out.println(add(2, 3));
System.out.println(add(2, 3, 4));
}

public static int add(int x, int... args) {
int sum = x;
for (int arg:args) {
sum = sum + arg;
}
return sum;
}
}

4、自动装箱与拆箱（-128~127 享元模式 flyWeight）

package jdk_5new;

public class AutoBox {
public static void main(String[] args) {
//自动装箱
Integer num = 3;

//自动拆箱
int sum = num +2;
System.out.println(sum);

Integer num1 = 13;
Integer num2 = 13;
Integer num3 = 128;
Integer num4 = 128;

String s1 = new String("abc");
String s2 = new String("abc");

System.out.println("num1 == num2："+(num1 == num2));
System.out.println("num3 == num4："+(num3 == num4));

//s1 == s2 比较的是两个对象的地址
System.out.println("s1 == s2 ："+(s1 == s2));
//这里String的equals方法被重写了，比较的是两个对象的值
System.out.println("s1.equals(s2): "+s1.equals(s2));
}

/**
* 装箱如果数字在-128~127的这些数字，一旦被装箱成Integer对象之后，就会被缓存起来
* 缓冲在一个池里面，到下次如果遇到又要把它封装成对象的时候，先看池子里面有没有，
* 如果有直接从池里面拿出来。因为我觉得小的整数用的频率会非常高，并且经常不会改变。
* 所以就 用一个池存起来，实现重用。
* (享元模式)经常用到的小对象，不会每次都创建！而是放到一个对象池里面。
*/

}

5、枚举

为什么要有枚举？问题：要定义星期几或性别的变量，该怎么定义？枚举就是让某个类型的变量只能为若干个固定值中的一个，否则编译

器就会报错。

package jdk_5new;

public class Enum_1 {
public static void main(String[] args) {

//编译时就发现你输入的值不合法
Week WeekDay = Week.FRI;
//打印一个对象，其实就是打印他的toString

System.out.println(WeekDay);
System.out.println(WeekDay.nextDay());

//通过匿名内部类的方式将众多的if...else分解到不同的方法中。
Week2 week2 = Week2.MON;
System.out.println(week2);
System.out.println(week2.nextDay());
}
}

package jdk_5new;

public class Week {

private Week(){

}

public final static Week SUN = new Week();
public final static Week MON = new Week();
public final static Week TUE = new Week();
public final static Week WEN = new Week();
public final static Week THU = new Week();
public final static Week FRI = new Week();
public final static Week SAT = new Week();

public Week nextDay(){
if(this == SUN){
return MON;
}else if(this == MON){
return TUE;
}else if(this == TUE){
return WEN;
}else if(this == WEN){
return THU;
}else if(this == THU){
return FRI;
}else if(this == FRI){
return SAT;
}else if(this == SAT){
return SUN;
}else
return MON;
}

/**
* 如果没有重写这个toString方法，打印就会有问题。打印Week对象时，会调用这个方法。
* 打印一个对象，就是打印他的toString
*/
public String toString(){
if(this == SUN){
return "今天是星期天！";
}else if(this == MON){
return "今天是星期一！";
}else if(this == TUE){
return "今天是星期二！";
}else if(this == WEN){
return "今天是星期三！";
}else if(this == THU){
return "今天是星期四！";
}else if(this == FRI){
return "今天是星期五！";
}else{
return "今天是星期六！";
}
}
}

6、反射(反射不是jdk1.5的新特性，而是jdk1.2就开始有了)

package jdk_5new;

import java.lang.reflect.*;
import java.util.Arrays;

/**
*
* @author Administrator Class---->代表一种什么样的事物？ Person person1 = new Person();
* Person person2 = new Persion();
*
* Class cls1 = new Class()??? 没有这种方法， Class cls2 = ;
*
* Class 实例对象代表内容里的一份字节码
*
* Class cls1 = Date.class //字节码1 Class cls2 = Person.class //字节码2
*
* getClass(); 得到这个类的字节码 Class.forName("java.lang.String");
*
* 得到一个类的字节码有两种方式 ： 第一种：这个类的字节码已经加载到内存中，此时直接返回就可以了；
* 第二种：虚拟机中还没有这个类的字节码，于是用类加载器去加载。
* 加载后就把这个类的字节码缓存起来，同时用Class.forName()这个方法 返回刚才加载的字节码
*
* 如何得到各个字节码对应的实例对象？(Class类型) 有三种方法： 1、类名.class，如 System.class
* 2、实例名.class，如 new Date().getClass 3、Class.forName("类名")，如
* Class.forName("java.lang.String");
* 反射的时候最常用的是第三种，因为在写源程序的时候，并不知道要创建实例的类的名称，
* 而是在运行的时候才将类的类型传进来。比如从配置文件里面读取。
*
*/
public class ClassDemo {
public static void main(String[] args) throws Exception {

/**
* Class 类的实例表示正在运行的 Java 应用程序中的类和接口。 枚举是一种类，注释是一种接口。每个数组属于被映射为 Class
* 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java
* 类型8个（boolean、byte、char、short、 int、long、float 和 double）和关键字 void 也表示为
* Class 对象。
*/
System.out.println(void.class);
System.out.println(int.class);

/**
* 用各各方式，得到的是内存中同样一份字节码
*/
String str1 = "abc";
Class cls1 = str1.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");

System.out.println(cls1 == cls2);
System.out.println(cls2 == cls3);
System.out.println(cls1 == cls3);

// isPrimitive() 判定指定的 Class 对象是否表示一个基本类型。
System.out.println(cls1.isPrimitive()); // false
System.out.println(int.class.isPrimitive()); // true
System.out.println(int.class == Integer.class); // false
/*
* Object.TYPE 表示所包装的那个基本类型的字节码 static Class<Integer> TYPE 表示基本类型 int 的
* Class 实例。
*/
System.out.println(int.class == Integer.TYPE); // ture
System.out.println(int[].class);
System.out.println(int[].class.isPrimitive());
System.out.println(Array.class);
System.out.println(int[].class.isArray());
// 总之，只要是在程序中出现的类型，都有各自的Class实例对象，例如int[],void

// new String(new StringBuffer("abc"))
Constructor cons1 = String.class.getConstructor(StringBuffer.class);
String str = (String) cons1.newInstance(new StringBuffer("abc"));

// Field 成员变量
ReflectPoint reflectp1 = new ReflectPoint(3, 5);
ReflectPoint reflectp2 = new ReflectPoint(4, 8);
// FieldY不是对象上的变量，而是类上的变量，它去取某个对象上对应的值
Field fieldY = ReflectPoint.class.getField("y");
System.out.println(fieldY.get(reflectp1));
System.out.println(fieldY.get(reflectp2));

// 对私有成员的反射取值
Field fieldX = ReflectPoint.class.getDeclaredField("x");
// 暴力反射
fieldX.setAccessible(true);
System.out.println(fieldX.get(reflectp2));

changeStrValue(reflectp1);
System.out.println(reflectp1);

// 成员方法反射Method
Method methodCharAt = String.class.getMethod("charAt", int.class);

// invoke 列车司机把列车停下来，但并不是司机真正把它停下来。而是列车员踩刹车，
// 给列车发信号，列车自已开启自己的制动系统让自己停下来。所以只有火车自己才更清楚该
// 怎么停下来！String也是，String调用自己的invoke方法截取字符
System.out.println(methodCharAt.invoke(str1, 1));

// 如果第一个参数为null，意味着这个method为静态方法
// System.out.println(methodCharAt.invoke(null,1));

// 1、直接用静态代码的方式调用main
TestArguments.main(new String[] { "111", "222", "333" });
// 2、用反射的方式调用main,为什么要用反射的方式调用?我不知道调用哪个类的main方法，而是以参数传入
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod("main",
String[].class);
// jdk1.4不把数组而是一个参数，而是当成三个参数
mainMethod.invoke(null, new Object[] { new String[] { "aaa", "bbb",
"ccc" } });
// 哥们，我给你的是一个Object，而不是数组，不要给我拆包啊
mainMethod.invoke(null, (Object) new String[] { "aaa", "bbb", "ccc" });

// 数组的Class类型
int[] a1 = new int[3];
int[] a2 = new int[4];
int[][] a3 = new int[2][3];
String[] a4 = new String[3];
String[] a5 = new String[] { "a", "b", "c" };
int[] a6 = new int[] { 1, 2, 3 };
Integer[] a7 = new Integer[] { 1, 2, 3 };
System.out.println(a1.getClass() == a2.getClass());
System.out.println(a3.getClass().getName());
System.out.println(a1.getClass().getSuperclass().getName());

// 打印数组
System.out.println(Arrays.asList(a5));
/*
* 1.4中没有可变参数，asList中只能是对象(Object)类型,于是自动匹配1.5的asList asList(T...a)
* 这种可变参数的形式，虚拟机就会把int数组当成是一个参数
*/
System.out.println(Arrays.asList(a6));
System.out.println(Arrays.asList(a7));

int []a8 = new int[]{1,2,3,4,5};
printObject(a8);
printObject("abc");

//Object里面可以放不同类型的数据哦！
Object[] a9 = new Object[]{"a",1};
System.out.println(a9[0].getClass().getName());
System.out.println(a9[1].getClass().getName());
}

/**
*
* @param obj
* @throws Exception
* 需求：通过反射将一个对象中的成员变量值换掉
*/
public static void changeStrValue(Object obj) throws Exception {
Field[] fields = obj.getClass().getFields();
for (Field field : fields) {
// 相同的Class类型(字节码)都是一份，比较用"=="
if (field.getType() == String.class) {
String oldStr = (String) field.get(obj);
String newStr = oldStr.replace('b', 'a');
field.set(obj, newStr);
}
}
}

// 数组也是一个对象，是一个特殊的对象
public static void printObject(Object obj) {
Class clazz = obj.getClass();
if (clazz.isArray()) {
int len = Array.getLength(obj);
for (int i = 0; i < len; i++) {
System.out.println(Array.get(obj, i));
}
}else{
System.out.println(obj);
}
}

}

// 自己写程序，调用人家的main方法
class TestArguments {
public static void main(String[] args) {
for (String arg : args) {
System.out.println(arg);
}
}
}

7、泛型 泛型在函数体本身不明确其参数类型，而是在创建对象的时候指定参数具体指定的类型。这样就可以在函数内部不用强制类型转换，并且将

可能在运行阶段出现的问题在编译阶段就暴露出来。

package generic;

import java.io.Serializable;
import java.util.*;

/**
* 泛型类型的确定：
* 1、输入参数什么类型就是什么类型
* 2、多个输入参数不同类型时，取多个参数的公共父类的类型
* 3、有返回值（并且有显示接收返回值）泛型变量值以返回值类型为准。
* @author Administrator
*
* @param <T>
*/
public class GenericTest2{
public static void main(String[] args) {
Demo<String> d = new Demo<String>();
// 泛型的真实类型，取他们共同的父类
//类型变量根据输入参数确定的例子
add(3, 5);
add(3.5, 5);
add(3, "abc");
Object obj = "abc";
//接收返回值的是什么类型我就返回什么类型
//泛型变量根据返回值类型确定的例子
String str = autoConvert(obj);
//此时T为Integer
//Integer n = autoConvert(obj);
//此时T没指定返回原始类型
System.out.println(autoConvert(obj).getClass());
}

public static <M> M add(M x, M y) {
return null;
}

public static <T> T autoConvert(Object obj){
return (T)obj;
}

public static <T> void fillArray(T[]a,T obj){
for(int i=0;i<a.length;i++){
a[i] = obj;
}
}

//Collection<Object> != Collection<Integer>
//泛型是不识别父类子类的，严格相等才是相等的。
//这里的?是指Collection里面可以放什么类型的元素
public static void printCollection(Collection <?> collection){
for(Object obj:collection){
System.out.println(obj);
}
}

//任意类型打印，用?也可以,用类型变量<T>也行，但T更灵活
public static <T>void printCollection2(Collection <T> collection,T t){
for(Object obj:collection){
System.out.println(obj);
}
collection.add(t);
}

public static <T> void copy1(Collection<T> c,T []src){

}

public static <T> void copy2(T[] dest,T[] src ){

}

}

// 泛型的类型只能引用类型作为实际参数,而不能用基本类型
class Demo<T extends Serializable> {

}

8、注释 annotation

package annotation;

import java.util.Arrays;

@ItcastAnnotation(value = "abc", arrayAttr = 2, annotationAttr = @MetaAnnotation("zhougang"))
public class AnnotationTest {

@SuppressWarnings("deprecation")
@ItcastAnnotation(value = "abc", arrayAttr = { 0 })
public static void main(String[] args) {
System.runFinalizersOnExit(true);
if (AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class)) {
ItcastAnnotation annotation = (ItcastAnnotation) AnnotationTest.class
.getAnnotation(ItcastAnnotation.class);
ItcastAnnotation annotation1 = (ItcastAnnotation) AnnotationTest.class
.getAnnotation(ItcastAnnotation.class);
// 注解
System.out.println(annotation);
System.out.println(annotation.color());
System.out.println(annotation.value());
System.out.println(annotation.arrayAttr().length);
System.out.println(annotation.lamp().nextLamp().name());
System.out.println(annotation.annotationAttr().value());
}
}
}