黑马程序员—Java提高1（eclipse工具，枚举，反射）

----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------

Myeclipse和eclipse的区别

Myeclipse：是elipse的插件，用于开发javaEE的平台，为其打补丁，扩展其功能，可以开发JavaEE程序即web项目，但是现在Myeclipse也集成了eclipse的功能，可直接使用Myeclipse。

eclipse：是开发java的一款专业的IDE（集成开发环境），以前需要Myeclipse才能开发JavaEE程序，现在的eclipse的版本也可以不用再安装Myeclipse插件，直接可以开发JavaEE项目。

名词

1）IDE：ItegrityDevelopment Enviroment，集成开发环境

2）JavaEE：javaEnterprise Edition：java企业版开发工具。

3）JMS：Java MessageService，Java消息服务，是一个Java平台中关于面向消息中间件的API，用于在两个应用程序间，或分布式系统中，发送消息，进行异步通信。

4）JMX：Java ManagementExtensions，Java管理扩展；是一个为应用程序、设备、系统植入管理功能的框架。

5）JNDI：Java Nameingand Directory Interface：Java命名和目录接口。

6）JDBC：Java DataBase Connectivity：Java数据库连接。

静态导入 importstatic

1、import语句：是导入一个类或某个包中的所有类。

2、import static语句：导入一个类中的某个静态方法或所有静态方法。

增强for循环

1、语法：for(type 变量名 : 集合变量名){statement}

2、注意：迭代变量必须定义在()中，集合变量可以使参数或实现Iterable接口的集合类，变量类型前可加修饰符，如final（可被局部内部类访问到）。

可变参数（方法的重载）

特点：

1、只能出现在参数列表的最后。

2、用…这三个点表示参数可以有很多，且这三个点位于变量类型和变量名之间，前后有无空格皆可。

3、调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

public class VarableParameter {
	public static void main(String [] args){
		System.out.println(add(2, 3));
		System.out.println(add(2, 3, 5));
	}
	public static int add(int x,int... args){
		int sum = x;
		/*for(int i=0;i<args.length;i++){
			sum += args[i];
		}*/
		
		for(int arg : args){
			sum += arg;
		}
		return sum;
	}
}

基本数据类型的自动拆箱与装箱

1、自动装箱：Integer iObj = 3;

2、自动拆箱：iObj + 2;

3、对于基本数据类型的说明：整数在-128 ~ 127之间的数，包装成Integer类型对象，会存入常量池中的缓存，再创建同一个对象的时候，会直接使用前一个已有的值，因为这些小数值使用的频率很高，所以这些数值需要如此的使用以优化内存。

享元模式（flyweight）

如果很多很小的对象，他们有很多相同的属性，那么就可变为一个对象使用，这些属性称为内部状态，还有些不同的属性，作为方法参数植入，这些称为外部状态。这种优化内存，只创建一个对象的模式，称之为享元模式。

应用：

（1）word中输入英文字母，可创建26对象，每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法：如，字母i：i.display(intx,int y)，将高度重复使用的char类型的字母i封装成一个对象使用。

（2）图标：window下的文件夹图标，只哟名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。

（3）valueOf(int x)：Integer中静态方法，讲一个整数转换为Integer，即把基本数据类型变为包装类。

枚举类

1、通过enum定义枚举类，在其中列出所有同类的元素常量值作为子类的实例对象使用。枚举类是一个特殊的类，每个元素都是该类的一个实例对象。

2、用枚举类规定值，如上面的WeekDay类。以后用此类型定义的值只能是这个类中规定好的那些值，若不是这些值，编译器不会通过。

3、好处：在编译时期就会发现错误，表明值不符合，减少了运行时期的错误。

4、如果调用者想打印枚举类中元素的信息，需由编写此类的人定义toString方法。

5、采用抽象方法定义的nextDay可将大量的if else语句转换成了一个个独立的类。

