java isAssignableFrom 使用示例

最新推荐文章于 2025-03-26 11:04:23 发布
最新推荐文章于 2025-03-26 11:04:23 发布
阅读量1k 收藏 30
点赞数 26
分类专栏： java basic 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_rockefeller/article/details/144854909
版权

好的，下面我将通过多个具体的类和子类示例，展示在不同情况下 isAssignableFrom 如何工作，以及在你的代码逻辑中如何处理这些情况。我们将讨论以下几种场景：

  1. 同名字段且类型相同
  2. 同名字段但子类字段类型为父类字段类型的子类
  3. 同名字段但类型不兼容
  4. 不同字段名的情况
  5. 更复杂的继承层级

场景设置

假设我们有一个父类 Parent 和其子类 Child，以及另一个独立的类 Unrelated。我们将通过这些类的不同字段组合，展示 isAssignableFrom 的行为。

import java.lang.reflect.Field;
import java.util.*;

class ReflectionUtil {
    public static List<Field> getAllFields(List<Field> fields, Class<?> type, Predicate<Field> filter) {
        for (Field field : type.getDeclaredFields()) {
            if (filter.test(field)) {
                fields.add(field);
            }
        }
        if (type.getSuperclass() != null) {
            getAllFields(fields, type.getSuperclass(), filter);
        }
        return fields;
    }
}

@FunctionalInterface
interface Predicate<T> {
    boolean test(T t);
}

public class FieldMapExample {

    static class Parent {
        public String name;
        public Object data;
        public Number value;
    }

    static class Child extends Parent {
        public Integer value; // Overrides Parent's 'value' with a more specific type
        public Double extra;
    }

    static class Unrelated {
        public String description;
    }

    public static void main(String[] args) {
        FieldMapExample example = new FieldMapExample();
        example.processFields();
    }

    private void processFields() {
        Map<String, Field> fieldMap = null;

        if (fieldMap == null) {
            List<Field> fields = ReflectionUtil.getAllFields(
                new LinkedList<>(), getClass(), this::isParameterField);
            fieldMap = new HashMap<>(fields.size());
            fields.forEach(field -> {
                if (fieldMap.containsKey(field.getName())) {
                    Field finalField = fieldMap.get(field.getName());
                    if (!finalField.getClass().isAssignableFrom(field.getClass())) {
                        fieldMap.put(field.getName(), field);
                        System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
                    }
                } else {
                    fieldMap.put(field.getName(), field);
                    System.out.println("Added field '" + field.getName() + "' from " + field.getDeclaringClass().getSimpleName());
                }
            });
        }

        // 输出最终的 fieldMap 内容
        System.out.println("\nFinal fieldMap:");
        fieldMap.forEach((name, field) -> {
            System.out.println("Field Name: " + name + ", Declared In: " + field.getDeclaringClass().getSimpleName() + ", Type: " + field.getType().getSimpleName());
        });
    }

    private boolean isParameterField(Field field) {
        // 仅示例：接受所有字段
        return true;
    }
}

类定义说明

  • Parent 类：

    • name：类型为 String
    • data：类型为 Object
    • value：类型为 Number

  • Child 类（继承自 Parent）：

    • 继承了 Parent 的所有字段。
    • 重写了 value 字段，类型变为 Integer（更具体的子类型）。
    • 新增了 extra 字段，类型为 Double

  • Unrelated 类：

    • description：类型为 String

执行 processFields 方法

在 processFields 方法中，我们通过反射获取所有字段，并根据字段名和类型进行处理。每当处理一个字段时，系统会输出添加或替换操作的日志，最后输出 fieldMap 的内容。

场景 1：同名字段且类型相同

类定义：

static class Parent {
    public String name;
}

static class Child extends Parent {
    // 没有重写 'name' 字段
}

预期行为：

  • Parent 和 Child 都有 name 字段，类型相同（String）。
  • isAssignableFrom 判定为 true（Field 类相同）。
  • 不会替换已有的 fieldMap 中的 name 字段。

输出：

Added field 'name' from Parent

