java 判断class对象是否为某个类 java判断class相等

转载

huatechinfo 2023-07-16 09:58:26

文章标签 Java 反射自定义错误类数据字段 文章分类 Java 后端开发

思维①：创建一个类，在类中写一个静态方法传递两个参数（Object类型），获取Class类型的对象后调用反射获取所有字段，循环遍历判断是否相等，若不相等停止循环返回false，若都相等最后返回true。

思维②：创建一个类，有三个字段一个为Field[] 类型，一个为Object 类型，一个为Class类型的对象，第一个储存获取到的字段集合，第二个储存数据，第三个储存Class类型的对象。通过传递数据（Object类型）构造这三个字段。在写一个比对数据的方法传递一条需要比对的数据，然后直接循环遍历判断是否相等（在传递数据构造类的时候已经反射了所有字段储存在类中）若不相等停止循环返回false，若都相等最后返回true。

扩展：通过自定义异常类实现手动抛出异常并处理异常给与提示。

（一）自定义异常类

/**
 * 自定义提示异常
 * @author 织梦
 *传递提示文字
 */
class PromptException extends Exception{  //继承异常基类
 private String promptMessage;  //提示文字
 public PromptException(String msg){ //构造提示文字
  this.promptMessage = msg;
 }
 public String getPromptException() { //获取提示文字的方法
  return this.promptMessage;
 }
}

自定义异常类是为了让方法的使用者更好的了解方法如何使用，使用不规范会给出相应提示。

（二）思维①写法

* @param oldClassData
  * @param newClassData
  * @return 比对两条数据是否相等（静态）
  */
 public static boolean comparisonOutside(Object oldClassData,Object newClassData){ //思维①写法
  boolean b = true;
  Class<?> class1 = oldClassData.getClass(); //获取Class类型的对象
  Class<?> class2 = newClassData.getClass();
  if (!class1.equals(class2)) {  //判断传递过来的数据类型是否一致
    try {
    throw new PromptException("请传递两条相同类型的数据！！！"); //抛出自定义异常
   } catch (PromptException e) {
    // TODO Auto-generated catch block
    System.out.println(e.getPromptException()); //处理自定义异常
    e.printStackTrace();
   }
  }
  Field[] field =class1.getDeclaredFields(); //获取所有成员字段
  for (int i = 0; i < field.length; i++) {  //循环遍历成员字段
   try {
    field[i].setAccessible(true);  //启用访问权限，
    if (!field[i].get(oldClassData).equals(field[i].get(newClassData))){  //分别访问数据判断是否相等
     b = false;   //不相等则将b赋值为false，且退出循环
     break;
    }
   } catch (IllegalArgumentException e) {  //参数无效异常（不会触发）
    // TODO Auto-generated catch block
    b = false;
    e.printStackTrace();
   } catch (IllegalAccessException e) { //类拒绝访问异常（无权限异常）（不会触发）若没有启用访问权限则有可能触发
    // TODO Auto-generated catch block
    System.out.println("拒绝访问");
    b = false;
    e.printStackTrace();
   }
  }
  return  b;
 }

方法接收两个Object对象，返回布尔值提示传递的两条数据是否相等。

第一步：首先分别获取Class类型的对象判断是否相等，若相等则两天数据类型一致，若不相等则抛出异常提示。

第二步：利用反射获取所有成员字段集合。

第三步：循环遍历成员字段，启用访问权限（打破封装），分别访问数据判断是否相等，若不相等直接跳出循环并返回false

（三）思维②写法

class ComparisonClass{
 public Field[] field; //储存所有成员字段
 public Object sourceData; //储存源数据
 public Class<?> class1; //源数据的Class类型的对象
 public ComparisonClass(Object classData){ //构造函数
  this.sourceData = classData; 
  this.class1 = classData.getClass();
  this.field = this.class1.getDeclaredFields();
 }
  /**
     * 
     * @param object
     * @return 比对两条数据是否相等
     */
 public boolean comparisonInterior(Object object){
  boolean b = true;
  if (!class1.equals(object.getClass())) {   //判断传递过来的数据类型是否一致
    try {
    throw new PromptException("请传递两条相同类型的数据！！！"); //抛出自定义异常
   } catch (PromptException e) {
    // TODO Auto-generated catch block
    System.out.println(e.getPromptException()); //处理自定义异常
    e.printStackTrace();
   }
  }
  for (int i = 0; i < this.field.length; i++) { //循环遍历成员字段
   try {
    field[i].setAccessible(true);  //启用访问权限，
    if (!this.field[i].get(this.sourceData).equals(this.field[i].get(object))) { //分别访问数据判断是否相等
     b = false;
     break;
    }
   } catch (IllegalArgumentException e) { //参数无效异常（不会触发）
    // TODO Auto-generated catch block
    b = false;
    e.printStackTrace();
   } catch (IllegalAccessException e) { //类拒绝访问异常（无权限异常）（不会触发）若没有启用访问权限则有可能触发
    // TODO Auto-generated catch block
    b = false;
    System.out.println("拒绝访问");
    e.printStackTrace();
   }
  }
  return  b;
 }
}

方法接收一个Object对象，在使用方法前需要先实例化类。

第一步：实例化类传递一个Object对象，通过构造函数分别给字段赋值（所有成员字段的集合，Class类型的对象，源数据）。

第二步：调用方法传递一个Object对象，获取这个对象的Class类型的对象与字段中储存的是否相等，若相等则两天数据类型一致，若不相等则抛出异常提示。

第三步：循环遍历类中成员字段集合，启用访问权限（打破封装），分别访问传递过来的数据与类中储存的数据判断是否相等，若不相等直接跳出循环并返回false

总结：自定义的异常能够很好的提示使用者使用规范，不必等当出现异常再去挽回，先用if判断避免后续代码异常的发生可以很好的提高代码的性能，并且给出相应的提醒。

（四）调用示例

public class HelloWord {
 public static void main(String[] args){
  Text1 text1 = new Text1(1,"2");
  Text1 text2 = new Text1(1,"3");
  System.out.println(ComparisonClass.comparisonOutside(1,1));  //true
  System.out.println(ComparisonClass.comparisonOutside(1,2));  //false
  System.out.println(ComparisonClass.comparisonOutside(1,"2"));  //抛出自定义异常，给与提示信息
  System.out.println(ComparisonClass.comparisonOutside(text1,text2)); //false
  ComparisonClass comparisonClass = new ComparisonClass(text1); 
  text2.str1 = "2";
  System.out.println(comparisonClass.comparisonInterior(text2)); //true
  System.out.println(comparisonClass.comparisonInterior("2")); // 抛出自定义异常，给与提示信息
 }
}
class Text1{
 private int inta1;
 public String str1;
 public Text1(int a,String b){
  this.inta1 = a;
  this.str1 =b;
 }
}