6、如果想在一个类中编写完每个枚举类和测试调用类，那么可将枚举类定义成调用类的内部类。

枚举类是一个class，而且是一个不可被继承的final类，其中的元素都是类静态常量。

public class EnumText {
	public static void main(String[] args) {
		WeekDayTest weekDay = WeekDayTest.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("获取类名：" + weekDay2.getClass());
		//静态方法：
		System.out.println("通过字符串获取对象："+WeekDay.valueOf("SUN"));
		System.out.println("将元素存入数组："+WeekDay.values().length);
		
	}
	//定义星期枚举类
	public enum WeekDay{
		SUN(1),MON,TUE,WED,THI,FRI,SAT;
		private WeekDay(){
			System.out.println("first");
		}
		private WeekDay(int x){
			System.out.println("second");
		}
	}
	//定义交通灯
	public enum TrafficLamp{
		//定义3个元素，即此类的子类，覆写抽象方法
		RED(30){
			public TrafficLamp nextLamp() {
				return GREEN;
		}},
		GREEN(45){
			public TrafficLamp nextLamp() {
				return YELLOW;
		}},
		YELLOW(5) {
			public TrafficLamp nextLamp() {
				return RED;
		}};
		private int time;
		//构造方法
		private TrafficLamp(int time){this.time = time;}
		//抽象方法，转为下个灯
		public abstract TrafficLamp nextLamp();
	}
}

1、构造器：

1）构造器只是在构造枚举值的时候被调用。

2）构造器只有私有private，绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例，这样是合情合理的，因为枚举值是public static final的常量，但是枚举类的方法和数据域是可以被外部访问的。

3）构造器可以有多个，调用哪个即初始化相应的值。

2、所有的枚举类都继承了Enum方法，方法如下：

1）toString() 返回枚举量的名称

2）ordina() 返回枚举值在枚举类中的顺序，按定义的顺序排

3）getClass()  获取对应的类名

静态方法：

1）valueOf(String e)  转为类中对应的对象，即将字符串转为对象

2）values()获取数组，将元素放入一个数组中。

三、注意：

1、元素列表即所有的元素项目，必须放在整个类的最前面。

2、元素列表后要有分号

3、枚举类中的方法为private

4、在元素后跟上()，就可指定要使用的构造方法，含参数。

5、枚举类中的每个元素都是它的一个子类对象，当枚举类中存在abstract方法，须在子类后加{}，并在其中实现此方法。

四、总结：

1、匿名内部类比较常用

2、类的方法返回的类型可以是类的类型

3、类中可定义静态常量，常量的结果就是自己这个类型的实例对象

4、如果枚举只有一个成员，就可以作为一种单利的实现方式，对象只有一个。

Class

Class是Java程序中各个Java类的总称；它是反射的基石，通过Class类来使用反射。

Class和class的区别

1）class：Java中的类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则由此类的实例对象确定，不同的实例对象有不同的属性值。

2）Class：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类，这些类称为Class。例如人对应的是Person类，Java类对应的就是Class。

Class对象的创建和使用

1、创建实例对象：不可用new Class()的方式，因为Class没有这样的构造方法。而是将字节码对象赋值给Class变量。如Class c1 =Person.class。

如Person类，它的字节码：首先要将Person的java文件编译为class文件放于硬盘上，即为二进制代码，再将这些代码加载到内存中，接着用它创建一个个对象。就是把类的字节码加载进内存中，再用此字节码创建一个个对象。当有如Person、Math、Date等等的类，那么这些字节码就是分别的一个Class对象。即Class c2 =Date.class;。

2、获得类的字节码对象：如Class.forName(”java.lang.String”)即获得String.class。得到这个字节码对象有两种情况：

1）此类已经加载进内存：若要得到此类字节码，不需要再加载。

2）此类还未加载进内存：类加载器加载此类后，将字节码缓存起来，forName()方法返回加载进来的字节码。

3、得到各字节码对应的实例对象(Class类型)的方式：

