加强eclipse的使用技巧。可变参数。基本数据类型自动装箱和拆箱。枚举。反射。数组反射的应用。ArrayList和HashSet。JavaBean

 /*

eclipse的使用技巧。可变参数。基本数据类型自动装箱和拆箱。枚举。反射。数组反射的应用。ArrayList集合和HashSet集合。
JavaBean。
*/


/*基础加强和JDK1.5新特性.

	基础很重要,就业就看基础掌握的好不好.
	但不能天天学基础,只有通过高级的应用,才能知道基础怎么用.
	就像一年纪的题目,五年纪的人来做能拿满分.

eclipse的使用技巧。
	MyEclipse是eclipse的插件。可以处理j2ee.
	eclipse用javaw.exe运行，不再是java.exe.

	ide-->itegrity development environment （集成开发环境）

	1）Workspace与project
		必须要求：会切换工作间与导入项目。

	IDE开发工具都支持使用工程化方式管理一个项目的程序开发过程。一般
	来说一个相对独立的项目就是一个工程，一个项目中涉及的多个java文件，资源
	文件等用一个工程进行管理。

	点window-->点击Preferences-->Java-->Compiler(编译器)。有java版本。编译时版本。
	Java->Installed JREs(java运行版本) 。运行时版本。

	切换工作间：File->Switch Workspace.选择Others,OK后就新建。

	新建一个工程，普通的java工程，New->Project->java Project->输入工程名字。这时可以选用jre版本。
	在src上，可以选择新建class.会选择新建包名。良好的习惯应该有包名。

	修改工程名字，-->Refactor(重构),新建立的工程配置环境可能改变，如快捷键。

	配置快捷键。window-->Preferences->General-->Keys.输入content.
	选择content Assist-->按下UnbindCommand(解除绑定)。在下面可以Binding，按下Alt键同时按其他。如/键。
	
	2）View与调试debug
	打个断点，程序上选择bebug  as run ，出来调试窗口-->选中变量，点右键->Watch.
	想回去写程序，在右上角选择java视图。
	Window->show view->other可以调试视图。

	3）配置编译和运行java版本。
	点window-->点击Preferences-->Java-->Compiler(编译器)。有java版本。编译时版本。
	Java->Installed JREs(java运行版本) 。运行时版本。
	用高版本的jdk编译出来的程序，用低版本不能运行。
	高版本的jre可以运行低版本jdk编译出来的java程序。
*/
/*
可变参数
	特点:放在未尾。
	三点...位于变量类型和变量名之间时，前后有无空格都可。
	调用可变参数的方法时，编译器为该可变参数隐含创建一个
	数组，在方法体中以数组的形式访问可变参数。
	public static int getSun(int x,int ... args){
		int sum = x;
		for(int i=0;i<args.length;i++){
			sum += args[i];
		}
		return sum;
	}
	面试题。overload与override 的区别.



基本数据类型的自动装箱和拆箱
	自动装箱
	Integer num = 12;
	自动拆箱
	System.out.println(num+10);

	基本数据类型的对象缓存。
	Integer num1 = 12;
	Integer num2 = 12;
	System.out.println(num1==num2);//true
	//基本类型整数在(-128~127)之间，就不创建新对象，大于区间就创建。
	//享元模式。
	Integer num1 = 129;
	Integer num2 = 129;
	System.out.println(num1==num2);//false

	Integer num1 = Integer.valueOf(12);
	Integer num2 = Integer.valueOf(12);
	System.out.println(num1==num2);//true，大于127同样false.
*/
/*
枚举：
	枚举的作用介绍。jdk1.5新特性。
	枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个。否则，
	编译器会报错。这个值在编译时期就被控制。
*/

public abstract class WeekDay1 {