Final fieldMap:
Field Name: name, Declared In: Parent, Type: String

场景 2：同名字段但子类字段类型为父类字段类型的子类

类定义：

static class Parent {
    public Number value;
}

static class Child extends Parent {
    public Integer value; // 更具体的类型
}

预期行为：

  • Parent 和 Child 都有 value 字段。
  • 子类的 value 字段类型 (Integer) 是父类的 value 字段类型 (Number) 的子类。
  • finalField.getClass() 和 field.getClass() 都是 Field 类，相同。
  • 因为 Field 类本身不具有继承关系，仅仅判断 Field 类类型相同，所以 isAssignableFrom 返回 true。
  • 注意：在实际代码中，这个判断可能无法达到预期效果，因为 Field 类一般不会有自身的子类，除非有自定义的 Field 实现。

输出：

Added field 'value' from Parent
Added field 'value' from Child

Final fieldMap:
Field Name: value, Declared In: Parent, Type: Number
Field Name: value, Declared In: Child, Type: Integer

问题说明：
在这种情况下，由于 Field 类本身没有继承关系，isAssignableFrom 会始终返回 true（因为 finalField.getClass() 和 field.getClass() 都是 Field）。所以字段会被替换或保留，具体取决于类加载器和反射实现。但在标准 Java Field 类中，这种替换通常不会发生。

场景 3：同名字段但类型不兼容

类定义：

static class Parent {
    public String name;
}

static class Child extends Parent {
    public Integer name; // 不兼容类型
}

预期行为：

  • Parent 和 Child 都有 name 字段，但类型不同（String vs Integer）。
  • finalField.getClass() 和 field.getClass() 依然是 Field 类，相同。
  • 因为 Field 类相同，isAssignableFrom 返回 true，不会替换。
  • 注意：在实际反射中，同名字段将导致一个类隐藏另一个类的字段，而不是用不同类型的字段替换。在反射操作中，你需要根据具体需求手动处理这些情况。

输出：

Added field 'name' from Parent
Added field 'name' from Child

Final fieldMap:
Field Name: name, Declared In: Parent, Type: String
Field Name: name, Declared In: Child, Type: Integer

场景 4：不同字段名的情况

类定义：

static class Parent {
    public String name;
}

static class Child extends Parent {
    public Integer age;
}

预期行为：

  • Parent 有 name 字段，Child 有 age 字段。
  • 两个字段名不同，直接添加到 fieldMap 中。

输出：

Added field 'name' from Parent
Added field 'age' from Child

Final fieldMap:
Field Name: name, Declared In: Parent, Type: String
Field Name: age, Declared In: Child, Type: Integer

场景 5：更复杂的继承层级

类定义：

static class GrandParent {
    public Object data;
}

static class Parent extends GrandParent {
    public Number num;
}

static class Child extends Parent {
    public Integer num; // 更具体的类型
    public Double extra;
}

预期行为：

  • GrandParent 有 data 字段。
  • Parent 继承 GrandParent，添加 num 字段。
  • Child 继承 Parent，重写 num 字段（从 Number 到 Integer），并新增 extra 字段。
  • 根据 isAssignableFrom，因为字段类型都是 Field 类，判断返回 true，不会替换。
  • 所有同名字段会被重复添加，因为字段名相同且 Field 类相同。

输出：

Added field 'extra' from Child
Added field 'num' from Parent
Added field 'num' from Child
Added field 'data' from GrandParent

Final fieldMap:
Field Name: extra, Declared In: Child, Type: Double
Field Name: num, Declared In: Parent, Type: Number
Field Name: num, Declared In: Child, Type: Integer
Field Name: data, Declared In: GrandParent, Type: Object

分析与改进

从上面的各个场景可以看出，isAssignableFrom 对于 Field 类的使用并不能正确处理字段类型的继承或覆盖关系，因为 Field 类本身并没有子类化（除非你自定义了 Field 类的子类）。这意味着无论字段类型如何，finalField.getClass() 和 field.getClass() 大多数情况下都是相同的 Field 类。

