如何製作方法的參數的構造函數

Question

同時使Java中的小遊戲，我偶然發現了KeyListener的類，實例化（的keyTyped，的keyPressed和的keyReleased）時，詢問了三種方法，如下：

JFrame.addKeyListener(new KeyListener(){ 
    public void keyTyped(KeyEvent evnt) { 
    //blah 
    } 
    public void keyPressed(KeyEvent evnt) { 
    //blah 
    } 
    public void keyReleased(KeyEvent evnt) { 
    //blah 
    } 
}); 

我怎樣才能得到一個我自己的接受方法作爲上述參數的類？

Answer 1

new KeyListener() { ... }實際上創建了一個實現KeyListener的匿名內部類。因此，它可以訪問創建它的類的任何可見字段以及調用構造方法的方法內的任何本地最終變量。

例子：

class Outer { 
    int x; 

    void initUI(final int z) { 
    final int y = 0;   
    int nope = 1; //you can't access this since it is neither final nor a field like x 

    JFrame.addKeyListener(new KeyListener() { 
     public void keyTyped(KeyEvent evnt) { 
     System.out.println(x + y + z); //you can access all of them 
     } 
    }); 
    } 
} 

如果你想爲你的按鍵偵聽器，您需要明確地定義一個類，作爲anonymous classes can't have custom constructors提供一個構造函數。這意味着你必須做這樣的事情（注意：僞代碼）：

class Outer { 
    void initUI() { 
    JFrame.addKeyListener(new InnerKeyListener(myParam)); 
    } 

    class InnerKeyListener implements KeyListener { 
    InnerKeyListener(Param p) { 
    } 

    ... 
    } 
} 

當然你也可以把內部類成separe文件以及或使其靜態內部類。

Answer 2

它不接受方法作爲參數。你聲明瞭一個匿名類並將其作爲參數傳遞給addKeyListener方法。

Answer 3

從技術上講，這些方法在這裏不是參數。唯一的參數是KeyListener的一個匿名實例。

KeyListener是interface，它要求實現這3種方法。

如果要定義自己的接口，它類似於一個類：

public interface SomeInterface { 
    public void foo(); 
    public int bar(int x); 
} 

然後你就可以（在你的例子一樣）匿名方式使用它，或者在一個類實現它：

public class MyClass implements SomeInterface { 
    // ... 
} 

Answer 4

我知道這是怪異回答我的問題，但...

我想通了。您必須使您的類變爲抽象類型，並且您可以聲明抽象方法來使方法「參數」具有類似於KeyListener聲明的行爲。抽象方法聲明如下：

abstract ReturnType name(Parameter p); 

並且在調用時的行爲與方法完全相同。舉一個完整的例子：

//The abstract keyword enables abstract methods to work with this class. 
    abstract class Foo { 
     //Just a random variable and a constructor to initialize it 
     int blah; 
     public Foo(int blah) { 
      this.blah = blah; 
     } 
     //An abstract method 
     abstract void doStuff(); 
     //Example with a parameter 
     abstract void whatDoIDoWith(int thisNumber); 
     //A normal method that will call these methods. 
     public void doThings() { 
      //Call our abstract method. 
      doStuff(); 
      //Call whatDoIDoWith() and give it the parameter 5, because, well... 5! 
      whatDoIDoWith(5); 
     } 
    } 

當你試圖實例化一個像普通類的抽象類時，Java會嚇壞了。

Foo f = new Foo(4); 

你將需要做的就是這樣的事情：你需要包括所有的抽象方法在這裏

Foo f = new Foo(4) { 
     @Override 
     void doStuff() { 
      System.out.println("Hi guys! I am an abstract method!"); 
     } 
     @Override 
     void whatDoIDoWith(int thisNumber) { 
      blah += thisNumber; 
      System.out.println(blah); 
     } 
    }; //Always remember this semicolon! 

注意，不只是其中的一部分。現在，讓我們試試這個：

public class Main { 
     public static void main(String[] args) { 
      //Instance foo. 
      Foo f = new Foo(4) { 
       @Override 
       void doStuff() { 
        System.out.println("Hi guys! I am an abstract method!"); 
       } 
       @Override 
       void whatDoIDoWith(int thisNumber) { 
        blah += thisNumber; 
        System.out.println(blah); 
       } 
      }; 
      //Call our method where we called our two abstract methods. 
      foo.doThings(); 
     } 
    } 

這將打印以下控制檯：

Hi guys! I am an abstract method! 
    9