是否限定方法调用会降低Java中的性能？

Question

我猜测以下两个函数编译为完全相同的字节码,但我想问一下这个问题.是否在不需要降低性能的情况下限定方法调用？

例如:

package com.my;

import android.app.Activity;
import android.os.Bundle;

public class Main extends Activity {

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        this.setContentView(R.layout.main); // Fully qualified 
        setContentView(R.layout.main);      // Not fully qualified
    }

}

标准是使用后者,但完全合格的呼叫this.setContentView()是否有任何负面影响？

Answer 1

不,没有任何惩罚.两个调用都将invokespecial在字节码中使用来调用成员方法.

在标准Java中,以下代码:

public class TestQualified {

   private void someMethod() {
   }

   public void otherMethod() {
       this.someMethod();
       someMethod();
   }
}

产生以下字节码:

Compiled from "TestQualified.java"
public class TestQualified extends java.lang.Object{
public TestQualified();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

private void someMethod();
  Code:
   0:   return

public void otherMethod();
  Code:
   0:   aload_0
   1:   invokespecial   #2; //Method someMethod:()V
   4:   aload_0
   5:   invokespecial   #2; //Method someMethod:()V
   8:   return

}

如您所见,两个呼叫都是相同的.

现在Android .class使用dx输出.dex文件的工具将文件转换为dalvik字节码.由于.class文件没有显示两个调用之间的任何区别,因此相应的.dex文件也不会显示任何区别:

Processing 'TestQualified.dex'...
Opened 'TestQualified.dex', DEX version '035'
Class #0            -
  Class descriptor  : 'LTestQualified;'
  Access flags      : 0x0001 (PUBLIC)
  Superclass        : 'Ljava/lang/Object;'
  Interfaces        -
  Static fields     -
  Instance fields   -
  Direct methods    -
    #0              : (in LTestQualified;)
      name          : '<init>'
      type          : '()V'
      access        : 0x10001 (PUBLIC CONSTRUCTOR)
      code          -
      registers     : 1
      ins           : 1
      outs          : 1
      insns size    : 4 16-bit code units
0000e4:                                        |[0000e4] TestQualified.<init>:()V
0000f4: 7010 0300 0000                         |0000: invoke-direct {v0}, Ljava/lang/Object;.<init>:()V // method@0003
0000fa: 0e00                                   |0003: return-void
      catches       : (none)
      positions     : 
        0x0000 line=1
      locals        : 
        0x0000 - 0x0004 reg=0 this LTestQualified; 

    #1              : (in LTestQualified;)
      name          : 'someMethod'
      type          : '()V'
      access        : 0x0002 (PRIVATE)
      code          -
      registers     : 1
      ins           : 1
      outs          : 0
      insns size    : 1 16-bit code units
0000fc:                                        |[0000fc] TestQualified.someMethod:()V
00010c: 0e00                                   |0000: return-void
      catches       : (none)
      positions     : 
        0x0000 line=4
      locals        : 
        0x0000 - 0x0001 reg=0 this LTestQualified; 

  Virtual methods   -
    #0              : (in LTestQualified;)
      name          : 'otherMethod'
      type          : '()V'
      access        : 0x0001 (PUBLIC)
      code          -
      registers     : 1
      ins           : 1
      outs          : 1
      insns size    : 7 16-bit code units
000110:                                        |[000110] TestQualified.otherMethod:()V
000120: 7010 0200 0000                         |0000: invoke-direct {v0}, LTestQualified;.someMethod:()V // method@0002
000126: 7010 0200 0000                         |0003: invoke-direct {v0}, LTestQualified;.someMethod:()V // method@0002
00012c: 0e00                                   |0006: return-void
      catches       : (none)
      positions     : 
        0x0000 line=7
        0x0003 line=8
        0x0006 line=9
      locals        : 
        0x0000 - 0x0007 reg=0 this LTestQualified; 

  source_file_idx   : 3 (TestQualified.java)

您可以看到两个调用都是使用的invoke-direct.因此,这里也没有性能损失.