黑马程序员_基础与加强上

---------------------- ASP.Net+Android+IOS开发 、 .Net培训 、期待与您交流！ ----------------------

1.JDK5中新增了很多新的java特性，利用这些新语法可以帮助开发人员编写出更加高效、清晰，安全的代码。

静态导入

自动装箱/拆箱

增强for循环

可变参数

枚举

反射

泛型

2.静态导入：

JDK 1.5 增加的静态导入语法用于导入类的某个静态属性或方法。使用静态导入可以简化程序对类静态属性和方法的调用。

语法：

import static 包名.类名.静态属性|静态方法|*

l例如：

import static java.lang.System.out

import static java.lang.Math.*

示例：

package cn.itcast.java.statik;

import org.junit.Test;
import static java.lang.Math.PI;
import static java.lang.Math.pow;
import static java.lang.System.out;

//静态导入
public class Demo1 {
	@Test
	public void test(){
		double R = 2.3;
		out.println("圆的面积:" + PI * pow(R,2));
	}
}

3.自动装箱/拆箱

JDK5.0的语法允许开发人员把一个 基本数据类型直接 赋给对应的包装类变量, 或者赋给 Object 类型的变量，这个过程称之为自动装箱。

自动拆箱与自动装箱与之相反，即把包装类对象直接赋给一个对应的基本类型变量。

在JDK5中，编译器自动将基本类型和对应的包装类型，自动转换  
例如：int<->Integer

典型应用：

List list = new ArrayList();

list.add(1);

int j = (Integer)list.get(0);

基本数据类型
byte ---> Byte
short ---> Short
int ---> Integer
long ---> Long
float ---> Float
double ---> Double
char ---> Character
boolean ---> Boolean

4.增强for循环：

引入增强for循环的原因：在JDK5以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！

因此JDK5中定义了一种新的语法——增强for循环，以简化此类操作。增强for循环只能用在数组、或实现Iterator接口的集合类上

语法格式：                                             

for(变量类型 变量　：需迭代的数组或集合){}

小细节：向集合中取元素时同时加元素，需要使用迭代器来完成

示例：

package cn.itcast.java.addfor;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import org.junit.Test;

//增强for循环
public class Demo1 {
	@Test
	public void test1(){
		int[] is = {1,2,3,4,5};
		for(int i=0;i set = new HashSet();
		set.add(100);
		set.add(200);
		set.add(300);
		Iterator it = set.iterator();
		while(it.hasNext()){
			Integer key = it.next();
			System.out.print(key+"\t");
		}
	}
	@Test
	public void testList(){
		List list = new ArrayList();
		list.add("jack");
		list.add("marry");
		list.add("sisi");
		for(String name : list){
			System.out.print(name+"\t");
		}
	}
	@Test
	public void testMap1(){
		Map map = new HashMap();
		map.put(100,"jack");
		map.put(200,"marry");
		map.put(300,"sisi");
		Set set = map.keySet();
		Iterator it = set.iterator();
		while(it.hasNext()){
			Integer key = it.next();
			String value = map.get(key);
			System.out.println(key+"-"+value);
		}
	}
	@Test
	public void testMap2(){
		Map map = new HashMap();
		map.put(100,"jack");
		map.put(200,"marry");
		map.put(300,"sisi");
		Set> set = map.entrySet();
		Iterator> it = set.iterator();
		while(it.hasNext()){
			Entry entry = it.next();
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+"<->"+value);
		}
	}
}

5.可变参数：

测试JDK中具有可变参数的类Arrays.asList()方法。分别传多个参、传数组，传数组又传参的情况。

注意：传入基本数据类型数组的问题。

从JDK 5开始, Java 允许为方法定义长度可变的参数。语法：

public void foo(int … args){

}

注意事项：

1）参数的个数不确定的
2）可变参数只能放置在参数的最后，即最右边
3）可变参数最少0个，最多1个
4）编译器将可变参数当作一个一维数组来对待

package cn.itcast.java.changeableargs;

//可变参数
public class Demo1 {
	public static void main(String[] args) {
		//show1(new String[]{"jack","marry","sisi","soso"});
		//show2("jack","marry","sisi","soso","berry");
		show3("qq","jack","marry","sisi","soso","berry");
		
	}
	public static void show1(String[] arr) {
		for(String a :arr){
			System.out.print(a+"\t");
		}
	}
	public static void show2(String... arr) {
		for(String a :arr){
			System.out.print(a+"\t");
		}
	}
	public static void show3(String qq,String... arr) {
		System.out.println("第一个参数是：" + qq);
		for(String a :arr){
			System.out.print(a+"\t");
		}
	}
	/*
	public static void show4(String... arr1,String... arr2) {
	}
	*/
}