1）类名.class：如System.class，String.class等等

2）对象.class：如new Date().getClass()或者d.getClass()。（Date d = new Date()）

3）Class.forName(“类名”)：如Class.forName(”java.lang.String”)

当获取类名的时候，是不知道此类的名称的，forName(字符串参数)方法中传入字符串型的变量作为对外访问的入口，即传入什么类名就获得什么类名，从而得知相应的类名。

注：forName()是静态方法，是反射中使用的一种方式获取字节码的实例对象。每个类的字节码对象只有唯一的一个，如任何字符串对象，对应唯一的String.clas字节码。

4、九个预定义的Class：

1）包括八种基本类型（byte、short、int、long、float、double、char、boolean）的字节码对象和一种返回值为void类型的void.class。

2）Integer.TYPE是Integer类的一个常量，它代表此包装类型包装的基本类型的字节码，所以和int.class是相等的。

基本数据类型的字节码都可以用与之对应的包装类中的TYPE常量表示

数组类型的Class实例对象，可以用Class.isArray()方法判断是否为数组类型的。

5、总结：只要是在源程序中出现的类型都有各自的Class实例对象，如int[].class、void.class等。

Class类方法

1、static Class forName(String className) 返回与给定字符串名的类或接口的相关联的Class对象。

2、Class getClass() 返回的是Object运行时的类，即返回Class对象即字节码对象

3、Constructor getConstructor() 返回Constructor对象，它反映此Class对象所表示的类的指定公共构造方法。

4、Field getField(String name) 返回一个Field对象，它表示此Class对象所代表的类或接口的指定公共成员字段。

5、Field[] getFields() 返回包含某些Field对象的数组，表示所代表类中的成员字段。

6、Method getMethod(String name,Class… parameterTypes) 返回一个Method对象，它表示的是此Class对象所代表的类的指定公共成员方法。

7、Method[] getMehtods() 返回一个包含某些Method对象的数组，是所代表的的类中的公共成员方法。

8、String getName() 以String形式返回此Class对象所表示的实体名称。

9、String  getSuperclass() 返回此Class所表示的类的超类的名称

10、boolean isArray() 判定此Class对象是否表示一个数组

11、boolean isPrimitive() 判断指定的Class对象是否是一个基本类型。

12、T newInstance() 创建此Class对象所表示的类的一个新实例。

<span style="font-family:Arial;">public static void fuction()throws Exception{
		String str1 = "abc";
		Class cls1 = str1.getClass();
		Class cls2 = String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1 == cls2);//true
		System.out.println(cls1 == cls3);//true
		
		//判断是否为基本类型：isPrimitive()
		System.out.println(cls1.isPrimitive());//false
		System.out.println(int.class == Integer.class);//false
		//Integer.TYPE代表包装类对应的基本数据类型的字节码
		System.out.println(int.class == Integer.TYPE);//true
		System.out.println(int[].class.isPrimitive());//false
		//判断是否为数组类型的
		System.out.println(int[].class.isArray());//true
}
</span>

反射

把Java类中的各种成分映射成相应的Java类。如Class中的每一个方法返回的都是一种类（型），即Method对所有方法抽取成了这个类Method，它的每一个对象（如变量methodObj1）代表了一个方法。

一个类中的组成成分：成员变量、方法、构造函数、包等信息，也用一个个java类来表示（如汽车是一个类，其中的发动机，变速箱等也是对应的一个个类），表示Java类的Class类显然要提供一系列的方法来获取其中的变量、方法、构造函数、修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等。一个类中的每个成员都可用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可得到这些实例对象。

反射中的类

一、Constructor类

1、Constructor代表某个类的构造方法

2、获取构造方法：

1）如何得到摸个类的所有构造方法：如得到String类的所有构造方法

Constructor[] cons = Class.forName(“java.lang.String”).getConstructors()；

2）获取某一个构造方法：