因此，要实现根据字段类型的继承关系来替换 fieldMap 中的字段，你需要修改判断逻辑，基于字段类型 (field.getType()) 进行比较，而不是 Field 对象本身的类类型。下面是改进后的示例：

改进后的判断逻辑

if (!finalField.getType().isAssignableFrom(field.getType())) {
    fieldMap.put(field.getName(), field);
    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
}

说明：

  • 我们使用 finalField.getType().isAssignableFrom(field.getType()) 来比较字段的类型。
  • 如果当前字段 (field) 的类型不能赋值给已有字段 (finalField) 的类型，则替换。

改进后的代码示例

修改 processFields 方法如下：

private void processFields() {
    Map<String, Field> fieldMap = null;

    if (fieldMap == null) {
        List<Field> fields = ReflectionUtil.getAllFields(
            new LinkedList<>(), getClass(), this::isParameterField);
        fieldMap = new HashMap<>(fields.size());
        fields.forEach(field -> {
            if (fieldMap.containsKey(field.getName())) {
                Field finalField = fieldMap.get(field.getName());
                if (!finalField.getType().isAssignableFrom(field.getType())) {
                    fieldMap.put(field.getName(), field);
                    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
                }
            } else {
                fieldMap.put(field.getName(), field);
                System.out.println("Added field '" + field.getName() + "' from " + field.getDeclaringClass().getSimpleName());
            }
        });
    }

    // 输出最终的 fieldMap 内容
    System.out.println("\nFinal fieldMap:");
    fieldMap.forEach((name, field) -> {
        System.out.println("Field Name: " + name + ", Declared In: " + field.getDeclaringClass().getSimpleName() + ", Type: " + field.getType().getSimpleName());
    });
}

使用改进后的逻辑重新分析场景

场景 2（改进后）：同名字段但子类字段类型为父类字段类型的子类

类定义：

static class Parent {
    public Number value;
}

static class Child extends Parent {
    public Integer value; // 更具体的类型
}

预期行为：

  • Parent.value 类型为 Number
  • Child.value 类型为 Integer，是 Number 的子类
  • finalField.getType().isAssignableFrom(field.getType())：
    • Number.class.isAssignableFrom(Integer.class) 返回 true
  • 不进行替换，因为子类字段类型是父类字段类型的子类型，已经是兼容的。

输出：

Added field 'value' from Parent

Final fieldMap:
Field Name: value, Declared In: Parent, Type: Number

如果需要保留更具体的类型，可以调整判断逻辑：

如果你希望在子类中有更具体的字段类型时，优先使用子类的字段，可以修改判断逻辑为：

if (finalField.getType().isAssignableFrom(field.getType())) {
    fieldMap.put(field.getName(), field);
    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
}

这样，当子类的字段类型是父类字段类型的子类时会进行替换。

场景 3（改进后）：同名字段但类型不兼容

类定义：

static class Parent {
    public String name;
}

static class Child extends Parent {
    public Integer name; // 不兼容类型
}

预期行为：

  • Parent.name 类型为 String
  • Child.name 类型为 Integer，与 String 不兼容
  • finalField.getType().isAssignableFrom(field.getType())：
    • String.class.isAssignableFrom(Integer.class) 返回 false
  • 进行替换，因为新字段类型不兼容

输出：

Added field 'name' from Parent
Replaced field 'name' with Child

Final fieldMap:
Field Name: name, Declared In: Child, Type: Integer

最终总结

通过修改判断逻辑，从比较 Field 类本身改为比较字段的类型 field.getType()，我们可以更准确地控制字段的替换和添加行为。以下是改进后的关键判断逻辑：

if (!finalField.getType().isAssignableFrom(field.getType())) {
    fieldMap.put(field.getName(), field);
    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
}

或根据需求调整为：

if (finalField.getType().isAssignableFrom(field.getType())) {
    fieldMap.put(field.getName(), field);
    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
}

选择哪种逻辑取决于你的具体需求：

  • 保留更具体的类型：当子类的字段类型是父类字段类型的子类时，替换
  • 保留最初的类型：仅当新字段类型不兼容时，替换