	/**普通类模拟枚举
	 * @param args
	 */
	private WeekDay1(){};//让别人创建不了对象
	public static final WeekDay1 SUN = new WeekDay1() {
		@Override
		public WeekDay1 nextDay() {
			// TODO Auto-generated method stub
			return MON;
		}	
	};
	public static final WeekDay1 MON = new WeekDay1() {
		@Override
		public WeekDay1 nextDay() {
			// TODO Auto-generated method stub
			return SUN;
		}
	};
	
	/*public WeekDay nextDay(){//独立方法去写
		if(this == SUN){
			return MON;
		}else{
			return SUN;
		}
	}*/
	public abstract WeekDay1 nextDay();//让别人实现它。
	
	public String toString(){
		return this == SUN?"SUN":"MON";
	}
}


public class EnumTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		WeekDay1 weekDay = WeekDay1.MON;
		System.out.println(weekDay.nextDay());
		
		WeekDay weekDay2 = WeekDay.FRI;
		System.out.println(weekDay2);
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());
		System.out.println(WeekDay.valueOf("SUN").toString());
		System.out.println(WeekDay.values().length);
	}
	
	public enum WeekDay {
		SUN(1),MON,TUE,WED,THI,FRI,SAT;//分号，所有其他信息都必须列于元素列表之后。
		private WeekDay() {//枚举的构造方法必须私有。
			System.out.println("frist");
		}
		private WeekDay(int day) {
			System.out.println("second");
		}
	}	
}
/*枚举就是一个类，枚举的成员就是静态成员。
	//所有其他信息都必须列于元素列表之后。
	//枚举的构造方法必须私有。
	//枚举的成员相当于一个类的实例对象。对象之间用,号隔开
	SUN(1)相当于创建元素用哪个构造方法。
	SUN，SUN():调用空的。

	实现带抽象方法的枚举.

	如果枚举只有一个成员，那可以了解为单例设计模式。

*/

	public enum TrafficLamp {
		RED(30){

			@Override
			public TrafficLamp nextLamp() {
				// TODO Auto-generated method stub
				return GREEN;
			}
		}，
		GREEN(45){

			@Override
			public TrafficLamp nextLamp() {
				// TODO Auto-generated method stub
				return YELLOW;
			}}，
		YELLOW(5){

			@Override
			public TrafficLamp nextLamp() {
				// TODO Auto-generated method stub
				return RED;
			}
		}，
		public abstract TrafficLamp nextLamp();//抽象方法，那么每个成员都要实现。
		private int time;
		private TrafficLamp(int time){this.time = time;}
	}

/*反射的基石->Class类 jdk1.2
Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class.
	对比。众多的人用一个什么类表示？众多的Java类用一个什么类表示。
	人——>Person		Person p1 = new Person();Person p2 = new Person();
	java类-->Class	Class cls1 = ?;没有构造方法，或方法是私有的，不能直接new.
如何得到各个字节码对应的实例对象(Class类型)
	内存中的每份字节码，就是对应的实例对象。通过对象拿字节码。p1.getClass();
	还有一个方法得到类的字节码，Class类的静态方法:Class.forName("java.lang.String");
如何得到各个字节码对应的实例对象(Class类型)
三种：类名.class,如：System.class
	对象.getClass()如:new Date().getClass();
	Class.forName("类名"),如:Class.forName("java.util.Date");
反射主要用第三种，因为在写程序时还不知道类的名字.

九个预定义Class实例对象。
八个基本类型:boolean,byte,char,short,int,long,float,double.
还有一个void.
	int.class.isPrimitive();//是否是原始类型。
	int.class = Integer.TYPE;
	Integer.TYPE;代表基本类型。
	注意：int.class == Integer.class;//不是一个。

	数组类型的实例变量
	int[].class.isPerimitive();//不是
	Class.isArray();//判断是否是数组。字节码。isArray();

	总之：只要在源程序中出现的类型，都有各自的Class实例对象。例如:int[]...
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(int.class == Integer.class);//不相等
		System.out.println(int.class == Integer.TYPE);//相等
		System.out.println(int[].class.isPrimitive());//不是原始
		System.out.println(int[].class.isArray());//是数组
	}
*/
/*
反射：总之：反射就是把Java类中的各种成分映射成相应的java类。

Constructor 类(构造函数的反射)
	
	得到某个类中的所有的构造方法。
	例子;ConStructor [] cons = Class.forName("java.lang.String").getConstructors();
	得到某一个构造方法：
	ConStructor constructor1 = Class.forName("java.lang.String").getConstructor(StringBuffered.class);
	拿到构造方法后，就可以去构造一个实例对象。
	String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
	//程序编译时不知道是哪个构造方法的，只有运行时才知道。(String).
	//获得方法时要用到类型.class,使用方法时要用到相应类型的对象。
		clazz.newInstance(),运行空构造方法，得到一对象。

		Class clazz = Class.forName("java.lang.String");//拿字节码
		Constructor con = clazz.getConstructor(StringBuffer.class);//拿某一个构造函数
		String str = (String)con.newInstance(new StringBuffer("abc"));//要传对应的sb,不能是("abc")
		System.out.println(str);
*/

