Java反射，调用方法，配置文件，打印属性，参数个数，类型名，构造方法【诗书画唱】
1、创建一个Car类，包含车牌和价格两个属性，通过反射打印出这个类中的所有属性（如name）和属性类型（如java.lang.String等），里面有一个public void run方法，通过反射调用（即为打印）这个run方法。
package Car;
public class Car {
private String name;
private Double price;
public Car(){
}
public void run(){
System.out.println("正在跑");
}
}
package Car;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class FanShe {
public static void main(String[] args) throws Exception{
System.out.println("__________\n"
+ "获取Car类对应的Class实例：");
try {
//下面的类型为Class的c就是打开反射世界的钥匙：
Class c = Class.forName("Car.Car");
//声明数组，遍历数组等步骤获取Car类的所有成员属性Field(private的也可以获取到)：
Field[]FieldShuZu = c.getDeclaredFields();
for(int i = 0;i < FieldShuZu.length;i ++) {
//拿出每个成员属性前要声明i为下标数组的成员（内容等）：
Field f = FieldShuZu[i];
//下面是用getName获取这个成员属性的名字：
String n = f.getName();
System.out.println("\n名字是：" + n);
//下面是用getType获取这个成员属性的类型：
Class t = f.getType();
System.out.println("类型是：" + t.getName());
}
System.out.println("__________\n"
+ "获取Car类中的构造方法（特征就是没有void的）"
+ "(用上Constructor)：");
//获取Car类中的构造方法(Constructor)
Constructor[]cs = c.getDeclaredConstructors();
for(int i = 0;i < cs.length;i ++) {
//取出Car类中的每个构造方法：
Constructor con = cs[i];
//获取构造方法的参数的个数：
int count = con.getParameterCount();
System.out.println("\n其中的一个构造方法的参数的个数是：" + count);
//获取构造方法的参数的类型(数组)，
//类型为Class的数组pt，pt（为getParameterTypes的字母）
Class[]pt = con.getParameterTypes();
for(int j = 0;j < pt.length;j ++) {
//取出当前构造方法中的每个参数
Class t = pt[j];
System.out.println("这个构造方法的参数类型其中一个为："+t.getName());
}
}
//获取Car类中的所有的方法(Method)
System.out.println("__________\n"
+ "获取Car类中的所有的方法（特征就是有void）"
+ "(用上Method)：");
Method[]ms = c.getDeclaredMethods();
for(int i = 0;i < ms.length;i ++) {
//取出每个方法
Method m = ms[i];
//取出方法名
String methodName = m.getName();
System.out.println("方法名为："+methodName);
}
System.out.println("\n"
+ "下面是调用类中的方法，打印有void的方法中的内容：\n");
//通过反射创建Car对象
Object car = c.newInstance();
//通过反射调用方法
//获取eat方法对象
Method m1 = c.getDeclaredMethod("run");
//反射调用eat方法，方法.对象
m1.invoke(car) ;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2、创建一个Cat类，里面有一个public void cry方法，通过反射调用cry方法。
package fanShe;
import java.util.Date;
public class Cat {
private String name;
private Integer age;
public Cat(){
}
public Cat(String n,Integer a){
this.name = n;
this.age = a;
}
public void cry(){
System.out.println("正在叫");
}
}
package fanShe;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class FanShe {
public static void main(String[] args) throws Exception{
try {
Class c = Class.forName("fanShe.Cat");
System.out.println("\n"
+ "下面是调用类中的方法，打印有void的方法中的内容：\n");
Object Cat = c.newInstance();
Method M = c.getDeclaredMethod("cry");
M.invoke(Cat) ;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、创建一个Apple类，包含颜色和价格以及类型三个属性，通过反射打印出所有属性和属性类型，里面有一个public void grow方法，通过反射调用grow方法。
package fanShe;
import java.util.Date;
public class Apple {
public String color;
private String type;
private Double price;
public Apple(){
}
public Apple(String type,Double price){
this.type = type;
this.price = price;
}
public void grow(){
System.out.println("诗书画唱独到的种苹果的方法");
}
}
package fanShe;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class AppleFanShe {
public static void main(String[] args) throws Exception{
try {
Class c = Class.forName("fanShe.Apple");
Field[]FieldShuZu = c.getDeclaredFields();
for(int i = 0;i < FieldShuZu.length;i ++) {
Field f = FieldShuZu[i];
String shuXing = f.getName();
System.out.println("\n属性的名字是：" + shuXing);
Class type = f.getType();
System.out.println("属性的类型是：" + type.getName());
}
System.out.println("\n"
+ "下面是调用类中的方法，打印有void的方法中的内容：\n");
Object Apple = c.newInstance();
Method fangFa = c.getDeclaredMethod("grow");
fangFa.invoke(Apple) ;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4、在控制台接收一个字符串，这个字符串是一个类的全路径名，再接收一个方法名，通过反射调用这个类中的这个方法。
效果如下：
请输入类的全路径：
net.sf.Person
请输入方法名：
study
好好学习
package net.sf;
import java.util.Date;
public class Person {
public String name;
private String sshc;
public Person(){
}
public void study(){
System.out.println("好好学习");
}
}
package net.sf;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Scanner;
public class PfanShe {
public static void main(String[] args) throws Exception{
try {
Scanner Sca = new Scanner(System.in);
System.out.println("请输入类的全路径：");
String Src = Sca.next();
Class c = Class.forName(Src);
System.out.println("请输入方法名：");
String FangFaName = Sca.next();
System.out.println("\n"
+ "下面是调用类中的方法，打印有void的方法中的内容：\n");
Object Person = c.newInstance();
Method fangFa = c.getDeclaredMethod(FangFaName);
fangFa.invoke(Person) ;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
5、创建一个properties文件，包含下面的数据：
cls=net.sf.Person
method=study
运行程序后直接执行Person类中的study方法。
package net.sf;
import java.util.Date;
public class Person {
public String name;
private String sshc;
public Person(){
}
public void study(){
System.out.println("好好学习");
}
}
package net.sf;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;
import java.util.Scanner;
public class PfanShe {
// private static String Src = null;
// private static String FangFaName = null;
public static void main(String[] args) throws Exception{
Properties prop = new Properties();
//将db.properties文件读取到内存中去：
InputStream is = PfanShe.class.getClassLoader()
.getResourceAsStream("db.properties");
//加载内容：
prop.load(is);
//读取内容：
String Src = prop.getProperty("cls");
String FangFaName = prop.getProperty("method");
// System.out.println(Src+FangFaName);
// Scanner Sca = new Scanner(System.in);
//
// System.out.println("请输入类的全路径：");
// String Src = Sca.next();
Class c = Class.forName(Src);
//System.out.println("请输入方法名：");
//
//String FangFaName = Sca.next();
// System.out.println("\n"
//+ "下面是调用类中的方法，打印有void的方法中的内容：\n");
Object Person = c.newInstance();
Method fangFa = c.getDeclaredMethod(FangFaName);
fangFa.invoke(Person) ;
}
}
原型例子：
（自己出和写的题目：）
用反射打印出声明的类属性名和属性的类型名（类可以先写在同一个界面，也可以分开写等）：
package fanShe;
import java.sql.*;
import java.lang.reflect.Field;
public class Text {
public static void main(String[] args) {
try{
Class c=Class.forName("fanShe.Student");
Field[]fs=c.getDeclaredFields();
for(int i=0;i<fs.length;i++){
Field f=fs[i];
String n=f.getName();
System.out.println("\n名字是:"+n);
Class t=f.getType();
System.out.println("类型是:"+t.getName());
}
}catch(ClassNotFoundException e){
}
}
}
class Student {
public Integer id;
public String name;
public Date birth;
public Cat pet;
}
class Cat{
}
用反射的知识打印出自己声明为包装类等类型的变量名（就是属性名），
和相关的属性类型的名称，构造方法名和构造方法的参数和参数类型，参数的个数，方法名等。
package com.sshc;
import java.util.Date;
public class Cat {
public String sshc;
private String name;
private Integer age;
private Double price;
private Date birth;
public Cat(){
}
public Cat(String n) {
this.name = n;
}
public Cat(String n,Integer a,Double p,Date b){
this.name = n;
this.age = a;
this.price = p;
this.birth = b;
}
public void eat(){
System.out.println("正在吃东西");
}
public void play(){
System.out.println("正在玩耍");
}
}
package sshc;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
// ————
//下面Date的Class实例（共三种获得Date的内容的方法）：
// ————
//方法一：直接通过类名.class
// Class c1 = Date.class;
// ————
//方法二：创建一个Date对象，然后通过对象.getClass()方法
//Date now = new Date();
//Class c2 = now.getClass();
//类的全路径：包名+.+类名
// ————
//方法三：Class.forName(类的全路径)
// try {
// //使用反射技术的核心代码
// Class c3 = Class.forName("java.util.Date");
// } catch (ClassNotFoundException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// ————
//下面是获取Cat类对应的Class实例：
System.out.println("__________\n"
+ "获取Cat类对应的Class实例：");
try {
//下面的类型为Class的c就是打开反射世界的钥匙：
Class c = Class.forName("com.sshc.Cat");
//声明数组，遍历数组等步骤获取Cat类的所有成员属性Field(private的也可以获取到)：
Field[]FieldShuZu = c.getDeclaredFields();
for(int i = 0;i < FieldShuZu.length;i ++) {
//拿出每个成员属性前要声明i为下标数组的成员（内容等）：
Field f = FieldShuZu[i];
//下面是用getName获取这个成员属性的名字：
String n = f.getName();
System.out.println("\n名字是：" + n);
//下面是用getType获取这个成员属性的类型：
Class t = f.getType();
System.out.println("类型是：" + t.getName());
}
System.out.println("__________\n"
+ "获取Cat类中的构造方法（特征就是没有void的）"
+ "(用上Constructor)：");
//获取Cat类中的构造方法(Constructor)
Constructor[]cs = c.getDeclaredConstructors();
for(int i = 0;i < cs.length;i ++) {
//取出Cat类中的每个构造方法：
Constructor con = cs[i];
//获取构造方法的参数的个数：
int count = con.getParameterCount();
System.out.println("\n其中的一个构造方法的参数的个数是：" + count);
//获取构造方法的参数的类型(数组)，
//类型为Class的数组pt，pt（为getParameterTypes的字母）
Class[]pt = con.getParameterTypes();
for(int j = 0;j < pt.length;j ++) {
//取出当前构造方法中的每个参数
Class t = pt[j];
System.out.println("这个构造方法的参数类型其中一个为："+t.getName());
}
}
//获取Cat类中的所有的方法(Method)
System.out.println("__________\n"
+ "获取Cat类中的所有的方法（特征就是有void）"
+ "(用上Method)：");
Method[]ms = c.getDeclaredMethods();
for(int i = 0;i < ms.length;i ++) {
//取出每个方法
Method m = ms[i];
//取出方法名
String methodName = m.getName();
System.out.println("方法名为："+methodName);
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
