Java 如何实例化静态嵌套类的内部类？

这是我的课

public class XYZ{

    public static void main(String[] args) {
        int n = 5;
        Object myObject;
       //somehow call returnN(n);
    } //end main

    static class Inner{
        private class Private{
            private int returnN(int n){
                return n;
            }
        }
    }//end of Inner


}

---

我正试着从main打电话给returnN。我尝试了

myObject=new XYZ.internal.Private（）但这似乎不是正确的实例化。
Private
不是
静态的。因此，您需要一个
内部
实例，然后才能创建
私有
。正确的语法是

new XYZ.Inner().new Private().returnN(3);

或者，您可以将
设置为Private
静态
，然后只需执行以下操作即可

new XYZ.Inner.Private().returnN(3);

肖恩：在阿兰努力回答后，你为什么要删除你的答案？我会把它贴在这里，这样它至少能在互联网上出现，但你应该重新打开它，并投票给阿兰的答案，至少是因为他在回答这个问题上付出的努力


问题:
我应该实现一个类，当我有这样的行时：

double v = className.functionName().main(a,b);

public class Main {
    public static void main(String[] args) {
        ClassName className = new ClassName();
        Object a = new Object(); // replace with correct a
        Object b = new Object(); // replace with correct b
        double v = className.functionName().main(a,b);
        className.output.display(v);
    }
}

及

我不清楚这个层次结构在className类中应该是什么样子

从函数调用调用main（）意味着什么？从函数调用主函数？为什么这不可能只是函数名（a，b）

以及使用.output的意义。？这应该是一个带有子函数display（）的空白吗


阿兰的回答
答复

输出是一个字段。没有子函数或方法，只有对象上的方法。display（）方法位于类名对象的对象字段上

这里的main（）方法只是functionName（）返回的对象上的一个方法。被称为main（）没有什么特殊意义

我可以从以下几行中推断出类似的情况：

我假设className是className的一个实例，如下所示：

double v = className.functionName().main(a,b);

public class Main {
    public static void main(String[] args) {
        ClassName className = new ClassName();
        Object a = new Object(); // replace with correct a
        Object b = new Object(); // replace with correct b
        double v = className.functionName().main(a,b);
        className.output.display(v);
    }
}

类名的定义如下：

public class ClassName {
    public Output output = new Output;
    public Mainable functionName() {
        return new Mainable();
    }
}

Output.java：

public class Output {
    public void display(double v) {
        // implement display here
    }
}

Mainable.java：

public class Mainable {
    public double main(Object a, Object b) {
        return 0.0d; // put actual impl here
    }
}

“Private不是静态的”--我知道它不是静态的，但Inner是静态的，据我所知，静态类是一种“共享实例”，所以不需要使用“（）”，所以为什么我不能执行新的XYZ.Inner.Private（）？为什么它允许我执行myObject=new XYZ.Inner（）.new Private（）；但是那样我就不能做我的事了？静态嵌套类不是共享实例。静态嵌套类实际上与顶级类类似，只是它恰好是在另一个类中定义的。另一方面，可以认为内部类的实例属于封闭实例
因为
myObject
的类型是
Object
，并且
Object
没有方法
returnN
。您可以执行
internal.Private myObject=new-internal（）.new-Private（）<代码>对象返回n（3）