import java.lang.reflect.Constructor;
public class RefPointDemo {
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		/*暴力反射私有的构造函数*/
		Class clazz = new RefPoint().getClass();
		Constructor con = clazz.getDeclaredConstructor(int.class,int.class);//Declared是所有的，包括私有。
		con.setAccessible(true);//设为可使用。
		RefPoint refpoint = (RefPoint)con.newInstance(5,6);
		System.out.println(refpoint);
	}
}
 class RefPoint {

	public static int x ;
	private static int y;
	public RefPoint(){}
	private RefPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	public String toString()
	{
		return "x:"+x+",y:"+y;
	}
}
/*
Field类:(成员变量的反射)
	main()...{
		RefPoint ref1 = new RefPoint(3,5);
		Class clazz = ref1.getClass();
		Field fi = clazz.getDeclaredField("y");//私有的成员y就要用这个方法。
		fi.setAccessible(true);//私有的成员y必须为可见
		int yy =(Integer)fi.get(ref1);//这里才具体到哪个对象一个值
		System.out.println(yy);
	}
*/

import java.lang.reflect.Field;
//将任意一个对象中的所有String类型的成员变量所对应字符串内容中的"b"改成"a"。
public class RefFileTest {
	public static void main(String[] args) throws Exception {
		StringSSS sss = new StringSSS();
		show(sss);
		System.out.println(sss);
	}
	public static void show(Object obj) throws Exception{
		Class clazz = obj.getClass();
		Field[] field = clazz.getDeclaredFields();
		for(Field fi:field){
			if(fi.getType()==String.class){//获取成员的类型，同一个类型判断用==.
				String oldstr = (String)fi.get(obj);//如果是String,就传入对象，拿到具体的值
				String newstr = oldstr.replace('b', 'a');//替换b->a.
				fi.set(obj,newstr);//再设置到原对象上。
			}
		}
	}
}
class StringSSS{
	public String str1 = "ball";
	public static  String str2 = "baskball";//静态可以被修改，final修饰后常量不可以。
	public String str3 = "itcast";
	public String toString(){
		return "Str1:"+str1+",Str2:"+str2+",Str3:"+str3;
	}
}
/*以前老师不是讲String一初始化，值就不可以改变吗？
使用反射，没有改变引用地址，也可以改变它的值？？？*/

