是的-當然。通過反射查找類是，按震級更貴。

引文Java反射文檔:

由于反射涉及動態(tài)解析的類型，因此無法執(zhí)行某些Java虛擬機優(yōu)化。因此，反射操作的性能比它們的非反射操作要慢，在性能敏感的應用程序中經常調用的代碼部分應該避免反射操作。

在我的機器上運行SunJRE 6u10時，我在5分鐘內完成了一個簡單的測試：

public class Main {

    public static void main(String[] args) throws Exception
    {
        doRegular();
        doReflection();
    }

    public static void doRegular() throws Exception
    {
        long start = System.currentTimeMillis();
        for (int i=0; i<1000000; i++)
        {
            A a = new A();
            a.doSomeThing();
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    public static void doReflection() throws Exception
    {
        long start = System.currentTimeMillis();
        for (int i=0; i<1000000; i++)
        {
            A a = (A) Class.forName("misc.A").newInstance();
            a.doSomeThing();
        }
        System.out.println(System.currentTimeMillis() - start);
    }}

根據這些結果：

35 // no reflection465 // using reflection

請記住，查找和實例化是一起完成的，在某些情況下，查找可以重構，但這只是一個基本示例。

即使您只是實例化，您仍然得到了性能上的成功：

30 // no reflection47 // reflection using one lookup, only instantiating

再說一次，YMMV。

是的，慢點。

但是記住第一條該死的規(guī)則-過早的優(yōu)化是萬惡之源。

(好吧，可能和1號綁在一起干)

我發(fā)誓，如果有人在工作中來問我這個問題，我會在接下來的幾個月里非常小心他們的代碼。

在確定需要優(yōu)化之前，千萬不要進行優(yōu)化，在此之前，只需編寫好的、可讀的代碼即可。

我也不是說寫愚蠢的代碼。只要想一想最干凈的方法，你就可以做到-沒有復制和粘貼，等等。(仍然要小心內部循環(huán)和使用最適合您需要的集合-忽略這些不是“未優(yōu)化的”編程，而是“糟糕的”編程)

當我聽到這樣的問題時，我很害怕，但后來我忘記了，每個人都必須自己去學習所有的規(guī)則，才能真正得到它。當你花了一個人月的時間來調試某個“優(yōu)化”的東西之后，你就可以得到它了。

編輯：

這條線上發(fā)生了一件有趣的事。檢查#1答案，這是編譯器在優(yōu)化方面有多么強大的一個例子。測試完全無效，因為非反射實例化可以完全排除。

上課？永遠不要優(yōu)化，直到你寫了一個干凈的，整潔的編碼解決方案，并證明它是太慢。

您可能會發(fā)現，JVM正在優(yōu)化A=新的A()。如果將對象放入數組中，則它們的性能不太好。)以下指紋.

new A(), 141 ns
A.class.newInstance(), 266 nsnew A(), 103 ns
A.class.newInstance(), 261 nspublic class Run {
    private static final int RUNS = 3000000;

    public static class A {
    }

    public static void main(String[] args) throws Exception {
        doRegular();
        doReflection();
        doRegular();
        doReflection();
    }

    public static void doRegular() throws Exception {
        A[] as = new A[RUNS];
        long start = System.nanoTime();
        for (int i = 0; i < RUNS; i++) {
            as[i] = new A();
        }
        System.out.printf("new A(), %,d ns%n", (System.nanoTime() - start)/RUNS);
    }

    public static void doReflection() throws Exception {
        A[] as = new A[RUNS];
        long start = System.nanoTime();
        for (int i = 0; i < RUNS; i++) {
            as[i] = A.class.newInstance();
        }
        System.out.printf("A.class.newInstance(), %,d ns%n", (System.nanoTime() - start)/RUNS);
    }}

這表明我的機器上的差別大約是150 ns。