Class.isAssignableFrom与 instanceof 区别

本文介绍了Java中如何使用isAssignableFrom方法判断一个类是否为另一个类的超类或实现接口,以及如何使用instanceof关键字检查对象是否为特定类或接口的实例。通过示例代码展示了这两种方法的具体应用。
isAssignableFrom 是用来判断一个类Class1和另一个类Class2是否相同或是另一个类的超类或接口。
通常调用格式是
Class1.isAssignableFrom (Class2)
调用者和参数都是 java.lang.Class 类型。

而 instanceof 是用来判断一个对象实例是否是一个类或接口的或其子类子接口的实例。
格式是: oo instanceof TypeName
第一个参数是对象实例名,第二个参数是具体的类名或接口名
具体例子如下:

public class TestCase {
public static void main(String[] args) {
TestCase test = new TestCase();
test.testIsAssignedFrom1();
test.testIsAssignedFrom2();
test.testIsAssignedFrom3();
test.testInstanceOf1();
test.testInstanceOf2();
}

public void testIsAssignedFrom1() {
System.out.println(String.class.isAssignableFrom(Object.class));
}

public void testIsAssignedFrom2() {
System.out.println(Object.class.isAssignableFrom(Object.class));
}

public void testIsAssignedFrom3() {
System.out.println(Object.class.isAssignableFrom(String.class));
}

public void testInstanceOf1() {
String ss = "";
System.out.println(ss instanceof Object);
}

public void testInstanceOf2() {
Object o = new Object();
System.out.println(o instanceof Object);
}

}


打印结果:

false
true
true
true
true
/** * 自动关联 * @param e * @param <T> * @throws IllegalAccessException * @throws ClassNotFoundException */ private static <T extends SynchronizableEntity> void setDefaultAssociation(SynchronizedList<T> e ) throws IllegalAccessException, ClassNotFoundException { for (T t:e) { Class clazz=t.getClass(); Field[] fields = clazz.getDeclaredFields(); for (Field f:fields){ f.setAccessible(true); Class s=f.getType(); if(SynchronizableEntity.class.isAssignableFrom(s)){ if (t.getId()<0 ||f.get(t)==null|| ((SynchronizableEntity)f.get(t)).getId()==null) { f.set(t, dataCollectionMap.get(s).get(0)); }else { f.set(t, dataCollectionMap.get(s).get( ((SynchronizableEntity)f.get(t)).getId())); } } if (List.class.isAssignableFrom(s)){ Type genericSuperclass = s.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) genericSuperclass; Type[] types = pt.getActualTypeArguments(); // System.out.println("集合类型: " + types[0].getTypeName()); // User Log.d(TAG, "setDefaultAssociation: "+types[0].getTypeName()); Class c=Class.forName(types[0].getTypeName()); if(SynchronizableEntity.class.isAssignableFrom(c)) { List<SynchronizableEntity> l = (List<SynchronizableEntity>) f.get(t); if (l == null) { l = new ArrayList(); } if (l.isEmpty() || t.getId() < 0) { l.add(dataCollectionMap.get(c).get(0)); } if (!l.isEmpty()) { for (int i = 0; i < l.size(); i++) { //Log.d(TAG, "setDefaultAssociation: "); l.set(i,dataCollectionMap.get(c).get( l.get(i).getId())); } } } } } } } }
06-13
package com.example.kucun2.DataPreserver; import android.util.Log; import com.example.kucun2.entity.data.SynchronizableEntity; import com.example.kucun2.entity.data.SynchronizedList; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List; public class DataAssociator { private final DataStore dataStore; public DataAssociator(DataStore dataStore) { this.dataStore = dataStore; } public void automaticAssociation() { dataStore.dataCollectionMap.keySet().forEach(entityClass -> { try { associateEntities(dataStore.dataCollectionMap.get(entityClass)); } catch (Exception e) { Log.e("DataAssociator", "关联失败: " + entityClass.getSimpleName(), e); } }); } private void associateEntities(SynchronizedList<?> list) throws Exception { for (SynchronizableEntity entity : list.getViewList()) { if (entity == null) continue; for (Field field : entity.getClass().getDeclaredFields()) { field.setAccessible(true); Class<?> fieldType = field.getType(); if (SynchronizableEntity.class.isAssignableFrom(fieldType)) { associateSingleReference(entity, field); } else if (List.class.isAssignableFrom(fieldType)) { associateReferenceList(entity, field); } } } } private void associateSingleReference(SynchronizableEntity entity, Field field) throws Exception { SynchronizableEntity ref = (SynchronizableEntity) field.get(entity); if (ref == null) return; Class<?> targetType = field.getType(); SynchronizableEntity target = findTargetEntity(ref, targetType); field.set(entity, target); } private SynchronizableEntity findTargetEntity(SynchronizableEntity ref, Class<?> targetType) { SynchronizedList<?> targetList = dataStore.dataCollectionMap.get(targetType); if (targetList == null) return null; // 预置对象特殊处理 if (ref.getId() == -1) { return targetList.getViewList().stream() .filter(e -> e.getId() == -1) .findFirst().orElse(null); } // 根据ID查找实体 return targetList.getViewList().stream() .filter(e -> ref.getId().equals(e.getId())) .findFirst() .orElse(null); } private void associateReferenceList(SynchronizableEntity entity, Field field) throws Exception { Type genericType = field.getGenericType(); if (!(genericType instanceof ParameterizedType)) return; Type itemType = ((ParameterizedType) genericType).getActualTypeArguments()[0]; if (!(itemType instanceof Class) || !SynchronizableEntity.class.isAssignableFrom((Class<?>) itemType)) { return; } List<?> refList = (List<?>) field.get(entity); if (refList == null) { field.set(entity, new ArrayList<>()); return; } List<SynchronizableEntity> resolvedList = new ArrayList<>(); for (Object ref : refList) { if (ref instanceof SynchronizableEntity) { SynchronizableEntity resolved = findTargetEntity( (SynchronizableEntity) ref, (Class<?>) itemType ); if (resolved != null) resolvedList.add(resolved); } } field.set(entity, resolvedList); } } 详细注释
06-25
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值