静态类，方法和main（）

Question

所以，我是一个Java新手，刚遇到让我感到困惑的事情。 讲到重点，我做了一个Foo类并做了一个实例：

public class Main 
{
    public static void main(String[] args)
    {
        Foo foo = new Foo("Foo");
    }
}

class Foo
{
    public Foo(String A)
    {
        System.out.println(A);
    }
}

我注意到Foo类不必是静态的。 为什么？ 而

如果我这样做

public class Main 
{
    public static void main(String[] args)
    {
        Foo foo = new Foo("Foo");
    }
    static class Foo
    {
        public Foo(String A)
        {
            System.out.println(A);
        }
    }
}

然后它必须是静态的。 为什么会有所不同？ 静态意味着它是实例独立的，因此在静态方法中使用的所有事物也必须是实例独立的（？）使用Foo我是在静态方法中创建实例的，因此Foo不必是静态的。 但是，里面的类有什么不同？ 我以为我有静态下降的概念。 但显然我缺乏很多概念。

Answer 1

JLS-8.1.3对此进行了介绍。 内部类和包含实例 （部分）

内部类是未显式或隐式声明为static的嵌套类。

内部类可以是非static成员类（第8.5 节 ），本地类（ 第14.3节 ）或匿名类（第15.9.5节 ）。 接口的成员类是隐式static （第9.5节 ），因此从不将其视为内部类。

因此，静态类不是内部类，内部类需要封闭类的实例 ； 喜欢

public class Main {
    public static void main(String[] args)
    {
        Foo foo = new Main().new Foo("Foo");
    }
    class Foo
    {
        public Foo(String A)
        {
            System.out.println(A);
        }
    }
}

Answer 2

在第二个代码段中， Foo嵌套在Main 。 嵌套类可以是内部类，也可以是静态类。 如果它们是内部类（非静态），则内部类的每个实例都必须与封闭类的一个实例相关联。

因此，如果您从第二个片段的Foo类中删除static关键字，则必须使用实例化它：

Foo foo = new Main().new Foo("Foo");

当嵌套类是静态的时，它不需要封闭类的实例，您可以使用以下方法实例化它

Foo foo = new Foo("Foo");

另一方面，在您的第一个代码段中， Foo没有嵌套在Main ，因此您不需要实例Main来实例化它。 而且它不能是静态的，因为顶级类不能是静态的。

我以为我有静态下降的概念。 但显然我缺乏很多概念。

当应用于嵌套类时， static关键字的含义与应用于方法和变量时的含义不同。 您应该阅读有关嵌套类的信息。

Answer 3

Java是一种面向对象的编程语言。

如果需要一个类的非静态声明，字段，方法等，则需要从该类创建一个实例。

但是访问静态字段时，方法不需要创建实例。

现在看一下您的例子；

1.Main和Foo是不同的类，因此您可以在任何地方从Foo创建实例。

public class Main {
    public static void main(String[] args) {
        Foo foo = new Foo("Foo");
    }
}

class Foo {
    public Foo(String A) {
        System.out.println(A);
    }
}

2.Foo是一个内部类，如果未创建Main的实例，则Foo类将永远不可访问。 因此，如果创建Main实例，则也可以创建Foo。 但是没有创建Main实例，只有访问Foo才将Foo类定义为静态

public class Main {
    public static void main(String[] args) {
        Foo foo = new Foo("Foo");
    }

    static class Foo {
        public Foo(String A) {
            System.out.println(A);
        }
    }
}

Answer 4

在最上面的示例中，同一文件中有两个独立的类。 main可以引用Foo因为它只是另一个类。

在底部的示例中，您有一个静态的嵌套类。 它也可以独立实例化。 如果您在Foo上摆脱了static关键字，则会有一个内部类，它绑定到Main的特定实例，但是当您运行static main方法时，没有要引用的Main特定实例。

该参考可能会有所帮助： https : //docs.oracle.com/javase/tutorial/java/javaOO/nested.html

Answer 5

在Java中，我们不能将顶级类设为静态。 只有嵌套的类可以是静态的。 因此，对于第一种情况，您将无法使Foo类成为静态类。 对于第二种情况，即使非静态嵌套类（内部类）被声明为私有，也可以访问其周围的其他成员。 静态嵌套类无权访问封闭类的其他成员。