Java에서 a.getClass ()와 A.class의 차이점은 무엇입니까?

Java에서 a.getClass ()와 A.class의 차이점은 무엇입니까?

---

Java에서 a.getClass()또는 사용 선택을 둘러싼 장단점은 무엇 A.class입니까? 어느 쪽이든 a Class<?>가 예상 되는 곳이면 어디에서나 사용할 수 있지만 다른 상황에서 둘 다 사용하면 성능이나 기타 미묘한 이점이 있다고 생각합니다 (with Class.forName()및 ClassLoader.loadClass().

---

나는 그것들이 서로 다른 목적을 가지고 있고 둘 사이에 "선택"이 거의 없기 때문에 장단점 측면에서 비교하지 않을 것입니다.

• a.getClass()의 런타임 유형 을 반환합니다 a. 즉, 당신이있는 경우 A a = new B();다음 a.getClass()반환합니다 B클래스를.

• A.classA클래스를 정적으로 평가하고 반사와 관련된 다른 목적으로 사용됩니다.

성능면 에서 측정 가능한 차이 가있을 수 있지만 결국 JVM 및 / 또는 컴파일러에 따라 다르기 때문에 이에 대해 아무 말도하지 않겠습니다.

---

이 게시물은 여기 에 기사로 다시 작성되었습니다 .

---

실제로 사용할 수있는 위치에 따라 다릅니다. A.class컴파일 타임에 작동하지만 a.getClass()유형의 인스턴스가 필요하고 A런타임에 작동합니다.

성능 차이도있을 수 있습니다. 하지만 A.class그것의 실제 유형을 알고 있기 때문에 컴파일러에 의해 해결 될 수 A, a.getClass()실행시에 일어나는 가상 메소드 호출이다.

참고로 바이트 코드를 대상으로하는 컴파일러는 일반적으로에 대한 다음 명령어를 내 보냅니다 Integer.getClass().

aload_1
invokevirtual   #3; //Method java/lang/Object.getClass:()Ljava/lang/Class;

다음은 다음과 같습니다 Integer.class.

//const #3 = class  #16;    //  java/lang/Integer

ldc_w   #3; //class java/lang/Integer

전자는 일반적으로 가상 메서드 디스패치를 ​​포함하므로 실행하는 데 더 오래 걸릴 수 있습니다. 그러나 결국 JVM에 따라 다릅니다.

---

아래의 예를보세요

a.getClass()!= A.class즉 a는 A의 인스턴스가 아니라 A의 익명 하위 클래스입니다.

a.getClass() 유형 A의 인스턴스가 필요합니다.

---

a.getClass클래스 / 유형의 인스턴스가 있고 정확한 유형을 얻고 싶을 때 사용 합니다. while a.class은 사용 type가능하고 인스턴스를 작성하려는 경우에 사용됩니다.
또한 컴파일 타임에 평가되는 getClass()동안 인스턴스의 런타임 유형을 반환합니다 .class.
의 성능을 고려 getClass()하고 .class, .class보다 더 나은 성능을 가지고 getClass().
예 :

public class PerfomanceClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        long time=System.nanoTime();
        Class class1="String".getClass();
        class1="String".getClass();
        class1="String".getClass();
        class1="String".getClass();

        System.out.println("time (getClass()) :"+(System.nanoTime()-time)+" ns");     


        long time2=System.nanoTime();
        Class class2=String.class;
        class2=String.class;
        class2=String.class;
        class2=String.class;

        System.out.println("time (.class):"+(System.nanoTime()-time2)+" ns");
    }

}

출력 :

time (getClass()) : 79410 ns
time (.class)     : 8032 ns

---

There is one difference i would like to add. Let us say you have a class a constructor as shown below with a super class which takes a Class object. You want that whenever a subclass object is created the subClass' class object should be passed to the super class. Below code will not compile as you cannot call an instance method in a constructor. In that case if you replace myObject.getClass() with MyClass.class. It will run perfectly.

Class MyClass
{
    private MyClass myObject = new MyClass();
    public MyClass()
    {
        super(myObject.getClass()); //error line compile time error
    }
}

---

Interestingly the differences in performance mentioned in the example above, seem to be related to other reasons. Using 3 different Classes, in average the performance will be nearly the same :

import java.util.LinkedHashMap;
public class PerfomanceClass {

public static void main(String[] args) {

    long time = System.nanoTime();
    Class class1 = "String".getClass();
    Class class11 = "Integer".getClass();
    Class class111 = "LinkedHashMap".getClass();

    System.out.println("time (getClass()) :" + (System.nanoTime() - time) + " ns");

    long time2 = System.nanoTime();
    Class class2 = String.class;
    Class class22 = Integer.class;
    Class class222 = LinkedHashMap.class;

    System.out.println("time (.class):" + (System.nanoTime() - time2) + " ns");
} }

The Output will be something like :

time (getClass()) :23506 ns 
time (.class):23838 ns

And switching the order of the calls will even result in getClass() being faster.

import java.util.LinkedHashMap;

public class PerfomanceClass {

public static void main(String[] args) {
    long time2 = System.nanoTime();
    Class class2 = LinkedHashMap.class;

    System.out.println("time (.class):" + (System.nanoTime() - time2) + " ns");

    long time = System.nanoTime();
    Class class1 = "LinkedHashMap".getClass();

    System.out.println("time (getClass()) :" + (System.nanoTime() - time) + " ns");
}}

Output:

time (.class):33108 ns
time (getClass()) :6622 ns

---

p.getClass(), where the p is an instance of an object, returns the runtime class of this object p. p cannot be a type which will cause a compile-time error, it should be an instance of an object.

// B extends A
A a = new B();
System.out.println(a.getClass());
//output: class B

p.class is an expression. The .class is called the class syntax. p is a type. It can be the name of a class, interface or array and even a primitive type. a.getClass() == B.class.

If a type is available and there is an instance then it is possible to use getClass method to get the name of the type. Otherwise, use the .class syntax

참고URL : https://stackoverflow.com/questions/10947768/what-is-the-difference-between-a-getclass-and-a-class-in-java