/*
Method类。
	代表某一类中的成员方法。
	invoke(str1,1)，如果str1为null,那么为静态方法，不需要对象来调用的。
	Method methodChatAt = String.class.getMethod("chatAt",int.class);
	因为一个类中的方法有很多，得到具体的方法用到（方法名，XX），而这个方法有可能被重载，
	所以要用到参数列表的字节码，综合就是(方法名，参数.class);就是得到具体哪个方法。
	再调用这个方法。methodChatAt.invoke(str1,1);str1表示作用的某个对象。
*/
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		String str = "abc";
		Method method = String.class.getMethod("charAt",int.class);//拿到某个方法
		Character ch = (Character)method.invoke(str, 1);//这里可以是(Character),不可以是char???返回的Object不能转变char？
		System.out.println(method.invoke(str, 1));//str表示作用的某个对象,为null时表示为静态方法。不需要对象调用。
		System.out.println(ch+".....");//1.4版本前，invoke(str, 1))写为invoke(str, new Object[]{1}).传入Object数组
	}
	
/*练习，自己写程序，调用人家的main()方法,用反射方式。
	为什么要用反射的方式去调？
	写程序时不知道要执行哪个类的，传入参数才知道要调用哪个。 

	1.5因为兼容1.4，所以传入（null,new String("111","333","222")）这时会打开数组，参数就不对了
	应该改成（null,new Object[]{(new String[]{"111","333","222"})}）,先打好包，解开后还是我想要传的.
	还可以这样做，直接告诉编译器，我就是传给了你一个对象。（null,(Object)new String[]{"111","333","222"}）
	告诉它不要拆了。
*/

public class MethodDemo {

	public static void main(String[] args) throws Exception {	
		//new MethodSSS().main(new String[]{"111","222","333"});//没用反射，我们一般都是这样调用，
		
		//使用反射怎么调用呢？通过参数传入我想要运行哪个类的主函数。
		Method startMethod = Class.forName(args[0]).getMethod("main", String[].class);
		startMethod.invoke(null,(Object)new String[]{"111","222","333"});//数组参数这里要打包。
	
	}
}
class MethodSSS{
	public static void main(String[] args){
		for(int x=0;x<args.length;x++){
			System.out.println(args[x]);
		}
	}
}

/*
数组的反射,
	具有相同的元素类型的同维数组的字节码是同一个。可以相等==.

	基本数据类型不是Object.所以在Arrays.asList()时，基本数据类型转换时，是将整个
	数组转换成的，因为一个基本数据类型，不能转换成Object.如int

	调用Arrays.asList()时，高版本满足低版本，所以jdk1.4时，asList(Object[] obj),参数，不符合
	就返回用1.5方法，变成可变参数asList(T...a);

*/	main(){
		int[] a1 = new int[3];
		int[] a2 = new int[4];
		String[] a3 = new String[]{"1","2","3"};
		int[][] a4 = new int[3][4];
		
		System.out.println(a1.getClass()==a2.getClass());//true
		//System.out.println(a1.getClass()==a3.getClass());//错误
		//System.out.println(a1.getClass()==a4.getClass());//错误
		System.out.println(a1.getClass().getName());//[I
		System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object
		System.out.println(a3.getClass().getSuperclass().getName());//java.lang.Object
		
		Object ab1 = a1;
		Object ab2 = a3;
		Object ab3 = a4;
		Object[] ab4 = a1;//只有这个提示报错，说明int不能转成Object
		Object[] ab6 = a3;
		Object[] ab5 = a4;
		System.out.println(Arrays.asList(a1));//[[I@15ff48b]
		System.out.println(Arrays.asList(a3));//{1,2,3}
	}

//数组反射的应用。
	main(){
		//printObj(a3+"...");
		printObj(a3);//这样可以打印
		printObj("xyz");
		
	}
	public static void printObj(Object obj){
		Class clazz = obj.getClass();
		if(clazz.isArray()){//拿到字节码判断是不是数组
			int len = Array.getLength(obj);//拿到数组长度
			for(int x=0;x<len;x++){
				System.out.println(Array.get(obj, x));//[Ljava.lang.String;@affc70...为什么我的打不出来？？？
														//因为我在上面加了...,printObj(a3+"...");
			}
		}else{
			System.out.println(obj);
		}
	}

