求解流声分解法的shen方程时，需要对变量的边界作无反射处理。OpenFOAM提供的无反射边界条件有advective和waveTransmissive这两种，但这两种似乎都不能满足笔者的需要，可能要进行某些修改。在这之前，先来学习一下这两种无反射边界条件的代码以及它俩的区别，这对自己的运用起到帮助。这里会参考日本博主的博文。他用的是英文，而且只起了个开头，后面重要的没写（等他好久了都没补上）。我写点中国人看得懂的，顺便把后面的内容也补上。
 
1. 无反射边界条件
 
基于有限体积法，OpenFOAM的边界条件就是对边界上的面元通量进行计算（拟合）。在有限体积法里，面上的值通常用相邻两单元的体元值（cell value）插值近似求得。但是在边界上，边界面元只有一边和边界单元体接壤，另一边是计算域之外，所以需要根据不同的需求来对这块边界面元上的值进行设置或者计算。常用边界条件的有fixedValue（固定边界元上的值），zeroGradient（将接壤单元的体元值赋值到面元上）等。在高精度的有限差分方法中，边界可以通过边界外几个点进行插值拟合。而在有限体积法里，受到方法本身的限制，计算复杂的高精度的边界条件就没那么容易了。一些有特别需要的边界条件则要求解对应的偏微分方程才能得到。本文所讲到的无反射边界条件，就属于这一类。当我们需要波（声波、涡波、熵波）流出边界而不会反射回来，对计算域内造成影响时，就需要应用无反射边界条件。
 
2 advective
 
2.1 控制方程解析
 
advective在流体力学里是对流的意思。在边界条件上，主要体现在流体的流出。通过解方程： 
 
 
来得到面上的通量。其中是wave velocity (see advectiveFvPatchField.H)，由函数advectiveSpeed()函数计算得到。是面元法向量。就是需要无反射处理的流场变量。形式上相当于物质导数，又称全导数、随体导数等，本质上是拉格朗日法的概念之一。它是运动的流体微团的物理量随时间的变化率，它等于该物理量由当地时间变化所引起的变化率与由流体对流引起的变化率的和。然而它和一般我们说的物质导数又有一些区别，因为它只关注边界面上的情况，即仅关注流体在边界这一面上的对流。在计算上，它其实是fixedValue和zeroGradient的结合，当：
 
 
 
时，为fixedValue。而当：
 
 
时，相当于zeroGradient。这两项其中一个为零，另一个也为零。 可以理解为流体微团的物理量随时间的变化率，等于该物理量由当地时间变化所引起的变化率与由流体通过边界流出引起的变化率的和。拉格朗日法关注单个流体微团。通俗来讲，就是流体微团通过边界面时，其本身对应的物理量不发生改变（全导数为0）。信息“完整地”通过了边界，也就没有造成反射，从而影响到计算域内的情况。想要更直观地了解，可以看看博文里面提供的视频。
 
的计算由以下代码进行：
 
template<class Type>
Foam::tmp<Foam::scalarField>
Foam::advectiveFvPatchField<Type>::advectionSpeed() const
{
    const surfaceScalarField& phi =
        this->db().objectRegistry::template lookupObject<surfaceScalarField>
        (phiName_);

    fvsPatchField<scalar> phip =
        this->patch().template lookupPatchField<surfaceScalarField, scalar>
        (
            phiName_
        );

    if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
    {
        const fvPatchScalarField& rhop =
            this->patch().template lookupPatchField<volScalarField, scalar>
            (
                rhoName_
            );

        return phip/(rhop*this->patch().magSf());
    }
    else
    {
        return phip/this->patch().magSf();
    }
}
 
phi为速度通量U()&magSf()，在这里只是程序判定phi是否为密度流量的。如果是，那就要在输出的时候除以面元上的密度值（rhop）。因而这个Un的计算只是把边界面的速度通量除以面矢量，还原成面上的法向速度罢了。
 
2.2  和 
 
lInf和fieldInf的设置不是必须的。头文件原话：Additionally an optional mechanism to relax the value at the boundary to a specified far-field value is provided which is  switched on by specifying the relaxation length-scale \c lInf and the far-field value \c fieldInf. 不设置时，lInf默认负无穷，fieldInf默认为零。lInf是松弛用的，松弛系数定义如下：
 
 
所以不设置lInf和fieldInf时，松弛系数默认是零。
 