Constructor con =String.class.getConstructor(StringBuffer.class);①

3、创建实例对象：

1）通常方式：String str = new String(new StringBuffer (”abc”));

2）反射方式：String str = (String)con.newInstance(new StringBuffer(“abc”));②

调用获得的方法时要用到上面相同类型的实例对象，即两个StringBuffer()要对应相等。

NewInstance()：构造出一个实例对象，每调用一次就构造一个对象。

注意：上面的两个地方①②都要用到StringBuffer，这必须是一致的。

第①个是指定要带StringBuffer参数类型的构造方法，即所需使用的是含StringBuffer类型的构造方法。

第②个是用这个构造方法创建对象，要传入的参数类型是StringBuffer。

4、Class.newInstance()：创建一个对象，不带参数的构造方法。

		//new String(new StringBuffer("abc"));
		Constructor constructor1 = 
		String.class.getConstructor(StringBuffer.class);
		String str2 =
		 (String)constructor1.newInstance(new StringBuffer("abc"));
		System.out.println(str2);
				
		//Class.newInstrance创建不带参数的构造方法
		String str3 = 
		(String)Class.forName("java.lang.String").newInstance();
		System.out.println("str3:"+str3);

二、Field类

1、Field类代表成员变量（字段）的反射。

	public class ReflectPoint {
		private int x;
		public int y;
	
		public String toString(){
			return str1+";" + str2 + ";" + str3;
		}
	}
	public class FieldTest(){
	ReflectPoint pt1 = new ReflectPoint(3,5);
		//fieldX和fieldY并不是对象身上的变量，而是类上的
		//要用它去取某个对象上的对应的值，传入什么对象，就取相应对象的值。
		Field fieldY = pt1.getClass().getField("y");
		System.out.println(fieldY.get(pt1));
		//获取私有的成员变量
	Field fieldX = pt1.getClass().getDeclaredField("x");
		fieldX.setAccessible(true);
		System.out.println(fieldX.get(pt1));
	}

2、获取成员变量：

如上例子所示：

1）获取公有的成员变量：

getField(String name)和get(变量)

2）获取私有的成员变量：暴力反射

getDeclared(String name)

setAccessible(boolean b)，将b设为true即可

get(变量)

//替换字符 
private static void changeStringValue(Object obj) throws Exception {
	Field[] fields = obj.getClass().getFields();
	for(Field field : fields){
		//此处需要用==比较，因为是同一份字节码对象
		if(field.getType() == String.class){
			String oldValue = (String)field.get(obj);
			String newValue = oldValue.replace('b','a');
			field.set(obj, newValue);
		}
	}
}

三、Method类

1、Method类代表某个类中的一个成员方法。调用某个对象身上的方法，要先得到方法，再针对某个对象调用。

2、专家模式：谁调用这个数据，就是谁在调用它的专家。

如人关门：

调用者：是门调用管的动作，对象是门，因为门知道如何执行关的动作，通过门轴之类的细节实现。

指挥者：是人在指挥门做关的动作，只是给门发出了关的信号，让门执行。

总结：变量使用方法，是方法本身知道如何实现执行的过程，也就是“方法对象”调用方法，才执行了方法的每个细节的。

3、获取某个类中的某个方法：（如String str = ”abc”）

1）通常方式：str.charAt(1)

2）反射方式：

Method charAtMethod =Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);

charAtMethod.invoke(str,1);

说明：如果传递给Method对象的invoke()方法的第一个参数为null，说明Method对象对应的是一个静态方法

4、用反射方式执行某个main方法：

首先要明确为何要用反射：在写源程序时，并不知道使用者传入的类名是什么，但是虽然传入的类名不知道，而知道的是这个类中的方法有main这个方法，所以可以通过反射的方式，通过使用者传入的类名（可定义字符串型变量作为传入类名的入口，通过这个变量代表类名），内部通过传入的类名获取其main方法，然后执行相应的内容。

