标签: inner-classes

可能类似于问题,为什么外部Java类可以访问内部类私有成员？或使用子类中的super关键字访问超类私有字段.

但是存在一些差异:子类可以访问其父级(并且只有最近的父级)的私有成员.

鉴于以下示例代码:

public class T {

    private int t;

    class T1 {
        private int t1;

        public void test() {
            System.out.println(t);
        }
    }

    class T2 extends T1 {

        private int t2;

        public void test() {
            System.out.println(t);
            System.out.println(super.t1);
            System.out.println(this.t2);
        }
    }

    class T3 extends T2 {

        public void test() {
            System.out.println(t);
            System.out.println(super.t1); // NG: t1 Compile error! Why?
            System.out.println(super.t2); // OK: t2 OK
        }
    }
}

如何使用IntelliJ或Android Studio提取公共静态内部类来创建新的顶级类？

谢谢.

我正在回顾java中内部类的概念.到目前为止,我已经理解和应用java内部类有一个链接或访问其外部/封闭类的方法和字段.

我的问题:

1. 什么时候应该创建或定义内部类？
2. 内部类被认为是"助手类"吗？
3. 你有什么指标来建立一个内部阶级,以及它们的另一个目的是什么？

我正在研究过度散列hashCode和equals方法的示例问题,但是得到一个错误:" 没有可以访问CustomHashCodeExample类型的封闭实例.必须使用CustomHashCodeExample类型的封闭实例来限定分配(例如,xnew A(),其中x是一个实例of CustomHashCodeExample). "我写了一个内部类HashPerson,当我试图在另一个名为testHashCodeOverride()的方法中实例化这个内部类时,我收到了这个错误.

public static void testHashCodeOverride(){   
    System.out.println("\nTest HashCode Override Method");
    System.out.println("==================================\n");

    HashPerson william = new HashPerson("willy");
    HashPerson bill = new HashPerson("willy");          
}

这段代码工作正常,即使我没有看到静态内部类或外部类的实例化,困惑:(

public class HashCodeExample {

    public static void testHashCodeOverride() {

        HashPerson william = new HashPerson("Willy");
        HashPerson bill = new HashPerson("Willy");
        System.out.println("Hash code for william  = " + william.hashCode());
        System.out.println("Hash code for bill     = " + bill.hashCode());

        HashMap table = new HashMap();
        table.put(william, "Silly");

        if (table.containsKey(william)) {
            System.out.println(table.get(william));
        } else {
            System.out.println("Key " + william + …

以下代码生成输出middle.谁能详细解释这是怎么回事？

是因为声明"内部"版本class A来自在方法中class A创建的实例之后go()？

class A {
    void m() {
        System.out.println("outer");
    }
}

public class MethodLocalVSInner {
    public static void main(String[] args) {
        new MethodLocalVSInner().go();
    }

    void go() {
        new A().m();
        class A {
            void m() {
                System.out.println("inner");
            }
        }
    }

    class A {
        void m() {
            System.out.println("middle");
        }
    }
}

我没想到在这个阶段我会在Java中遇到全新的语法,但是,我刚刚遇到了一些问题:

确切的上下文以及下面的代码应该做的事情是非常无关紧要的 - 它只是提供某种上下文.

我正在尝试综合在IT Mill Toolkit中创建一个事件,所以我写了这样一行:

buttonClick(new Button.ClickEvent(button));

但是,Eclipse给出了以下错误消息:

不能访问类型为Button的封闭实例.必须使用Button类型的封闭实例限定分配(egxnew A(),其中x是Button的实例).

当我按如下方式重写上面的行时,它不会再抱怨了:

buttonClick(button.new ClickEvent(button)); // button instanceof Button

所以,我的问题是:后面的语法是什么意思,确切地说,为什么第一个片段不起作用？什么是Java抱怨,以及它在第二个版本中做了什么？

背景信息:无论Button和Button.ClickEvent是非抽象公共类.

有些人可能会认为这是有史以来最不重要问题的候选人.然而代码风格对我来说是一个非常重要的主题,我想确保以可读的方式编写代码 - 对我和大多数开发人员而言.

这就是为什么我想知道你们在哪里宣布你们的内心课程.

我遵循以下方法排序方案,因为它很常见:

public void foo() {
    usedByFoo();
}

private void usedByFoo() {
}

public void bar() {
}

我从上到下订购它们,每个方法都接近使用它的位置.

现在我可以对内部类做同样的事情,像这样:

class Outer {
    private Inner inner;

    private class Inner {};

    public Outer() {
    }

    ...
}

我认为这是我要遵循的最一致的风格,但我也经常看到人们在文件的顶部或底部声明所有内部类.

根据我的订购方法,我应该遵循哪种风格？最常见的方法是什么？

可能重复:
为什么我得到"无法从静态上下文引用的非静态变量"？

这是代码

public class Stack
{
    private class Node{
        ...
    }
    ...
    public static void main(String[] args){
         Node node = new Node(); // generates a compiling error
    }
}  

错误说:

无法从静态上下文引用非静态类Node

为什么我不应该在main()方法中引用Node类？

我正在Netbeans中开发一个小型桌面应用程序.这是我的第一个程序,我面临一种非常奇怪的错误.我知道我做错了但却无法追查我做错了什么:(

请帮我解决这个错误.

描述:我有一个默认包Src,我根据需要在这个包中创建新的Java类.和其他课一样,我创建了X这样一个类:

public class X
{
    public class Y
    {//some member functions and variables exist here}

    public class Z
    {//some member functions and variables exist here}

    //some member functions and variables exist here
}

现在我需要在同一个包中存在的其他一些类中创建一个内部类的实例,如下所示:

public X.Y oY = new X.Y();

但我收到以下错误:

需要包含XY的封闭实例

请帮我解决这个错误.

Scala中使用Java进行此类操作的模拟是什么:

public class Outer {
  private Inner inner;

  public static class Inner {
  }

  public Inner getInner() { return inner; }
}

我特别希望我的内部阶级不必拥有一个完全限定的名字 - 即我想要的Trade.Type,不是TradeType.所以在Scala我想象它可能是这样的:

class Outer(val inner: Inner) {
    object Inner
}

但这似乎不起作用:我的scala Inner似乎从课外看不出来Outer.一个解决方案当然是:

class Inner
class Outer(val inner: Inner)

这是确定-但因为我的课的名字,Inner真是的"类型" Outer和Outer实际上有一个很长的名字.所以:

class SomeHorriblyLongNameType
class SomeHorriblyLongName(myType: SomeHorriblyLongNameType)

这是冗长而可怕的.我可以SomeHorriblyLongNameType用just 替换,Type但是它与它所涉及的类之间没有明显的联系.表示不快