Java 静态嵌套类型语义答案

【问题标题】：Java Static Nested Type SemanticJava 静态嵌套类型语义
【发布时间】：2016-04-13 21:22:27
【问题描述】：

我最近一直在学习Java，得出以下结论：声明静态嵌套类型是没有意义的冗余。

我正在阅读以下问题的答案，虽然我确实理解了答案（它消除了我最初的困惑 - 类似于提问者的答案） Can a Static Nested Class be Instantiated Multiple Times? 我还得出结论，关于内部类型的静态这个词是没有意义的，例如，如果我们没有将内部类型声明为静态，我们仍然不需要实例化外部类型来创建内部类型的新对象.毕竟它是嵌套类型，而不是外部类型的成员/变量。我刚刚测试了一些代码（删除了静态代码），我的假设是正确的。

有什么我错过的吗？

这是我测试的代码（请注意，当我从 IGameInput 中的 KeyEvent 类型中删除静态时，一切正常）

package FrameWork;
import java.util.List;
public interface IGameInput {

    //type definitions
    public static class KeyEvent {
public static final int KEY_DOWN = 0;
public static final int KEY_UP = 1;
public int type;
public int keyCode;
public char keyChar;
    }
}

/////////////////////

package FrameWork.Imp;


import java.util.ArrayList;
import java.util.List;

/*
*/
public class Pool<T> 
{  
    public interface PoolObjectFactory<T> {
    public T createObject(); 
}

    private final ArrayList<T> freeObjects;
    private final PoolObjectFactory<T> factory;
    private final int maxSize;

    public Pool(PoolObjectFactory<T> factory, int maxSize)
    {
        this.factory = factory;
        this.maxSize = maxSize;
        this.freeObjects = new ArrayList<T>(maxSize);
    }

    public T newObject() 
    {
        T object = null;
        if (freeObjects.size() == 0)
        {
            object = factory.createObject();
        }
        else
        {
            object = freeObjects.remove(freeObjects.size() - 1);
        }
        return object;
    }

    public void free(T object) 
    {
        if (freeObjects.size() < maxSize)
        {
            freeObjects.add(object);
        }
    }
}

/////////////////////

package FrameWork.Imp;

import java.util.ArrayList;
import java.util.List;
import android.view.View;
import android.view.View.OnKeyListener;
import FrameWork.IGameInput.KeyEvent;
import FrameWork.Imp.Pool.PoolObjectFactory;

public class KeyboardHandler implements OnKeyListener {
  boolean[] pressedKeys = new boolean[128];
  Pool<KeyEvent> keyEventPool;
  List<KeyEvent> keyEventsBuffer = new ArrayList<KeyEvent>();
  List<KeyEvent> keyEvents = new ArrayList<KeyEvent>();

  public KeyboardHandler(View view) {

    PoolObjectFactory<KeyEvent> factory;
    factory =
        new PoolObjectFactory<KeyEvent>() {
          @Override
          public KeyEvent createObject() {
            return new KeyEvent();
          }
        };
    keyEventPool = new Pool<KeyEvent>(factory, 100);
    view.setOnKeyListener(this);
    view.setFocusableInTouchMode(true);
    view.requestFocus();
  }

  @Override
  public boolean onKey(View v, int keyCode, android.view.KeyEvent event) {
    if (event.getAction() == android.view.KeyEvent.ACTION_MULTIPLE) return false;
    synchronized (this) {
      KeyEvent keyEvent = keyEventPool.newObject();
      keyEvent.keyCode = keyCode;
      keyEvent.keyChar = (char) event.getUnicodeChar();
      if (event.getAction() == android.view.KeyEvent.ACTION_DOWN) {
        keyEvent.type = KeyEvent.KEY_DOWN;
        if (keyCode > 0 && keyCode < 127) pressedKeys[keyCode] = true;
      }
      if (event.getAction() == android.view.KeyEvent.ACTION_UP) {
        keyEvent.type = KeyEvent.KEY_UP;
        if (keyCode > 0 && keyCode < 127) pressedKeys[keyCode] = false;
      }
      keyEventsBuffer.add(keyEvent);
    }
    return false;
  }
}

【问题讨论】：

我的假设是正确的你一定做错了什么。如果没有封闭实例，则无法实例化内部类型（没有static 的嵌套）。
您确定不是在实例中进行实例化吗？
有什么我遗漏的吗？：是的：代码和你如何得出这个结论的解释。
@Pillar 代码已更新
@shmosel 代码更新

标签： java

【解决方案1】：

您不能在没有包含类的实例的情况下实例化非静态嵌套类。

class Test {
    public static void main(String[] args) { //static, non-instance method
        Inner inner = new Inner(); //error
    }

    class Inner { }
}

您能够做到这一点的唯一方法是在包含类的实例中实例化它（很可能是您正在做的事情，根据您的解释）：

class Test {
    public void someMethod() { //non-static, instance method
        Inner inner = new Inner();
    }

    class Inner { }
}

或者通过使用包含类的实例来实例化内部类：

class Test {
    public static void main(String[] args) { //static, non-instance method
        Test test = new Test();
        Inner inner = test.new Inner(); //error
    }

    class Inner { }
}

否则你会得到编译时错误：

非静态变量 this 不能从静态上下文中引用

通过您的代码示例，它更有意义。 KeyEvent 仍然是静态的。调查JLS §9.5：

接口中的成员类型声明是隐式静态和公共的。

这意味着所有类，无论您是否将它们明确定义为static，都将是static。

【讨论】：

【解决方案2】：

KeyEvent 是接口 IGameInput 的嵌套类。

接口的嵌套类总是隐含的静态（和公共）。

见the JLS：

接口中的成员类型声明是隐式公共和静态的。允许冗余指定这些修饰符中的一个或两个。

所以，您的结论是正确的，但仅适用于接口的嵌套类。嵌套类的类是错误的。

【讨论】：

谢谢，好的，让我们暂时忘记接口，假设它是一个名为 GameInput 的类，现在为了能够实例化一个非静态 KeyEven 我需要有类似 GameInputInstance.KeyEvent ke1 的东西= 新的 GameInputInstance.KeyEvent();现在如果 KeyEvent 是静态的并且我有以下语句 GameInput.KeyEvent ke2 = new GameInput.KeyEvent; ke1和ke2到底有什么区别？在这两种情况下，我都创建了内部类型的实例，它们都不属于外部类型的任何实例！
我说它们不属于任何 GameInput 实例，因为 GameInput 没有 KeyEvent 的引用/成员，它只有 KeyEvent 的内部类型定义
您如何做到这一点，尝试编译您的代码，自己查看差异，并使用包含实际编译的真实代码的最小示例提出问题？
再次感谢，是的，我写的例子充满了语法错误。抱歉，我仍在试图表达我的困惑，一旦回答了主要问题并且我意识到我需要“静态”以便能够在不实例化外部类型的情况下创建实例，我开始想知道为什么有人需要静态内部类型，因为它可以被视为外部类型，它有点违反直觉。无论如何再次感谢

【解决方案3】：

根据Java documentation 可以实例化静态嵌套类，而不必实例化外部类。注意：“实际上，静态嵌套类在行为上是一个顶级类，它已经嵌套在另一个顶级类中以方便打包。”。如果我们有这样的内部和外部类：

public class A {
  static public class B {
  }
}

我们可以像这样实例化多个 B 实例：

        A.B b1 = new A.B();
        A.B b2 = new A.B();

希望这会有所帮助。

【讨论】：