//Method类演示
private static void methodTest(String [] args) throws Exception {
	String str1 = "abc";
	//一般方法：
	System.out.println(str1.charAt(1));
	//反射方法 ：
	Method methodCharAt =
		Class.forName("java.lang.String").getMethod("charAt",int.class);
	System.out.println(methodCharAt.invoke(str1,1));
	
	//用反射方式执行某个main方法
	//一般方式：
	Test.main(new String[]{"111","222","333"});
	System.out.println("-------");
	
	//反射方式：
	String startingClassName = args[0];
	Method methodMain =
		Class.forName(startingClassName).getMethod("main",String[].class);
		//方案一：强制转换为超类Object，不用拆包
		methodMain.invoke(null,(Object)new String[]{"111","222","333"});
		//方案二：将数组打包，编译器拆包后就是一个String[]类型的整体
		methodMain.invoke(null,new Object[]{new String[]{"111","222","333"}});
	}
//定义一个测试类
class Test{
	public static void main(String [] args){
		for(String arg : args){
			System.out.println(arg);
		}
	}
}

四、数组的反射

1、数组字节码的名字：有[和数组对应类型的缩写，如int[]数组的名称为：[I

2、基本数据类型的一维数组不能转换为Object数组，如：

int[] a = new int[3]；Object[] obj= a;这样是不成立的。

3、如何得到某个数组中的某个元素的类型：

例：int a = newint[3]；Object[] obj= new Object[]{”ABC”,1}；

无法得到某个数组的具体类型，只能得到其中某个元素的类型，如

Obj[0].getClass().getName()得到的是java.lang.String

若通过b.getClass().getName()，结果是：[Ljava.lang.Object;

	public static void arrayTest()throws Exception {
		int[] a1 = new int[]{1,2,3};
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		Integer[] ai = new Integer[3];
		String[] a4 = new String[]{"a","b","c"};
		
		System.out.println(a1.getClass() == a2.getClass());
		System.out.println((Object)a1.getClass() == (Object)a3.getClass());
			
		System.out.println(a3[0].getClass() == a1.getClass());
		System.out.println(a3[0].getClass().getSuperclass().getName());
		System.out.println(a1.getClass().equals(a3.getClass()));
		System.out.println(a1.getClass().equals(a4.getClass()));
		System.out.println(a1.getClass().getName());
		System.out.println("----:" + a1.getClass());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a2.getClass().getSuperclass().getName());
			
		Object obj1 = a1;
		Object obj2 = a2;
		//int基本数据类型不是Object的
		//Object[] obj3 = a1;
		Object[] obj4 = a3;
		Object[] obj5 = a4;
			
		System.out.println(a1);
		System.out.println(a4);
		
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));
		System.out.println("-------");
		int[] a = new int[3];
		Object[] obj = new Object[]{"abc",new Integer(1)};
		System.out.println(a.getClass().getName());
		System.out.println(obj.getClass().getName());
		System.out.println(obj[0].getClass().getName());
	}

反射的作用

1、通过反射调用位置Java类的一种方式。如房地产商造房子用户住，门窗和空调等等内部都是由用户自己安装，房子就是框架，用户需使用此框架，安好门窗等放入到房地产商提供的框架中。

框架和工具类的区别：工具类被用户类调用，而框架是调用用户提供的类。

2、框架机器要解决的核心问题：

我们在写框架（造房子的过程）的时候，调用的类（安装的门窗等）还未出现，那么，框架无法知道要被调用的类名，所以在程序中无法直接new其某个类的实例对象，而要用反射来做。

3、简单框架程序的步骤：

1）右击项目名-->File-->命名，写入键值对：className=java.util.ArrayList，等号右边的可以自己定义集合的名称，即用户可以对此记事本修改成自己的类名。

2）代码实现，加载此文件：

①将文件读取到读取流中，一定要用完整的路径，可以使用getRealPath()方法获取路径名，再加上自己定义的文件夹名。