/*
	ArrayList集合和HashSet集合，HashCode()分析。
	ArrayList集合，是有顺序的，判断相同与否的依据是:对象的equals()方法，默认比较的是地址值，要想相等，就要重写equals()方法。
	HashSet集合：是无序的，判断的依据是Hashcode(),相同再比较equals().

	HashCode()值，让具备HashCode存储的对象，在内在中对应相应的Hash区域。
	当HashCode依据的算法存储进内存后，就不要修改算法依据的相应的值了。
	因为一改了之后，HashCode()的值也会改变。会内存泄露。
	内存泄露：对象使用后，没有被释放。
	父类引用Collection 分别建立ArrayList,HashSet子类对象,比较它的区别。如元素的大小。
	复写各方法，可发现不同。
*/

/*
	反射的作用->实现框架功能。
	前面已经小小使用一回了，就是输入名字，运行它的主函数。

	框架要解决的核心问题。
	因为在写程序时无法知道要被调用的类名，所以在程序中无法直接用new某个类的实例对象了。
	要用反射方式来做。
*/
public class RefTest {

	/**利用反射实现一个小框架，
	 * 在一个文件中写入内容。config.txt,className = java.util.ArrayList 
	 * @getRealPath();javaweb开发时，可以得到文件的路径。实际开发一定要完整的路径。InputStream("config.txt");
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		InputStream ips = new FileInputStream("config.txt");//读取文件,实际开发要用到绝对路径
		Properties prop = new Properties();
		prop.load(ips);//文件载入内存
		ips.close();
		String className = prop.getProperty("className");//得到文件名字
		Class clazz = Class.forName(className);
		//Constructor con = clazz.getConstructor();//得到构造函数
		//Collection coll = (Collection)con.newInstance();//创建对象
		Collection coll = (Collection)clazz.newInstance();//空的构造方法直接这样。
	}
}
/*
用类加载器的方式管理资源和配置文件。
原理：程序要运行，要加载.class文件，用什么加载这个文件呢？那就是类加载器，
它能够加载.class文件，为什么就不能加载普通文件呢？肯定能。
实例对象.getClass().getClassLoader().getResourceAsStream(cn/itcast/day1/config.txt);注意cn前不加/
文件在src目录下的。java文件，一保存eclipse就会自动编译到bin目录下去，非.java会拷贝过去。
.getResourceAsStream()这个方法只读，又读又写，还是用上面那种。InputStream ips = new FileInputStream("config.txt")。

.getClass().getClassLoader().getResourceAsStream()这种方法加载麻烦，那么.class有没有直接加载的方法呢？
.getClass().getResourceAsStream("resources/文件名")相对路径，当最前面有/时,要用绝对路径，这是用字节码的简单直接方法
加载文件，实际上还是用的类加载器加载实现的。
*/
/*
由内省引出的JavaBean的讲解。
	内省->IntroSpector.-->主要用于对JavaBean进行操作
	什么是JavaBean,特殊的java类，方法按特殊的规定起名。
	例如有个age属性，有方法 int getAge(); void setAge(int age).
	JavaBean也是一个java类，可以进行java类的所有普通操作。
	1.int getAge();没有参数，返回值是int
	2.void setAge(int age)。有参数，返回值是void
	有这二个条件就可以当作JavaBean操作了
*/
class Person
{
	private int x;
	public int getAge()//public
	{
		return x;
	}
	public void setAge(int age)
	{
		this.x = age;
	}
}
/*
上面的Person类当作普通的java类来看，有一个x的成员属性。
Person类当作一个JavaBean 来看，有一个Age属性。
Age-->age如果第二个字母是小的，把第一个字母变成小的。
gettime-->time;
settime-->time
getCPU-->CPU，为了整洁。不是cPU

当JavaBean处理，可以更方便，简单。
	在Java EE开发中，很多环境就要求按照JavaBean方式进行操作。
	JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。
*/

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//对javabean的简单操作，获取属性。
public class JavaBeanDemo {