2.3 计算过程
 
要理解边界条件是怎么被应用于边界单元面上值，首先需要知道五个主要的函数：updateCoeffs(), valueInternalCoeffs(), valueBoundaryCoeffs(), gradientInternalCoeffs()和gradientBoundaryCoeffs()。这里先留个坑，下次再详细讲解。在advective这个边界条件中，程序会根据时间离散格式的不同来计算修正的系数（valueFraction），这个valueFraction会流到后面四个函数中作为计算的要素之一。valueFraction的值为：
 
 
当valueFraction为1时，对应fixedValue边界条件；为0时对应fixedGradient（不一定zeroGradient）。 α是wave coefficient，计算公式为：
 
 
deltaCoeffs()是face-cell distance coeffcient，是和距离有关的系数，与网格和梯度离散格式有关。
 
时间格式的不同会影响valueFraction的计算方式，体现出方程中时间导数的影响；而deltaCoeffs()则体现了物理量对面元法向矢量的求导。由此完成对边界的修正。
 
3. waveTransmissive
 
waveTransmissive继承了advective的类，控制方程为：
 
 
此时程序里的advectionSpeed()计算的是(U_n+c)，也就是在advective的基础上，再加上当地声速。声速c的计算公式如下：
 
 
所以在使用时，需要给定psi和gamma：
 
    <patchName>
    {
        type            waveTransmissive;
        phi             phi;
        psi             psi;
        gamma           1.4;
    }
 
而advective只要type和phi即可。
 
参考资料：
 
http://caefn.com/openfoam/bc-advective-wavetransmissive
 
https://cpp.openfoam.org/v9/waveTransmissiveFvPatchField_8H.html

 
Java 反射
 
类加载器
 
当程序要使用某个类时，如果该类还未被加载到内存中，则系统(虚拟机)会使用类加载器进行加载，连接，初始化三步来实现对这个类进行初始化。
 
加载
 
就是指将class文件读入内存，并为之创建一个编译后的class文件对象(字节码对象)，任何类被使用时系统都会建立一个class文件对象
 
连接
 
验证：是否有正确的内部结构(构造器、变量、方法、代码块等)，并和其他类协调一致
 
准备：负责为类的静态成员分配内存，并设置默认初始化值
 
解析：将类的二进制数据中的符号引用替换为直接引用
 
初始化
 
就是类的初始化步骤，使用关键字new进行初始化
 
注：加载和连接是由虚拟机的类的加载器来完成的，初始化是由程序员来做的
 
类的加载时机
 
创建类的实例
 
调用类的静态变量，或者为静态变量赋值
 
调用类的静态方法
 
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
 
初始化某个类的子类，会先加载父类
 
直接使用java.exe命令来运行某个主类
 
三种类的加载器
 
Bootstrap ClassLoader 根类加载器
 
也被称为引导类加载器，负责Java核心类的加载。比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
 
Extension ClassLoader 扩展类加载器
 
负责JRE的扩展目录中jar包的加载。在JDK中JRE的lib目录下ext目录
 
System ClassLoader 系统类加载器
 
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径
 
反射
 
概念：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
 
java.lang.Class 类是描述.class文件对象的类
 
获取class文件对象的三种方式
 
对象获取 Person person=new Person();
 
Class c=person.getClass();
 
System.out.println(c);
 
类名获取
 
每个类型，包括基本类型和引用类型，都会赋予这个类型一个静态的属性，属性名为class Class c=Person.class;
 
System.out.println(c);
 
Class类的静态方法forName()获取 Class c=Class.forName("Person");
 
System.out.println(c);
 
注：这种方式中forName()的参数需要类的全名(报名.类型)形式，另需要抛出ClassNotFoundException异常
 
以上3中方式中获取的对象是唯一性的，也就是说，三种方式获取同一个类的对象都是一样的(class文件对象)
 
获取构造方法并运行
 
获取构造函数，以数组形式返回
 
获取所有public修饰的指定参数类型的构造函数：getConstructors() Class c=Person.class;
 
Constructor[] constructors = c.getConstructors();
 
for (Constructor con:constructors){
 
System.out.println(con);
 
}
 
获取所有指定参数类型的构造函数，包括私有：getDeclaredConstructors() Class c=Person.class;
 
