相关疑难解决方法(0)

我最近在学习Java,我遇到了package-private类的概念,如果我们没有指定任何东西,这是默认的.但后来我意识到:

1. 我很少看到使用package-private类.是否有这样的原因,例如,它有严重的缺点,它是多余的,或者只是我阅读不够？是否有强烈的论据支持/反对其使用？

2. 如果它在大多数情况下确实没用,为什么它会是默认值？

3. 在什么情况下我们应该在现实世界中使用package-private？即,什么时候会变得不可替代？

换句话说,默认的package-private修饰符的主要优点和缺点是什么？

一般来说,将私有类声明为静态是否有任何好处？

在什么情况下我想使用以下哪一个而不是另一个？

private static class Foo
{
    ...
}

VS

private class Foo
{
    ...
}

swift没有嵌套类吗？

例如,我似乎无法从嵌套类访问主类的属性测试.

class master{
  var test = 2;

  class nested{
     init(){
       let example = test; //this doesn't work
     }
   }
 }

术语内部类通常用于表示"需要封闭实例的嵌套类".但是,JLS声明如下:

8.1.3.内部类和封闭实例

[...]

内部类包括本地(§14.3),匿名(§15.9.5)和非静态成员类(§8.5).

[...]

声明在静态上下文中发生的内部类的实例没有词法封闭的实例.

也,

15.9.5.匿名类声明

[...]

匿名类始终是内部类(第8.1.3节); 它永远不会static(§8.1.1,§8.5.1).

众所周知,匿名类可以在静态上下文中声明:

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

要尖锐地描述它,

new A() {} 是一个没有封闭实例的嵌套类,在静态上下文中定义,但它不是静态嵌套类 - 它是一个内部类.

我们是否都在日常使用中为这些条款赋予了不恰当的含义？

作为一个相关的兴趣点,这个历史规范文档将术语顶层定义为内部的反面:

作为static类成员的类和作为包成员的类都称为顶级类.它们与内部类的不同之处在于顶级类只能直接使用它自己的实例变量.

而在常见用法中,顶层被认为是嵌套的反面.

我有两个选项(技术上是相同的,据我所知)来声明仅从特定类抛出的自定义异常类com.XXX.Foo:

• 作为包中的公共类: com.XXX.CustomException
• 作为公共静态内部类: com.XXX.Foo.CustomException

哪个选项更好？

我的Java类中有一个内部类.

当我运行查找错误时,它建议(警告)使其成为静态.

这个警告有什么意义？将内部类设为静态有什么好处？

我只是遇到了一个奇怪的效果,在跟踪它时,我注意到收集内部和静态嵌套类似乎有很大的性能差异.考虑以下代码片段:

public class Test {
    private class Pointer {
        long data;
        Pointer next;
    }
    private Pointer first;

    public static void main(String[] args) {
        Test t = null;
        for (int i = 0; i < 500; i++) {
            t = new Test();
            for (int j = 0; j < 1000000; j++) {
                Pointer p = t.new Pointer();
                p.data = i*j;
                p.next = t.first;
                t.first = p;
            }
        }
    }
}

那么代码所做的就是使用内部类创建一个链表.该过程重复500次(用于测试目的),丢弃上次运行中使用的对象(受GC影响).

在内存限制严格(例如100 MB)下运行时,此代码在我的计算机上执行大约需要20分钟.现在,通过简单地用静态嵌套类替换内部类,我可以将运行时减少到不到6分钟.以下是更改:

    private static class Pointer {

和

                Pointer p …

鉴于我所知道的其他类型的静态编程功能 - 我认为答案是'不'.然而,看到这样的陈述OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();让我感到奇怪.

Java中常用内部类吗？这些是否与嵌套类相同？或者用Java更换这些更好的东西？我有一本关于版本5的书,它有一个使用内部类的例子,但我想我读过一些内部类是"坏的".

我不知道,并希望有关于它的想法.

谢谢.

以下代码:

public class TestInnerClass {

    public static void main(String[] args) throws IOException {
        new TestInnerClass().serializeInnerClass();
    }

    private void serializeInnerClass() throws IOException {
        File file = new File("test");
        InnerClass inner = new InnerClass();
        new ObjectOutputStream(new FileOutputStream(file)).writeObject(inner);
    }

    private class InnerClass implements Serializable {

        private static final long serialVersionUID = 1L;

    }

}

抛出以下异常:

Exception in thread "main" java.io.NotSerializableException: TestInnerClass

我猜内部类有一个TestInnerClass.this字段允许私有访问TestInnerClass的字段和方法.声明内部类静态可以解决它,但是如果InnerClass需要这种访问呢？有没有办法在没有封闭类的情况下序列化非静态内部类,例如通过引用外部类transient？

编辑:例如,只有在序列化之前才需要访问外部类.好的,编译器无法知道,但我认为这就是transient关键字存在的原因.