Java에서 클래스 개체가 다른 클래스 개체의 하위 클래스인지 확인합니다.

Java에서 클래스 개체가 다른 클래스 개체의 하위 클래스인지 확인합니다.

Java의 리플렉션 API를 가지고 놀면서 몇 가지 필드를 처리하려고 합니다.이제 나는 내 분야의 종류를 식별해야 한다.현악기는 쉬워요, 그냥 하세요.myField.getType().equals(String.class)다른 비파생 클래스도 마찬가지입니다.그러나 파생 클래스를 확인하려면 어떻게 해야 합니까?예.LinkedList의 아류로서List찾을 수가 없어요.isSubclassOf(...)또는extends(...)방법.내가 모든 걸 다 살펴볼 필요가 있나요?getSuperClass()내 수페클래스를 직접 찾을 수 있을까?

다음과 같은 방법이 필요합니다.

boolean isList = List.class.isAssignableFrom(myClass);

일반적으로는List(상기)는 다음과 같이 치환해야 합니다.superclass그리고.myClass로 대체해야 한다.subclass

JavaDoc에서:

클래스 또는 인터페이스가 이에 의해 표시되는지 여부를 판별합니다.Class오브젝트는 지정된 클래스 또는 인터페이스와 같거나 슈퍼클래스 또는 슈퍼인터페이스입니다.Class파라미터를 지정합니다.다시 돌아오다true있을 경우, 그렇지 않을 경우 반환됩니다.false이 경우Classobject는 기본 유형을 나타냅니다. 이 메서드는 반환됩니다.true지정된 경우Class파라미터는 바로 이것입니다.Class오브젝트. 그렇지 않으면 반환됩니다.false.

레퍼런스:

• Class.isAssignableFrom(Class)

---

연관된:

a) 오브젝트가 컴파일 시에 알고 있는 클래스 또는 인터페이스(서브 클래스 포함)의 인스턴스인지 확인합니다.

boolean isInstance = someObject instanceof SomeTypeOrInterface;

예:

assertTrue(Arrays.asList("a", "b", "c") instanceof List<?>);

b) 오브젝트가 실행 시에만 알고 있는 클래스 또는 인터페이스(서브 클래스 포함)의 인스턴스인지 확인합니다.

Class<?> typeOrInterface = // acquire class somehow
boolean isInstance = typeOrInterface.isInstance(someObject);

예:

public boolean checkForType(Object candidate, Class<?> type){
    return type.isInstance(candidate);
}

또 다른 옵션은 다음과 같습니다.

Object o =...
if (o instanceof Number) {
  double d = ((Number)o).doubleValue(); //this cast is safe
}

인스턴스(instance of instance)는 객체(Objects)에서 작동합니다.때로는 수업과 직접 일하고 싶을 때도 있습니다.이 경우 Class 클래스의 asSubClass 메서드를 사용할 수 있습니다.몇 가지 예:

1)

    Class o=Object.class;
    Class c=Class.forName("javax.swing.JFrame").asSubclass(o);

JFrame은 Object의 서브클래스이기 때문에 이 작업은 원활하게 진행됩니다.c에는 JFrame 클래스를 나타내는 Class 객체가 포함됩니다.

2)

    Class o=JButton.class;
    Class c=Class.forName("javax.swing.JFrame").asSubclass(o);

java.display가 실행됩니다.JFrame이 JButton.의 서브클래스가 아니기 때문에 ClassCastException은 초기화되지 않습니다.

3)

    Class o=Serializable.class;
    Class c=Class.forName("javax.swing.JFrame").asSubclass(o);

JFrame은 java.io을 구현하기 때문에 이 작업은 원활하게 진행됩니다.시리얼 가능한 인터페이스.c에는 JFrame 클래스를 나타내는 Class 객체가 포함됩니다.

물론 필요한 수입품도 포함되어야 한다.

이것으로 충분합니다.

protected boolean isTypeOf(String myClass, Class<?> superClass) {
    boolean isSubclassOf = false;
    try {
        Class<?> clazz = Class.forName(myClass);
        if (!clazz.equals(superClass)) {
            clazz = clazz.getSuperclass();
            isSubclassOf = isTypeOf(clazz.getName(), superClass);
        } else {
            isSubclassOf = true;
        }

    } catch(ClassNotFoundException e) {
        /* Ignore */
    }
    return isSubclassOf;
}