Constructor[] constructors = c.getDeclaredConstructors();
 
for (Constructor con:constructors){
 
System.out.println(con);
 
}
 
获取无参的构造函数并运行 Class c=Person.class;
 
Constructor constructor = c.getConstructor();
 
Object obj = constructors.newInstance();
 
System.out.println(obj);
 
获取有参的构造函数并运行 Class c=Person.class;
 
Constructor constructor = c.getConstructor(String.class,int.class);
 
Object obj = constructors.newInstance("tony",21);
 
System.out.println(obj);
 
快捷方式获取构造函数并运行
 
需要满足以下两个条件
 
该类必须有无参的构造函数
 
该类无参的构造函数必须是public Class c=Person.class;
 
Object obj = c.newInstance();
 
System.out.println(obj);
 
获取私有的构造方法并运行(暴力反射)；constructors.setAccessible(true); Class c=Person.class;
 
Constructor constructor = c.getConstructor(String.class,int.class);
 
constructors.setAccessible(true);
 
Object obj = constructors.newInstance("tony",21);
 
System.out.println(obj);
 
获取成员变量并改值
 
Class c=Person.class;
 
Object obj = c.newInstance();
 
Field field = c.getField("name");
 
field.set(obj,"张三");
 
System.out.println(field.get(obj));
 
说明：
 
可获取成员变量的数组
 
可获取私有private的成员变量
 
获取成员方法
 
获取空参的成员方法并运行 Class c=Person.class;
 
Object obj = c.newInstance();
 
Method method=c.getMethod("eat");
 
Object invoke = method.invoke(obj);
 
System.out.println(invoke);
 
获取带参的成员方法并运行 Class c=Person.class;
 
Object obj = c.newInstance();
 
Method method=c.getMethod("sleep",String.class,int.class,double.class);
 
Object invoke = method.invoke(obj,"休眠",888,99.9);
 
System.out.println(invoke);
 
反射泛型擦除
 
将已存在的ArrayList集合中添加一个字符串数据，如何实现呢？其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素
 
ArrayList list = new ArrayList();
 
list.add(new Integer(30));
 
list.add(new Integer("12345"));
 
list.add(123);
 
System.out.println(list);
 
//通过反射技术，实现添加任意类型的元素
 
Class c = list.getClass();
 
Method addMethod = c.getMethod("add", Object.class);
 
addMethod.invoke(list, "哈哈");// list.add("哈哈");
 
System.out.println(list);
 
反射配置文件
 
配置文件内容：
 
该配置文件制定类名和方法名，后可更改该配置文件来执行不同的类和方法
 
className=cn.itcast_01_Reflect.Person
 
methodName=method5
 
实现代码：
 
Properties prop = new Properties();
 
prop.load(new FileInputStream("properties.txt"));
 
String className = prop.getProperty("className");
 
System.out.println(className);
 
Class c = Class.forName(className);
 
Constructor con = c.getConstructor(String.class, int.class, String.class);
 
Object obj = con.newInstance("小明", 20, "中国");
 
System.out.println(obj);
 
String methodName = prop.getProperty("methodName");
 
Method m = c.getDeclaredMethod(methodName, null);
 
// 开启暴力访问
 
m.setAccessible(true);
 
m.invoke(obj, null);

 
package com.leaves.daoUtil;
 
import java.beans.PropertyDescriptor;
 
import java.lang.reflect.Field;
 
import java.lang.reflect.Method;
 
/**
 
* 此类用来创建hql查询语句，能自动生成如下格式hql语句。
 
* from BookInfo where bookNameId='null' and bookName='《三国演义》' and
 
* bookAuthor='施耐庵' ;
 
* 使用getHql()方法来创建hql语句，此方法调用会抛出异常。
 
* 此类需要你为其提供一个带有get和set方法的bean，类会根据其get的方法获得其值，如果get属性不为null则添加where条件。
 
* 如果没有设置任何方法，则默认生成from BookInfo形式HQL语句。
 
*
 
* @version 1.0.0.0
 
* @author leaves叶知泉，官方网站www.c5ms.com
 
*
 
*/
 
