反射
反射的基础_Class类
Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中的各个Java类，它们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要注意与小写class关键字的区别。Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。学习反射，首先就要明白Class这个类。写如下代码进行对比理解：
/*Personp1 = new Person("zhangsan");
Personp2 = new Person("lisi");
*/
/*Classx1 = Vector类在内存里的字节码
Class x2 = Date类在内存里的字节码*/
Classx1 = Vector.class;
Classx2 = Date.class;
Class类代表Java类，它的各个实例对象又分别对应什么呢？
每个java类都是Class的一个实例对象，它们的内容不同，但是，它们的特征相同，譬如，都有方法，有字段，有父类，有包。
Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class。
如何得到各个字节码对应的实例对象（Class类型）
1-类名.class，例如，System.class。
2-对象.getClass()，例如，new Date().getClass()。得到创建这个对象的字节码
3-Class.forName("类名")，例如，Class.forName("java.util.Date");。作用是返回字节码，返回的方式有两种：曾经加载过已经在java虚拟机里，直接返回。Java虚拟机还没有这份字节码，调用类加载器去加载把加载的字节码缓存在虚拟机里，以后要得到这份字节码就不用再加载了
九个预定义Class实例对象（八大基本类型+void）：
注意：
1、Int.class ==Integer.TYPE。
2、数组类型的Class实例对象用的Class方法是Class.isArray()
3、反射并不是Java5的新特性。
示例：
ReflectTest.java
package com.itheima.day1;
public class ReflectTest {
public static void main(String[] args) throws Exception {
String str = "abc";
Class clazz1 = String.class;
Class clazz2 = str.getClass();
Class clazz3 = Class.forName("java.lang.String" );
System. out.println(clazz1 == clazz2);
//结果：true
System. out.println(clazz2 == clazz3);
//结果：true
System. out.println(clazz1.isPrimitive());//是不是基本类型的字节码
//结果：false
System. out.println(int.class.isPrimitive());
//结果：true
System. out.println(int.class == Integer. class);
//结果：false
System. out.println(int.class == Integer. TYPE);//包装类型所包装的基本类型的那份字节码
//结果：true
System. out.println(int[].class.isPrimitive());
//结果：false
System. out.println(int[].class.isArray());//判断是不是数组
//结果：true
}
}
总之：
只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…
理解反射的概念
反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。
构造方法的反射应用
·Constructor类代表某个类中的一个构造方法。
Constructor对象代表一个构造方法，Constructor对象上会有的方法有：得到方法名字，得到所属于的类，产生实例对象。
·得到某个类所有的构造方法：
例子：Constructor[] constructors=Class.forName("java.lang.String").getConstructors();
·得到某一个构造方法：
例子：Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);//获得方法时要用到类型
注意：
一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。重点：参数类型用什么方式表示？用Class实例对象。
·创建实例对象：
通常方式：String str = new String(newStringBuffer("abc"));
反射方式： String str =(String)constructor.newInstance(new StringBuffer("abc")); //调用获得的方法时要用到上面相同类型的实例对象
·Class.newInstance()方法：
例子：String obj =(String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
ReflectTest.java
<span style="color:#333333;">package com.itheima.day1;
import java.lang.reflect.Constructor;
public class ReflectTest {
public static void main(String[] args) throws Exception {
Constructor constructor = String.class.getConstructor(StringBuffer.class);
String str = (String)constructor.newInstance( new StringBuffer("abc" ));
System. out.println(str.charAt(2));
//结果：c
}
}</span><span style="color:#41ad1c;">
</span>成员变量的反射
·Field类代表某个类中的一个成员变量。
·问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，那关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。
示例1：
ReflectPoint.java
package com.itheima.day1;
public class ReflectPoint {
private int x;
public int y ;
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
}
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPoint rp = new ReflectPoint(3, 5);
Field fieldY = rp.getClass().getField( "y");
System. out.println(fieldY.get(rp));
//结果：5
}
}
示例2：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPoint rp = new ReflectPoint(3, 5);
Field fieldX = rp.getClass().getField("x");
System. out.println(fieldX.get(rp));
}
}
结果：
Exception in thread"main" java.lang.NoSuchFieldException : x
atjava.lang.Class.getField( Class.java:1520)
atcom.itheima.day1.ReflectTest.main( ReflectTest.java:10)
注意：
如果类的某个成员变量的修饰符是private，那么直接通过getField方法获取Field类型的对象就会出现如上错误。
示例3：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPointrp = new ReflectPoint(3,5);
Field fieldX =rp.getClass().getDeclaredField("x");
System. out.println(fieldX.get(rp));
}
}
结果：
Exception in thread"main" java.lang.IllegalAccessException : Class com.itheima.day1.ReflectTest can not access a member of classcom.itheima.day1.ReflectPoint with modifiers "private"
atsun.reflect.Reflection.ensureMemberAccess( Reflection.java:65)
atjava.lang.reflect.Field.doSecurityCheck( Field.java:960)
atjava.lang.reflect.Field.getFieldAccessor( Field.java:896)
atjava.lang.reflect.Field.get( Field.java:358)
注意：
如果类的某个成员变量的修饰符是private，那么直接通过getDeclaredField方法获取Field类型的对象可以通过会但最后一句fieldX.get(rp)出现如上错误。表示获取fieldX的值，因为字段x是私有的
解决方案：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPointrp = new ReflectPoint(3,5);
FieldfieldX = rp.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System. out.println(fieldX.get(rp));
}
}
注意：
通过称之为暴力反射的方式解决，也就是使用setAccessible(true)使private类型的成员变量也可以被获取值。
作业：
将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
答案：
ReflectPoint.java
package com.itheima.day1;
public class ReflectPoint{
private int x;
public int y ;
publicStringstr1="ball";
publicStringstr2="basketball";
publicStringstr3="itcast";
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
@Override
publicString toString() {
returnstr1+":"+str2+":"+str3;
}
}
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class ReflectTest{
public static void main(String[]args) throws Exception {
ReflectPoint rp = newReflectPoint(3,5);
changeStringValue(rp);
System.out.println(rp);
}
publicstaticvoidchangeStringValue(Object obj)throwsException {
Field[]fields = obj.getClass().getFields();
for(Field field : fields){
if(field.getType() == String.class){//这里应该用==因为是同一份字节码
StringoldValue = (String)field.get(obj);
StringnewValue = oldValue.replace('b','a');
field.set(obj,newValue);
}
}
}
}
结果：
aall:aasketaall:itcast
成员方法的反射
·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));
注意：
如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
·jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)
即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数。所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke("str", newObject[]{1})形式。
示例：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception {
Stringstr = "abc";
Method methodCharAt =String.class.getMethod("charAt", int.class);
System.out.println(methodCharAt.invoke(str, 1));
//结果：b
System.out.println(methodCharAt.invoke(str,newObject[]{2}));
//结果：c
}
}
对接收数组参数的成员方法进行反射
目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？
在写程序的时候根本不知道执行哪个类
用普通方法调这样写:
TestArguments.main(newString[]{"111","222","333"});
·示例：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception {
String startingClassName = args[0];//用args[0]接收TestArguments这个类的类名字符串，ReflectTest类内部拿到这个字符串就可以生成TestArguments这个类的字节码从而拿到main方法进而就可以执行，相当于在控制台运行：java ReflectTest cn.itcast.day1.TestArgument
Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
mainMethod.invoke(null,newString[]{"111","222","333"});
}
}
classTestArguments{
publicstaticvoidmain(String[] args) {
for(String arg : args){
System.out.println(arg);
}
}
}
结果：
Exception in thread"main" java.lang.ArrayIndexOutOfBoundsException : 0
atcom.itheima.day1.ReflectTest.main( ReflectTest.java:8)
原因：
main方法没有设置传入的参数，所以会出现数组越界的错误。
解决方法：
右击Run As-->点击Run Configurations。
弹出如下窗口-->点击Arguments选项卡-->输入需要执行的main方法所在类全名。
点击Apply再点击Run。
结果如下：
Exception in thread"main" java.lang.IllegalArgumentException : wrong number of arguments
atsun.reflect.NativeMethodAccessorImpl.invoke0( Native Method)
atsun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
atsun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
atjava.lang.reflect.Method.invoke( Method.java:597)
atcom.itheima.day1.ReflectTest.main( ReflectTest.java:10)
·问题：
启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new
String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
解决办法：
方法一：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});//打开之后是一个数组
方法二：
mainMethod.invoke(null,(Object)new String[]{"xxx"});--编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。
解决方法：
·示例1：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception {
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod( "main",String[]. class);
mainMethod.invoke(null,newObject[]{newString[]{"111","222","333"}});
}
}
class TestArguments{
public static void main(String[] args) {
for(Stringarg : args){
System. out.println(arg);
}
}
}
·示例2：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Method;
public class ReflectTest {
public static void main(String[] args) throws Exception {
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod( "main",String[].class);
mainMethod.invoke(null, (Object)newString[]{"111","222","333"});
}
}
class TestArguments{
public static void main(String[] args) {
for(Stringarg : args){
System. out.println(arg);
}
}
}
结果：
111
222
333
数组与Object的关系及其反射类型（数组的反射）
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
示例：
ReflectTest.java
package com.itheima.day1;
import java.util.Arrays;
public class ReflectTest{
public static void main(String[]args) throws Exception {
int [] a1 = new int[3];
int []a2 = new int[4];
int [][]a3 = new int[2][3];
String[] a4 = new String[3];
System.out.println(a1.getClass() == a2.getClass());
//结果：true
System.out.println(a1.getClass()== a4.getClass());
//结果：false
System.out.println(a1.getClass()== a3.getClass());
//结果：false
}
}
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
示例：
ReflectTest.java
package com.itheima.day1;
import java.util.Arrays;
public class ReflectTest{
public static void main(String[]args) throws Exception {
int [] a1 = new int[3];
int []a2 = new int[4];
int [][]a3 = new int[2][3];
String[] a4 = new String[3];
System. out .println(a1.getClass().getName());
//结果：[I
System. out .println(a1.getClass().getSuperclass().getName());
//结果：java.lang.Object
System. out .println(a4.getClass().getSuperclass().getName());
//结果：java.lang.Object
}
}
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
示例：
ReflectTest.java
package com.itheima.day1;
import java.util.Arrays;
public class ReflectTest{
public static void main(String[]args) throws Exception {
int [] a1 = new int[3];
int []a2 = new int[4];
int [][]a3 = new int[2][3];
String[] a4 = new String[3];
Object aObj1 = a1;
Object aObj2 = a4;
//a1是int 类型的数组，int 不是Object，因此编译就会报错
//Object[]aObj3 = a1;
//a3是数组的数组，第二维数组也是一维数组，父类是Object，因此不会报错
Object[] aObj4 = a3;
//a4是String的数组，String父类是Object，因此不会报错
Object[] aObj5 = a4;
}
}
Arrays.asList()方法处理int[]和String[]时的差异。
示例：
ReflectTest.java
package com.itheima.day1;
import java.util.Arrays;
public class ReflectTest{
public static void main(String[]args) throws Exception {
int []a5 = new int[]{1,2,3};
String[] a6 = new String[]{"a" ,"b" ,"c" };
//直接使用System.out.println无法打印出数组的内容
System. out .println(a5);
//结果：[I@18a992f
System. out .println(a6);
//结果：[Ljava.lang.String;@4f1d0d
//通过Arrays.asList方法打印出数组的内容
System. out .println(Arrays.asList(a5));
//结果：[[I@18a992f]
//原因是因为JDK1.4中为Arrays.asList(Object[] a)，JDK1.5中为Arrays.asList(T... a)。
//a5是int[]类型，JDK1.4中的asList方法处理不了，JDK1.5可以处理。但是JDK1.5将 int数组整体作为一个参数进行处理。
//因此最终结果就是将 int[]进行了封装，结果类型也就成了[[I。
System. out .println(Arrays.asList(a6));
//结果：[a, b, c]
}
}
注意：
Class类的getName方法返回值中[表示数组的深度，[表示一维数组，[[表示二维数组。剩下的内容则表示数组类型，例如I表示int类型。
Array工具类用于完成对数组的反射操作。
示例：
ReflectTest.java
package com.itheima.day1;
import java.lang.reflect.Array;
public class ReflectTest {
public static void main(String[] args) throws Exception {
String[] a1 = newString[]{"a","b","c"};
String a2 ="xyz";
printObject(a1);
printObject(a2);
}
publicstaticvoidprintObject(Object obj){
Class clazz = obj.getClass();
if(clazz.isArray()){
intlen = Array.getLength(obj);
for(inti = 0; i < len; i++){
System.out.println(Array.get(obj,i));
}
}else{
System.out.println(obj);
}
}
}
ArrayList_HashSet的比较及Hashcode分析
示例1：
ReflectTest.java
package com.itheima.day1;
import java.util.ArrayList;
import java.util.Collection;
public class ReflectTest {
public static void main(String[] args) throws Exception {
Collection collections = newArrayList();
ReflectPoint pt1 =newReflectPoint(3, 3);
ReflectPoint pt2 =newReflectPoint(5, 5);
ReflectPoint pt3 =newReflectPoint(3, 3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System.out.println(collections.size());
//结果：4
}
}
示例2：
ReflectTest.java
package com.itheima.day1;
import java.util.Collection;
import java.util.HashSet;
public class ReflectTest {
public static void main(String[] args) throws Exception {
Collection collections = newHashSet();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System. out.println(collections.size());
//结果：3
}
}
分析：
由以上两示例可以看到当集合为ArrayList时，其实质是一个数组，因此放入4个元素后，集合size为4。
当集合为HashSet时，需要通过比较hashcode值以及equals方法是否返回true决定是否放入。如果hashcode值相等并且equals方法返回true，那么就不会放入。因此，集合size为3。
如果想让size为2，也就是pt1与pt3作为同一个元素存入HashSet集合，那就需要覆盖ReflectPoint类的hashCode方法以及equals方法。
示例：
在代码区右击-->Source-->点击Generate hashCode() andequals()...。
点击OK，即可生成hashCode和equals方法。
ReflectPoint.java
package com.itheima.day1;
public class ReflectPoint {
private int x ;
public int y ;
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}
@Override
publicinthashCode() {
finalintprime = 31;
intresult = 1;
result= prime * result +x;
result= prime * result +y;
returnresult;
}
@Override
publicbooleanequals(Object obj) {
if(this== obj)
returntrue;
if(obj ==null)
returnfalse;
if(getClass() != obj.getClass())
returnfalse;
ReflectPointother = (ReflectPoint) obj;
if(x!= other.x)
returnfalse;
if(y!= other.y)
returnfalse;
returntrue;
}
}
重新运行ReflectTest.java就可以看到size值为2。
注意：
当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。
示例：
ReflectPoint.java
package com.itheima.day1;
import java.util.Collection;
import java.util.HashSet;
public class ReflectTest {
public static void main(String[] args) throws Exception {
Collection collections = new HashSet();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
pt1.y= 70;
collections.remove(pt1);
System. out.println(collections.size());
//结果：2
}
}
分析：
由上面的示例可以看到由于pt1对象的y属性被修改了，因此该对象的哈希值也被修改了，所以无法删除掉。因此size值还是2。
框架的概念及用反射技术开发框架的原理
·框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
·框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
示例：
ReflectTest.java
package com.itheima.day1;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;
public class ReflectTest {
public static void main(String[] args) throws Exception {
InputStream is = newFileInputStream("config.properties");
//getRealPath();//金山词霸/内部
//一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。
Properties props =newProperties();
props.load(is);
is.close();
String className = (String)props.get("className");
Collection collections = (Collection)Class.forName(className).newInstance();
ReflectPointpt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System. out.println(collections.size());
}
}
注意：
config.properties文件直接放在工程根目录下。
config.properties
className= java.util.ArrayList
结果：
4
config.properties
className= java.util.HashSet
结果：
3
用类加载器的方式管理资源和配置文件
将config.properties文件移动到src目录下的com/itheima/day1目录下：
示例：
ReflectTest.java
package com.itheima.day1;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;
public class ReflectTest {
public static void main(String[] args) throws Exception {
//方式一：采用类加载器进行加载，使用相对路径的方式
//InputStream is =ReflectTest.class.getClassLoader().getResourceAsStream("com/itheima/day1/config.properties");
//方式二：利用Class方式进行加载，使用相对路径的方式
//InputStream is =ReflectTest.class.getResourceAsStream("config.properties");
//方式三：利用Class方式进行加载，使用绝对路径的方式
InputStream is = ReflectTest.class.getResourceAsStream("/com/itheima/day1/config.properties");
Properties props = new Properties();
props.load(is);
is.close();
String className = (String)props.get( "className");
Collection collections = (Collection)Class.forName(className).newInstance();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System. out.println(collections.size());
}
}
注意：
将properties文件存放在src目录下，eclipse就会自动将其拷贝到class文件所在的二进制目录下。
扫一扫
220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