通过这种方式，你可以确保 fieldMap 中存储的字段类型是你所期望的，并且避免类型不兼容的问题。

完整的改进后代码示例

private void processFields() {
    Map<String, Field> fieldMap = null;

    if (fieldMap == null) {
        List<Field> fields = ReflectionUtil.getAllFields(
            new LinkedList<>(), getClass(), this::isParameterField);
        fieldMap = new HashMap<>(fields.size());
        fields.forEach(field -> {
            if (fieldMap.containsKey(field.getName())) {
                Field finalField = fieldMap.get(field.getName());
                // 根据需求选择以下其中一种判断逻辑

                // 逻辑一：替换不兼容的字段
                if (!finalField.getType().isAssignableFrom(field.getType())) {
                    fieldMap.put(field.getName(), field);
                    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
                }
                
                // 逻辑二：替换更具体的字段
                /*
                if (finalField.getType().isAssignableFrom(field.getType())) {
                    fieldMap.put(field.getName(), field);
                    System.out.println("Replaced field '" + field.getName() + "' with " + field.getDeclaringClass().getSimpleName());
                }
                */
            } else {
                fieldMap.put(field.getName(), field);
                System.out.println("Added field '" + field.getName() + "' from " + field.getDeclaringClass().getSimpleName());
            }
        });
    }

    // 输出最终的 fieldMap 内容
    System.out.println("\nFinal fieldMap:");
    fieldMap.forEach((name, field) -> {
        System.out.println("Field Name: " + name + ", Declared In: " + field.getDeclaringClass().getSimpleName() + ", Type: " + field.getType().getSimpleName());
    });
}

运行示例

以下是使用改进后的逻辑运行场景 3 的完整输出：

类定义：

static class Parent {
    public String name;
}

static class Child extends Parent {
    public Integer name; // 不兼容类型
}

输出：

Added field 'name' from Parent
Replaced field 'name' with Child

Final fieldMap:
Field Name: name, Declared In: Child, Type: Integer

借助优化后的判断逻辑，fieldMap 可以根据字段类型的继承关系更准确地进行管理，从而满足更复杂的业务需求。

如果你有更具体的用例或需要进一步的解释，请随时提问！

JAVA：使用 XStream 实现对象与XML转换的技术指南
木头
05-02 223
JAVA：使用 XStream 实现对象与XML转换的技术指南
isAssignableFrom
03-01
isAssignableFrom_example.rar 博文链接：https://pepa.iteye.com/blog/242507
Java中isAssignableFrom的用法
weixin_34356310的博客
01-07 704
 class1.isAssignableFrom(class2) 判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。如果是则返回 true；否则返回 false。如果该 Class表示一个基本类型，且指定的 Class 参数正是该 Class 对象，则该方法返回 true；否则返回 false。  1.class2是不是c...