public class HqlModel {
 
private Object object;
 
/**
 
* 是否开启模糊查询
 
*/
 
private boolean likeSel;
 
public boolean isLikeSel() {
 
return likeSel;
 
}
 
/**
 
* 设置属性是否开启模糊查询
 
*
 
* @param likeSel
 
*/
 
public void setLikeSel(boolean likeSel) {
 
this.likeSel = likeSel;
 
}
 
public Object getObject() {
 
return object;
 
}
 
public void setObject(Object object) {
 
this.object = object;
 
}
 
/**
 
* 允许不带参数实例化
 
*/
 
private HqlModel() {
 
}
 
/**
 
* 使用指定的对象来获取一个HqlModel实例
 
*
 
* @param object
 
* 实例化时所需要的DTO对象
 
*/
 
public static HqlModel newInstanceByObj(Object object) {
 
HqlModel hqlModel = new HqlModel();
 
hqlModel.setObject(object);
 
return hqlModel;
 
}
 
/**
 
* 用来进行创建hql语句的方法， 此方法可能抛出异常
 
*
 
* @return 根据传入对象的get方法构建的hql语句
 
*/
 
public String getHql() throws Exception {
 
// 预准备好的hql语句。
 
StringBuffer sbf = new StringBuffer("from Object where ");
 
// 得道给定实例的类型。
 
Class> theClass = this.getObject().getClass();
 
// 使用类名替换Object字符串。
 
sbf.replace(5, 11, theClass.getSimpleName());
 
// 活的该类所有属性。
 
Field[] fields = object.getClass().getDeclaredFields();
 
// 遍历所有属性
 
for (Field field : fields) {
 
PropertyDescriptor pd = new PropertyDescriptor(field.getName(),
 
theClass);
 
// 获得所有属性的读取方法
 
Method getMethod = pd.getReadMethod();
 
// 执行读取方法，获得属性值
 
Object objTemp = getMethod.invoke(object);
 
// 如果属性值为null，就略过
 
if (objTemp == null) {
 
continue;
 
}
 
// 如果不为空。
 
// 判断是否开启模糊查询，添加查询条件,并且加上%%符号。
 
if (isLikeSel()) {
 
sbf.append(field.getName() + " like '%" + objTemp + "%'");
 
sbf.append(" and ");
 
}//同理添加查询条件，不添加%%符号。
 
else {
 
sbf.append(field.getName() + "='" + objTemp + "'");
 
sbf.append(" and ");
 
}
 
}
 
//最后一个属性设置完成之后取出残余的and和尾部的空格。
 
if (sbf.toString().endsWith("and ")) {
 
sbf.delete(sbf.length() - "and".length() - 1, sbf.length());
 
}
 
//如果没有设置任何属性，则取出尾部的where字符串和后面的空格。
 
if (sbf.toString().endsWith("where ")) {
 
sbf.delete(sbf.length() - "where".length() - 1, sbf.length());
 
}
 
//返回生成好的语句。
 
return sbf.toString();
 
}
 
}
 
目前属于1.0版本，还不支持sql语句生成，其实都是一个道理，只要在类中修改 StringBuffer sbf = new StringBuffer(“from Object where ”);这一句就能完成。
 
希望朋友们修改出更好的生成器之后能跟小弟一起分享，多多指教。
 
此类不足之处：
 
·没有sql、hql切换的开关
 
·理论上还可以生成update和save这样的语句，只是小弟还没有想到设计。
 
分享到：
 
 
 
 
 
2011-11-10 00:42
 
浏览 3895
 
论坛回复 / 浏览 (19 / 8323)
 
评论
 
1 楼
 
980109763
 
2013-03-05
 
[i][i][i][i]sdfdsfsdfds
 
 
 
 
 
 
 
 
 
 
 
[/i][/i][/i][/i]

 
JAVA反射练习
 
题目
 
实现一个方法
 
public static Object execute(String className, String methodName, Object args[])
 
实现 “通过类的名字、方法名字、方法参数调调用方法，返回值为该方法的返回值。” 的功能。
 
解题思路
 
开始阶段
 
一开始看到这个题目，以为很简单。大致思路就是通过反射获取字节码文件对象，然后该对象获取方法名的方法对象。
 
将args数组转换成Class对象数组，这样来获取具体的调用某一个方法，最后调用invoke(obj,args)方法完成。
 
发现问题
 
按照这个思路写出程序，如下所示:
 
