一篇文章看懂java反射机制（反射实例化对象-反射获得构造方法,获得普通方法,获得字段属性）

Class<?> cls = Class.forName("cn.mldn.demo.Person"); // 取得Class对象
传入一个包名+类名的字符串就可以得到Class对象

Object obj = cls.newInstance() //反射实例化对象
Constructor<?> cons = cls.getConstructor(String.class, int.class);//获得构造方法
Method m3 = cls.getDeclaredMethod("getName"); //获得get方法
Field nameField = cls.getDeclaredField("name"); // 获得name属性

1. 虽然用此方法创造的对象比new出来的复杂，但是有利于程序的解耦，增加扩展性
8/22框架技术都是通过此技术进行解耦操作的

2. Class<?> cls = Class.forName("cn.mldn.demo.Person"); // 取得Class对象
Constructor<?> cons = cls.getConstructor(String.class, int.class);
Object obj = cons.newInstance("张三", 20); // 为构造方法传递参数
System.out.println(obj); // Person [name=张三, age=20]

3. Method m = cls.getDeclaredMethod("say"); //say是自己在类中自定义的方法
m.invoke(obj);//输出123456789，这个obj可以是new出来的或newInstance出来的

4. Object obj = Class.forName("Person").newInstance();

Field nameField = cls.getDeclaredField("name"); // 获得name属性
nameField.setAccessible(true); //解除封装
nameField.set(obj, "张三"); // Person对象.name = "张三"
System.out.println(nameField.get(obj)); // Person对象.name

packagecn.mldn.demo;
classPerson {}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Person per = new Person() ; // 正着操作-由类到对象
System.out.println(per.getClass().getName()); // 反着来-由对象到类
}
}


packagecn.mldn.demo;
classPerson {}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Person per = newPerson() ; // 正着操作
Class<?> cls = per.getClass() ; // 取得Class对象
System.out.println(cls.getName()); // 反着来
}
}


packagecn.mldn.demo;
classPerson {}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Class<?> cls = Person.class; // 取得Class对象
System.out.println(cls.getName()); // 反着来
}
}


packagecn.mldn.demo;
classPerson {}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象
System.out.println(cls.getName()); // 反着来
}
}


packagecn.mldn.demo;
classPerson {
@Override
publicString toString() {
return"Person Class Instance .";
}
}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象
Object obj = cls.newInstance() ; // 实例化对象，和使用关键字new一样
Person per = (Person) obj ; // 向下转型
System.out.println(per);
}
}


packagecn.mldn.demo;
interface Fruit {
public void eat() ;
}
classApple implements Fruit {
public void eat() {
System.out.println("吃苹果。");
};
}
class Factory {
public static Fruit getInstance(String className) {
if("apple".equals(className)){
return new Apple() ;
}
returnnull;
}
}
publicclassFactoryDemo {
publicstaticvoidmain(String[] args) {
Fruit f = Factory.getInstance("apple") ; //静态方法
f.eat() ;
}
}


packagecn.mldn.demo;
interfaceFruit {
publicvoideat() ;
}
classApple implementsFruit {
publicvoideat() {
System.out.println("吃苹果。");
};
}
classOrange implementsFruit {
publicvoideat() {
System.out.println("吃橘子。");
};
}
classFactory {
publicstaticFruit getInstance(String className) {
Fruit f = null;
try{
f = (Fruit) Class.forName(className).newInstance() ;
//获得Class对象----实例化一个类的对象
} catch(Exception e) {
e.printStackTrace();
}
returnf ;
}
}
publicclassFactoryDemo {
publicstaticvoidmain(String[] args) {
Fruit f = Factory.getInstance("cn.mldn.demo.Orange") ;
//只要传入字符串进入就可以实例化对象--深度解耦了
f.eat() ;
}
}


向上塑性的好处是，增加extensible，
要是接口的实现类B换成了实现类c，照样可以用A的引用变量.say()
在上面的类中，增加一个草莓类，但是工程这个类可以在不修改的情况下继续使用
这边进行了增加或者删除，不用修改 另外一边，降低了耦合度，增加了可扩展性

packagecn.mldn.demo;
importjava.lang.reflect.Constructor; //不在java语言包
classPerson { // CTRL + K
publicPerson() {}
publicPerson(String name) {}
publicPerson(String name,intage) {}
}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象
Constructor<?> cons [] = cls.getConstructors() ; // 取得全部构造
for(intx = 0; x < cons.length; x++) {
System.out.println(cons[x]);
}
}
}


packagecn.mldn.demo;
classPerson { // CTRL + K
privateString name;
privateintage;
publicPerson(String name,intage) {
this.name= name ;
this.age= age ;
}
@Override
publicString toString() {
return"Person [name="+ name+ ", age="+ age+ "]";
}
}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象
Object obj = cls.newInstance(); // 实例化对象
System.out.println(obj);
}
}


packagecn.mldn.demo;
importjava.lang.reflect.Method;
classPerson {
privateString name;
publicvoidsetName(String name) {
this.name= name;
}
publicString getName() {
returnname;
}
}
publicclassTestDemo {
publicstaticvoidmain(String[] args) throwsException {
Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象
Method met [] = cls.getMethods() ; // 取得全部方法
for(intx = 0; x < met.length; x++) {
System.out.println(met[x]);
}
}
}


packagecn.mldn.demo;
importjava.lang.reflect.Field;
classPerson {
privateString name;
}
public class TestDemo {
public static void main(String[] args) throws Exception {
Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 第一步：取得Class对象
Field field [] = cls.getDeclaredFields() ; // 第二步：取得全部属性
for(intx = 0; x < field.length; x++) {
System.out.println(field[x]);
}
}
}


资料来源：经过加工整理

链接：https://www.zhihu.com/question/24304289/answer/38218810
来源：知乎