②用Properties类的load()方法将流加载经内存，即提取文件中的信息。

③关闭流：关闭的是读取流，因为流中的数据已经加载进内存。

3）通过getProperty()方法获取类名属性，将传入的类名赋值给指定变量。

4）用反射的方式，创建对象newInstance()

5）进行相关的具体操作。

类加载器

1、简述：类加载器是将.class的文件加载经内存，也可将普通文件中的信息加载进内存。

2、文件的加载问题：

1）eclipse会将源程序中的所有.java文件加载成.class文件，以确保编译，然后放到classPath指定的目录中去。并且会将非.java文件原封不动的复制到.class指定的目录中去。在真正编译的时候，使用classPath目录中的文件，即放置.class文件的目录。

2）写完程序是要讲配置文件放到.class文件目录中一同打包，这些都是类加载器加载的，资源文件（配置文件）也同样加载了配置文件。

3）框架中的配置文件都要放到classPath指定的文件夹中，原因是它的内部就是用类加载器加载的文件。

3、资源文件的加载：是使用类加载器。

1）由类加载器ClassLoader的一个对象加载经内存，即用getClassLoader()方法加载。若要加载普通文件，可用getResourseAsStream(String name)在classPath的文件中逐一查找要加载的文件。

2）在.class身上也提供了方法来加载资源文件，其实它内部就是先调用了Loader方法，再加载的资源文件。

如：Reflect.class.getResourseAsStream(String name)

4、配置文件的路径问题：

第一、用绝对路径，通过getRealPath()方法运算出来具体的目录，而不是内部编码出来的。

一般先得到用户自定义的总目录，在加上自己内部的路径。可以通过getRealPath()方法获取文件路径。对配置文件修改是需要要储存到配置文件中，那么就要得到它的绝对路径才行，因此，配置文件要放到程序的内部。

第二、name的路径问题：

①如果配置文件和classPath目录没关系，就必须写上绝对路径，

②如果配置文件和classPath目录有关系，即在classPath目录中或在其子目录中（一般是资源文件夹resource），那么就得写相对路径，因为它自己了解自己属于哪个包，是相对于当前包而言的。

例：配置文件内容：className=java.util.ArrayList

<span style="font-family:Arial;">import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;

public class ReflectTest2 {
	public static void main(String [] args)throws Exception{
		//读取系统文件到读取流中
		//方式一：
		//InputStream ips = new FileInputStream("config.propert");
		/*getRealPath()--得到完整的路径//如：金山词霸/内部
		 * 一定要用完整的路径，但完整的路径不是硬编码出来的，而是运算出来的。*/
		//方式二：
		//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/text1/config.propert");
		//方式三：
			//第一种：配置文件（资源文件）在当前包中
		InputStream ips = ReflectTest2.class.getResourceAsStream("resourse/config.propert");
			//第二种：配置文件（资源文件）不在当前包中，和此包没太大关系
		//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/test2/resourse/config.properties");
		
		//加载文件中的键值对
		Properties props = new Properties();
		props.load(ips);
		//关闭资源，即ips调用的那个系统资源
		//注意：关闭的是ips操作的流，加载进内存后，就不再需要流资源了，需要关闭
		ips.close();
		//定义变量，将文件中的类名赋值给变量
		String className = props.getProperty("className");
		//通过变量，创建给定类的对象
		Collection cons = 
				(Collection)Class.forName(className).newInstance();
		
		//将元素添加到集合中
		/*Collection cons = new HashSet();*/
		ReflectPoint pt1 = new ReflectPoint(3,3);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,3);
		cons.add(pt1);
		cons.add(pt2);
		cons.add(pt3);
		cons.add(pt1);
		//移除元素
		cons.remove(pt1);
		System.out.println(cons.size());
	}
}
</span>

----------------------   JavaEE+Android、Java培训、期待与您交流！ ----------------------

详细请查看： http://edu.csdn.net