public static Object execute(String className, String methodName,Object[] args) throws Exception {
 
// 获取类的字节码文件对象
 
Class cls = Class.forName(className);
 
// 获取方法调用的参数的Class对象
 
Class[] paramsCls = new Class[args.length];
 
for (int i = 0; i < args.length; i++) {
 
paramsCls[i] = args[i].getClass();
 
}
 
// 获取方法对象
 
Method method = cls.getMethod(methodName, paramsCls);
 
Object obj = cls.newInstance();
 
return method.invoke(obj,args);
 
}
 
乍一看，这个程序没有什么太大的问题，可是在测试这个方法时出现了问题，如测试一个public int add(int a,int b)。在传递参数时，是一个Object类型的数组，如20,30这两个参数在传递过去时就被自动的装箱成为了Integer类型。那么获取的Class对象就成为了 class java.lang.Integer,但是add方法的参数却是int类型。
 
一开始我以为没什么问题，但是在调用cls.getMethod()方法时，出现了问题。虚拟机抛出异常，表示没有这样的方法，这让我很困惑，后来百度了一下，发现int.class和Integer.class并不能混为一谈，也就是这两者并不能像自动拆装箱那样进行转换。也明白了Class类的getMethod(methodName,paramTypes)中paramTypes需要的Class类型就是方法定义时的数据类型，add(int a,int b)参数是int，那么getMethod时传递的就是int.class，如果传递一个Integer.class，并不能获取到这个方法。所以这个程序并不是特别完善。
 
思考
 
解决方案1
 
既然基本数据类型在作为参数传递时，都变成了各自的包装类，那么只要在定义方法时，方法参数不允许使用基本数据类型就可以了。
 
解决方案2
 
在获取类的Class对象后，去获取类的所有方法，然后遍历获取的方法对象，拿方法对象名与methodName去比较，若相同，则调用该方法。
 
大致的解决思路就是这样，后来仔细思考了一下，这两种解决方案都不是特别完美。
 
方案1的缺陷
 
程序的通用性很差，如果我使用这个方法去调用别人定义的类中的方法，假如其他人在定义方法时，并没有将基本数据类型写成包装类，那么我使用这个方法就会发生错误，不能正确的执行。
 
方案2的缺陷
 
方案2使用循环遍历Methods数组，并通过methodName来比较判断是不是调用的该方法。但是假如我碰到了方法的重载，如调用add(int a, int b)时，这个类里面还有add(int a,int b, int c),或者add(double a,double b)。这就是三个方法， 并且方法的名称都是"add",假如我传递过来的methodName是"add",args是{20,30}，那么在循环遍历时，就会出现问题，如首先遍历的是add(int a,int b, int c)，那么在invoke时就会发生错误。所以方案2还需要判断方法的重载问题。
 
最终解决方案
 
我的最终解决方案就是在方案2的基础上，再对程序进行完善。那就是在判断method对象时，多追加几个判断条件。
 
即：当方法名一样时，判断传递的参数个数是否与当前方法对象所需要的参数个数相同，若相同，则再判断每一个参数类型是否与方法所需要的类型是否一致。这样就能精确的定位调用哪一个方法了。
 
完善后程序如下:
 
public static Object execute(String className, String methodName, Object args[]) throws Exception {
 
Class cls = Class.forName(className);
 
Method[] methods = cls.getMethods();
 
Object obj = cls.newInstance();
 
for (Method method : methods) {
 
// 获取方法所需要参数的Class对象数组
 
Class[] types = method.getParameterTypes();
 
// 判断methodName是否和方法名一致，若一致，再判断传递的参数个数是否一致。参数个数一致后再判断参数类型是否一致
 
if (method.getName().equals(methodName) && args.length == types.length
 
&& isEqualParamAndTypes(args, types)) {
 
// 都一致 执行该方法
 
return method.invoke(obj, args);
 
}
 
}
 
System.out.println("没有这个方法或参数不匹配");
 
return null;
 
}
 
/**
 
* 判断参数数组的类型是否与方法所需要的参数类型是否一致
 
* @param args 方法调用参数
 
* @param types 方法所需要的参数类型
 
* @return true代表一致，false不一致
 
*/
 