6.枚举类（Enum）

枚举类具有如下特性：

枚举类也是一种 特殊形式的 Java 类。

枚举类中声明的每一个 枚举值代表枚举类的一个 实例对象。

与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数，但枚举类的 构造函数必须为私有的（这点不难理解）。

枚举类也可以实现接口、或继承抽象类。

JDK5中扩展了switch语句，它除了可以接收int, byte, char, short外，还可以接收一个枚举类型。

若枚举类只有一个枚举值，则可以当作 单态设计模式使用

枚举类常用方法如下：
a)name()：显示枚举值
b)ordinal()：显示枚举值对应的索引，从0开始
c)values()：取得该枚举类对应的所有枚举值，是一个数组
d)valueOf()：判段某个字符串是否属性枚举值之一

示例:

编写一个关于星期几的枚举WeekDay

package cn.itcast.java.enumration5;

//星期枚举类
public enum WeekDay {
	Mon{
		public void show(){
			System.out.println("星期一");
		}	
	},
	Tue{
		public void show(){
			System.out.println("星期二");
		}	
	},
	Wed{
		public void show(){
			System.out.println("星期三");
		}	
	},
	Thu{
		public void show(){
			System.out.println("星期四");
		}	
	},
	Fri{
		public void show(){
			System.out.println("星期五");
		}	
	},
	Sat{
		public void show(){
			System.out.println("星期六");
		}	
	},
	Sun{
		public void show(){
			System.out.println("星期日");
		}	
	};
	public abstract void show();
}

7.泛型： 一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。之前我们放入集合的对象都定义为Object，在取出的时候进行强制类型的转换。而在JDK1.5中引入了泛型，它允许指定集合里元素的类型，这样就可以在编译的时候对强制类型转换进行检测。

 其中又包括泛型类和泛型方法，泛型类在声明对象的时候需指明类型，并且类型是一致的。而泛型方法可以被任意类型的对象调用。

泛型方法的类型参数的类型推断：根据调用泛型方法时实际传递的参数类型或返回值的类型来推断：
1.参数列表中只有一处被调用，直接根据调用方法时传递的参数类型或返回值来决定
2.多处对应同一种类型，可以凭感觉推断出来
3.多处对应不同类型，且没有返回值，这时去多个参数的最大交集类型
4.多处对应不同类型，且有返回值类型，优先考虑返回值类型

8.反射：

（1）反射就是把Java类中的各种成分映射成一个个的java对象。例如，一个类有：成员变量，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象。

1)解析一个类的各个部分，形成一个对象。

2)外存中的类，加载到内存中，会形成该对象的Class类，例如：String类，加载到内存中，就是StringClass对象。
3)使用不同的方式，取得同一个类型的字节码对象Class是相同的。
4)通过getXxxxx()只能取得该类public的类型
通过getDeclaredXxxxxx()可以取得该类非public的类型
设置非public类型的可访问性，默认为false，不可访问
c.setAccessible(true); 
5)反射可以反射private/public的构造方法，字段，普通方法
6)在反射main方法时，编译器会将数组自动拆分，取第一个值

（2）如何得到某个class文件对应的class对象。

类名.class

对象.getClass()

Class.forName(“类名”)

（3）Constructor类：

Constructor类的实例对象代表类的一个构造方法。

得到某个类所有的构造方法，例：

Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法，例：     

Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

利用构造方法创建实例对象：

String str = (String)constructor.newInstance(“abc”);

Class类的newInstance()方法也可创建类的实例，其内部工作原理是先得无参的构造方法，再用构造方法创建实例对象。

String obj =(String)Class.forName("java.lang.String").newInstance();

（4）Method类:

Method类代表某个类中的一个成员方法

得到类中的某一个方法：

例子：     Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式： System.out.println(charAt.invoke(str, 1)); 

（5）反射类的属性

Field field = clazz.getField(fieldName);

field.setAccessible(true);//设置为可访问

filed.setObject(value);          //设置值

Object value = field.get(clazz);      //获得值

Object staticValue = filed.get(Class);     //获得静态值

示例：加载属性文件

public class Demo6 {
	public static void main(String[] args) throws Exception {
		
		//加载属性文件，取得类名的方法名
		Properties props = new Properties();
		InputStream is = new FileInputStream("src/cn/itcast/java/reflect/class.properties");
		props.load(is);
		String className = props.getProperty("className").trim();
		String methodName = props.getProperty("methodName").trim();
		
		//通过反射，执行该类的方法
		Class c = Class.forName(className);
		Constructor con = c.getConstructor(null);
		Method m = c.getDeclaredMethod(methodName,null);
		m.setAccessible(true);
		m.invoke(con.newInstance(null),null);
		
	}
}

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------