关于 isAssignableFrom, isInstance(), instanceof 的使用
最新发布
yngzh的博客
03-26 155
以上返回均为boolean值。
java isAssignableFrom
liu_rockefeller的博客
12-31 1661
cls)功能：判断当前Class对象所表示的类或接口是否与指定的Class参数cls所表示的类或接口相同，或是否是它的超类或超接口。返回值返回true：如果当前Class对象表示的类或接口与参数cls表示的类或接口相同，或是参数类的超类或超接口。返回false：否则。是一个强大的工具，用于动态判断类之间的兼容性和继承关系。在你提供的代码中，它用于确保fieldMap中存储的Field对象是类型最兼容的版本，从而在后续的反射操作中避免潜在的类型冲突和错误。通过深入理解。
java中isAssignableFrom()方法与instanceof关键字用法及通过反射配合注解为字段设置默认值
热门推荐
wkNote
07-26 11万+
isAssignableFrom()方法与instanceof关键字的区别总结为以下两个点： isAssignableFrom()方法是从类继承的角度去判断，instanceof关键字是从实例继承的角度去判断。 isAssignableFrom()方法是判断是否为某个类的父类，instanceof关键字是判断是否某个类的子类。 使用方法： 父类.class.isAssignableF...
Java基础- isAssignableFrom() 检查类型之间的兼容性
青衫客36的博客
10-26 598
cls)参数Class cls，即要进行检查的类对象。返回值boolean，返回true表示当前类可以从指定类赋值，否则返回false。方法是Java中一个实用的工具，用于在类加载和类型兼容性判断时检查类间的赋值关系。它让开发者能够在运行时进行灵活的类型验证，从而安全地执行类型相关操作。
Java中isAssignableFrom的用法详解
08-31
在Java编程语言中，`Class` 类提供了一个非常有用的方法 `isAssignableFrom()`. 这个方法主要用于判断一个类或接口是否可以被赋值给另一个类或接口，即判断前者是否是后者的超类或超接口。这个功能在泛型、反射以及...
深入理解Java方法isAssignableFrom的应用示例
关于标签，给出的"源码 工具"表明这个主题不仅涉及深入理解Java类继承的机制，而且可能涉及到使用某种开发工具或者调试工具来观察和分析"isAssignableFrom"在运行时的应用情况。标签暗示了可能需要查看源代码来更好...
Java类和成员上的一些方法实例代码
08-28
在上面的示例代码中，我们使用了isAssignableFrom方法来判断Son类是否是Parent类的子类，结果表明，Son类是Parent类的子类，Parent类是Son类的父类。 三、transient关键字 transient关键字是Java语言中用于修饰...
java class isassignablefrom_Java中isAssignableFrom的用法详解
weixin_35823441的博客
02-24 274
class1.isAssignableFrom(class2) 判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。如果是则返回 true；否则返回 false。如果该 Class 表示一个基本类型，且指定的 Class 参数正是该 Class 对象，则该方法返回 true；否则返回 false。1. class2是不是class1的...
java：isAssignableFrom方法使用及instanceof对比
a232884c的博客
02-28 1026
Class类的方法isAssignableFrom，常见于源码中判断父子类关系时使用。X.class.isAssignableFrom(Y.class)，表示判断Y是否为X的子类（或Y接口（类）是否继承（实现）了X接口），均适用于类或接口中，且X.class.isAssignableFrom(X.class)仍返回true。isAssignableFrom为native方法，底层使用C/C++实现。instanceof为java中判断实例对象是否为某个类的类型的关键字，同常见于框架源码中使用。
Java中isAssignableFrom()与instanceof()方法用法
陈德山
06-21 1936
      isAssignableFrom()方法是从类继承的角度去判断，判断是否为某个类的父类。      instanceof()方法是从实例继承的角度去判断，判断是否某个类的子类。      例如：Class1.isAssignableFrom(Class2) 是用来判断一个类Class1和另一个类Class2是否相同或是另一个类的子类或接口。  调用者和参数都是java.lang.Cla...
【Java】isAssignableFrom()和instanceof
mizepeng的博客
03-31 261
.isAssignableFrom()方法与instanceof关键字的区别总结为以下两个点： isAssignableFrom()方法是从类继承的角度去判断，instanceof关键字是从实例继承的角度去判断。 isAssignableFrom()方法是判断是否为某个类的父类，instanceof关键字是判断是否某个类的子类。 使用方法： 父类.class.isAssignableFrom(子类.class) 子类实例 instanceof 父类类型 原文链接：https://blog.csdn
isAssignableFrom()
xushuai0095的博客
12-31 478
isAssignableFrom() instanceof 关键字用法 通过反射配合注解为字段设置默认值 isAssignableFrom()方法是从类继承的角度去判断，instanceof关键字是从实例继承的角度去判断。 isAssignableFrom()方法是判断是否为某个类的父类，instanceof关键字是判断是否某个类的子类。 使用方法： 父类.class.isAssignableFrom(子类.class) 子类实例 instanceof 父类类型 ...
java isAssignableFrom 判断类是否相同或是否超类或是否超接口
sayyy的专栏
04-17 224
略
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值
OSZAR »