一个内部类的问题

Question

public class Outer {
    public String name="Outer";

public static void staticMethod() {
Inner inner=new Inner();//编译不通过
Outer.Inner inner1=new Outer.Inner();//编译不通过
Inner inner2=new Outer().new Inner();//编译通过
StaticInner staticInner=new StaticInner();//编译通过
Outer.StaticInner staticInner1=new Outer.StaticInner();//编译通过
}

public void createInner(){
Inner inner=new Inner();//编译通过
Outer.Inner inner1=new Outer.Inner();//编译通过
StaticInner staticInner=new StaticInner();//编译通过
Outer.StaticInner staticInner1=new Outer.StaticInner();//编译通过
}


public class Inner{
    String name=new String("Inner");
void showName(){
System.out.println(name);
}
}

public static class StaticInner{
    String name=new String("Inner");
void showName(){
System.out.println(name);
}
}}如上所贴代码，我在外部类Outer的静态方法staticMethod() 中创建实例内部类Inner的实例时，外部类的实例必须已经存在；而在外部类的实例方法createInner()中创建实例内部类Inner的实例时，外部类的实例却不必已经存在。大家说说这到底是怎么回事？

Answer 1

因为staticMehtod是静态类。

Answer 2

因为staticMehtod是静态方法。 
不好意思写错了。

Answer 3

我的理解是，内部类也是外部类对象的一种属性，因为staticMehtod是静态方法，这个方法是类的一种行为，而不是对象的行为，所以编译不过。

Answer 4

staticMethod为静态方法
Inner不是静态类

Answer 5

java中 不存在静态类的呀！～～

Answer 6

楼主所提的是基本的语法问题。
如果在一个类A中定义了另一个静态的类B，我们称A类为顶层类，B类为嵌套类（nested classes）。
如果在一个类A中定义了另一个非静态的类B，我们称A类为顶层类，B类为内部类（inner classes）。
试想，我们是如何处理静态成员的？如：public class Outer {    public static void sayHello() {
        System.out.println("Hello world!");
    }
    
    public static void main(String[] args) {
        Outer.sayHello();
        sayHello();
    }
}对于静态函数，在main函数中调用 类名.方法名 是基本用法；调用 方法名 也是可以的，因为是同一个类的静态成员。对于类来说， new 操作是创建对象的基本方法，如：
  new Outer();同理，对于嵌套类我们要用静态成员和类两个概念去看待它。所以我们在创建嵌套类的对象时，使用的是：
  new Outer.StaticInner();当然在同一个类中的静态成员函数中，可以直接使用下面的方法创建嵌套对象：
  new StaticInner();------------------------------
再看一下我们是如何处理非静态成员的？public class Outer {    public void sayHello() {
        System.out.println("Hello world!");
    }
    
    public static void main(String[] args) {
        new Outer().sayHello();
    }
}我们必须先生成对象，再通过 对象.方法名 的方式调用非静态成员。同理，对于内部类我们也要用非静态成员和类两个概念去看待它。所以我们在创建内部类的对象时，使用的是：
  new Outer().new Inner();也就是说必须有 new Outer() 这个对象存在才可以创建内部类的对象。当然在静态成员函数中不能调用非静态成员。所以下面的调用是不可以的：public class Outer {   public static void staticMethod() { 
    Inner inner=new Inner();//编译不通过 
  }
  ...
}

Answer 7

public class Test {
public static void main(String[] args) {
say();//编译一定会出错
Test t=new Test();
t.say();//编译不可能会出错
//看了这段代码我想楼主应该明白了，这个跟你那个内部类是一个意思
//这是天天在写的main方法
}

public void say(){
System.out.println("hello.......");
}

public void test(){
say();//编译不可能会出错
}

}