이것은 @schuttek의 답변을 개량한 것입니다.이것은, 프리미티브에 대해서 false를 올바르게 반환하고(예를 들면 isSubclassOf(int.class, Object.class) => false), 인터페이스(예를 들면 isSubclassOf(HashMap.class, Map.class) => true)를 올바르게 처리하기 때문에 개선됩니다.

static public boolean isSubclassOf(final Class<?> clazz, final Class<?> possibleSuperClass)
{
    if (clazz == null || possibleSuperClass == null)
    {
        return false;
    }
    else if (clazz.equals(possibleSuperClass))
    {
        return true;
    }
    else
    {
        final boolean isSubclass = isSubclassOf(clazz.getSuperclass(), possibleSuperClass);

        if (!isSubclass && clazz.getInterfaces() != null)
        {
            for (final Class<?> inter : clazz.getInterfaces())
            {
                if (isSubclassOf(inter, possibleSuperClass))
                {
                    return true;
                }
            }
        }

        return isSubclass;
    }
}

으로, 재귀적인 방법으로, 재귀적인지 합니다.Class<?>는 다른 의 하위 클래스입니다.Class<?>

@To Kra의 답변이 개선되었습니다.

protected boolean isSubclassOf(Class<?> clazz, Class<?> superClass) {
    if (superClass.equals(Object.class)) {
        // Every class is an Object.
        return true;
    }
    if (clazz.equals(superClass)) {
        return true;
    } else {
        clazz = clazz.getSuperclass();
        // every class is Object, but superClass is below Object
        if (clazz.equals(Object.class)) {
            // we've reached the top of the hierarchy, but superClass couldn't be found.
            return false;
        }
        // try the next level up the hierarchy.
        return isSubclassOf(clazz, superClass);
    }
}

//상속

    class A {
      int i = 10;
      public String getVal() {
        return "I'm 'A'";
      }
    }

    class B extends A {
      int j = 20;
      public String getVal() {
        return "I'm 'B'";
      }
    }

    class C extends B {
        int k = 30;
        public String getVal() {
          return "I'm 'C'";
        }
    }

//방법

    public static boolean isInheritedClass(Object parent, Object child) {
      if (parent == null || child == null) {
        return false;
      } else {
        return isInheritedClass(parent.getClass(), child.getClass());
      }
    }

    public static boolean isInheritedClass(Class<?> parent, Class<?> child) {
      if (parent == null || child == null) {
        return false;
      } else {
        if (parent.isAssignableFrom(child)) {
          // is child or same class
          return parent.isAssignableFrom(child.getSuperclass());
        } else {
          return false;
        }
      }
    }

// 코드 테스트

    System.out.println("isInheritedClass(new A(), new B()):" + isInheritedClass(new A(), new B()));
    System.out.println("isInheritedClass(new A(), new C()):" + isInheritedClass(new A(), new C()));
    System.out.println("isInheritedClass(new A(), new A()):" + isInheritedClass(new A(), new A()));
    System.out.println("isInheritedClass(new B(), new A()):" + isInheritedClass(new B(), new A()));


    System.out.println("isInheritedClass(A.class, B.class):" + isInheritedClass(A.class, B.class));
    System.out.println("isInheritedClass(A.class, C.class):" + isInheritedClass(A.class, C.class));
    System.out.println("isInheritedClass(A.class, A.class):" + isInheritedClass(A.class, A.class));
    System.out.println("isInheritedClass(B.class, A.class):" + isInheritedClass(B.class, A.class));

//결과

    isInheritedClass(new A(), new B()):true
    isInheritedClass(new A(), new C()):true
    isInheritedClass(new A(), new A()):false
    isInheritedClass(new B(), new A()):false
    isInheritedClass(A.class, B.class):true
    isInheritedClass(A.class, C.class):true
    isInheritedClass(A.class, A.class):false
    isInheritedClass(B.class, A.class):false

@To-kra의 답변에 더해서.반복을 좋아하지 않는 경우:

    public static boolean isSubClassOf(Class<?> clazz, Class<?> superClass) {
        if(Object.class.equals(superClass)) {
            return true;
        }

        for(; !Object.class.equals(clazz); clazz = clazz.getSuperclass()) {
            if(clazz.getSuperclass().equals(superClass)) {
                return true;
            }
        }

        return false;
    }

메모: 명확하게 하기 위해 특수한 체크는 없습니다.

언급URL : https://stackoverflow.com/questions/4584541/check-if-a-class-object-is-subclass-of-another-class-object-in-java