	public static void main(String[] args) throws Exception {
		Point p1 = new Point(3,5);
		
		String propertyName = "x";
		//普通方式:"x"->"X"->"getX"->MethodGetX-->x获取过程麻烦
		
		//1.得到名称为propertyName的内省。
		Object retVal = getProperty(p1, propertyName);//这里用了方法抽取
		System.out.println(retVal);
		
		Object obj = 7;
		
		setProperty(p1, propertyName, obj);
		 
		 //Object retVal2 = methodGetX.invoke(p1);
		 
		 System.out.println(p1.getX());//当作普通类来获取
		//System.out.println(retVal2);
	}

	private static void setProperty(Object p1, String propertyName, Object obj)
			throws Exception{
		PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,//这是名称
				p1.getClass());//
		Method methodSetX = pd2.getWriteMethod();
		 methodSetX.invoke(p1, obj);
	}

	private static Object getProperty(Object p1, String propertyName)
			throws Exception {
		PropertyDescriptor pd = new PropertyDescriptor(propertyName,//这是名称
				p1.getClass());//得到javaBean属性，得到哪个对象的内省。
		
		//2.下面就可以得到它的读的方法。
		Method methodGetX = pd.getReadMethod();//这里就是得到x的方法。
		
		//3.应用在哪个对象上，没有参数后面就不写.第2，3步就是反射。
		Object retVal = methodGetX.invoke(p1);
		return retVal;//简单方法
	}
}
class Point{
	Point(int x,int y){
		this.x = x;
		this.y = y;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	private int x;
	private int y;
}

/*下面这个内省的复杂方法。为什么要看？程序设计中经常用这种思想。
在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法，
得到的是Beaninfo对象封装了把这个类当作javaBean看的结果信息。
*/	private static Object getProperty(XY xy, String name)
			throws IntrospectionException, IllegalAccessException,
			InvocationTargetException {
		/*
		 * PropertyDescriptor pd = new PropertyDescriptor(name,xy.getClass());
		
		Method methodGetX = pd.getReadMethod();
		Object retVal = methodGetX.invoke(xy);
		return retVal//;简单方法
		*/
		BeanInfo bfs = Introspector.getBeanInfo(xy.getClass());//记住这个Introspector类名
		PropertyDescriptor[] pds = bfs.getPropertyDescriptors();//所有属性信息
		Object retVal = null;
		for(PropertyDescriptor pd:pds){
			if(pd.getName().equals(name)){//名字相同，找到了。
				Method methodGetX = pd.getReadMethod();
				retVal = methodGetX.invoke(xy);
			}
		}
		return retVal;//复杂方法
	}

	/*
	使用工具操作javaBean
先去网上下载工具包JavaBean包，解压。

然后把工具包的.jar文件，加到我们的java工程中来。
局限方法：右击工程名，Build Path-->Configure Build Path-->Libraries->Add  External JARS.
这种方法不会随着工程转换。换了电脑就运行不了。

下面这种方法是放到工程里面转移。
在工程下建立一个目录，lib文件夹，然后把刚才的.jar拷贝进来lib。
然后选择.jar文件，Build Path-->Add to Build Path.前面的图标会变成小奶瓶。

Utils怎么应用呢？
里面有静态方法。
BeanUtils.getProperty(pt1,"x");会有错。没有日志包。
把日志包的.jar也增加到Build Path.再运行。就可以了。
set,get这里都是用字符串操作的，因为web上的数据都是用字符串传送的。

对比另外一个类的静态方法，就是用int操作。如下。
PropertyUtils.setProperty(pt1,"x",9),这个是用属性本身的类型进行操作。

javaBean 可以和Map相互转换。Utils工具有这样的方法。

java7里面，map对象可以这样定义。
Map map = (name:"zxx",age:18);


*/

android培训、 java培训、期待与您交流！