private static boolean isEqualParamAndTypes(Object[] args, Class[] types) {
 
boolean flag = false;
 
for (int i = 0; i < args.length; i++) {
 
String clsName = args[i].getClass().toString();
 
String typeName = types[i].toString();
 
// 上面获取参数的Class对象的字符串表示形式，是为了更好的去判断参数是否为基本数据类型。
 
// 这里还需要去判断方法参数是否为基本数据类型。 如果是，那么照样是可以通过的
 
if (clsName.equals(typeName) || isBasicType(clsName).equals(typeName)) {
 
flag = true;
 
} else {
 
flag = false;
 
break;
 
}
 
}
 
return flag;
 
}
 
/**
 
* 判断字节码文件对象的字符串表示形式是否为基本数据类型的包装类型，若是，则返回基本数据类型的class对象的字符串表示形式
 
* @param clsName 字节码文件(Class)对象的字符串表示形式
 
* @return 若是包装类型，返回对应类型的基本数据类型的class对象表示形式，若不是，则返回该字符串本身
 
*/
 
private static String isBasicType(String clsName) {
 
switch (clsName) {
 
case "class java.lang.Byte":
 
return "byte";
 
case "class java.lang.Short":
 
return "short";
 
case "class java.lang.Integer":
 
return "int";
 
case "class java.lang.Long":
 
return "long";
 
case "class java.lang.Float":
 
return "float";
 
case "class java.lang.Double":
 
return "double";
 
case "class java.lang.Character":
 
return "char";
 
case "class java.lang.Boolean":
 
return "boolean";
 
default:
 
return clsName;
 
}
 
}
 
结果： 能够成功的运行，并且能够很好的区分方法重载问题。
 
总结
 
这个练习题看似简单，但还是有不少坑是可以值得挖一挖的。
 
一开始我使用的是办法类似于方案1，在获取参数的Class对象时，判断一下是否为包装类型，若是，则转换成对应的基本类型的class。
 
判断条件:
 
if(args[i].getClass().getSimpleName().equals("Integer")){
 
cls[i] = int.class;
 
}else{
 
cls[i] = args[i].getClass();
 
}
 
这样转换会出现一个问题，当我指定一个方法的参数类型为Integer时，上面的判断条件又会将Integer类型转换为int.class，这样在getMethod(methodName,Class[] clsType)又会出现异常。这样使得在调用时必须确定方法的参数类型的class对象，又由于int.class和Integer.class不一样，上面的判断条件无法精确的判断方法的参数到底是int还是Integer类型。就很令人头痛。
 
于是我就想到假如我获取到所有的方法对象,并遍历每一个方法对象，判断传递的方法名称是否和遍历的方法名一致，这样我不就明确的知道了方法所需要的参数个数和参数的具体类型了吗。
 
知道了方法名 然后再通过传递的参数与方法所需要的参数进行匹配。一致，则调用该方法，不一致则不调用。
 
这就是方案2的思路，但是在判断类型时，我使用的是Class对象的字符串表示形式去判断而不是直接使用Class对象去判断，因为这样能够使用switch()判断，因为switch只接收基本数据类型和字符串类型的，而Class对象不在此范围内。
 
要是直接使用Class对象去比较判断的话，也不好解决。比如：获取到了参数的Class对象为Integer.class,判断时就是 if(cls == Integer.class){ cls = int.class} 这样就出现了上面一样的错误，假如方法参数要的是Integer.class 而上边判断又转成了int.class，这样不符合条件，就跳过了这一方法，这样一来方法就无法执行了。所以使用字符串比较就比较合理了，也就是如下的判断条件：
 
if (clsName.equals(typeName) || isBasicType(clsName).equals(typeName)) {
 
flag = true;
 
} else {
 
flag = false;
 
break;
 
}
 
这样判断的好处就是: 当传递的参数的Class对象字符串与方法需要的字符相同时，就符合条件。
 
当不一样时，再接着判断方法所需的参数是否是一个基本类型。若是，则符合条件。
 
这个程序大致就是这个样子了，但仍然还存在一些缺陷。如：当传递的参数是数组时，又出现了基本类型数组与包装类型数组的区别。这又需要去判断一下了。这里我就没有再过多的去完善它了。
 
通过写这个反射程序，让我不禁感慨写出一个健壮性很强的程序是多么的费事。更让我明白还有更多的知识等待着我去学习。
 
如果有更好的方法来实现这个功能，欢迎在评论中贴出来。