Почему Java запрещает статические поля во внутренних классах?

Идея внутренних классов состоит в том, чтобы работать в контексте включающего экземпляра. Почему-то разрешение статических переменных и методов противоречит этой мотивации?

8.1.2 Внутренние классы и закрывающие экземпляры

Внутренний класс - это вложенный класс, который явно или неявно не объявлен статическим. Внутренние классы не могут объявлять статические инициализаторы (§8.7) или интерфейсы-члены. Внутренние классы не могут объявлять статические члены, если только они не являются полями констант времени компиляции (§15.28).

я хочу знать, почему java запрещает статические поля / методы внутри внутренних классов

Потому что эти внутренние классы являются внутренними классами "экземпляра". То есть они похожи на атрибут экземпляра охватывающего объекта.

Поскольку они являются «экземпляровыми» классами, нет никакого смысла разрешать static функции, поскольку static изначально предназначен для работы без экземпляра.

Это как если бы вы одновременно пытались создать статический / экземплярный атрибут.

Возьмем следующий пример:

class Employee {
    public String name;
}

Если вы создаете два экземпляра сотрудника:

Employee a = new Employee(); 
a.name = "Oscar";

Employee b = new Employee();
b.name = "jcyang";

Понятно, почему у каждого свое значение свойства name, верно?

То же самое происходит с внутренним классом; каждый экземпляр внутреннего класса не зависит от другого экземпляра внутреннего класса.

Поэтому, если вы попытаетесь создать атрибут класса counter, невозможно будет разделить это значение между двумя разными экземплярами.

class Employee {
    public String name;
    class InnerData {
        static count; // ??? count of which ? a or b? 
     }
}

Когда вы создаете экземпляр a и b в приведенном выше примере, какое значение будет правильным для статической переменной count? Определить его невозможно, потому что существование класса InnerData полностью зависит от каждого из окружающих объектов.

Вот почему, когда класс объявлен как static, ему больше не нужен живой экземпляр, чтобы жить сам по себе. Теперь, когда нет зависимости, вы можете свободно объявлять статический атрибут.

Я думаю, это звучит повторяюще, но если вы подумаете о различиях между атрибутами экземпляра и класса, это будет иметь смысл.

InnerClass не может иметь static участников, потому что он принадлежит экземпляру (из OuterClass). Если вы объявите InnerClass как static, чтобы отделить его от экземпляра, ваш код будет скомпилирован.

class OuterClass {
    static class InnerClass {
        static int i = 100; // no compile error
        static void f() { } // no compile error
    }
}

Кстати: вы по-прежнему сможете создавать экземпляры InnerClass. static в этом контексте позволяет этому происходить без включающего экземпляра OuterClass.

Фактически, вы можете объявлять статические поля, если они являются константами и записываются во время компиляции.

class OuterClass {
    void foo() {
        class Inner{
            static final int a = 5; // fine
            static final String s = "hello"; // fine
            static final Object o = new Object(); // compile error, because cannot be written during compilation
        }
    }
}

1. Последовательность инициализации класса является важной причиной.

Поскольку внутренние классы зависят от экземпляра включающего класса / Outer, поэтому внешний класс необходимо инициализировать перед инициализацией внутреннего класса.
Это JLS говорит об инициализации класса. Нам нужно, чтобы класс T был инициализирован, если

• Используется статическое поле, объявленное T, и поле не является постоянной переменной.

Таким образом, если внутренний класс имеет доступ к статическому полю, это вызовет инициализацию внутреннего класса, но не гарантирует, что включающий класс инициализирован.

2. Это нарушит некоторые основные правила. вы можете перейти к последнему разделу (до two cases), чтобы избежать нубов

Одна вещь о static nested class, когда nested class равно static, он будет вести себя как обычный класс во всех отношениях и связан с внешним классом.

Но концепция Inner class / non-static nested class в том, что он будет связан с instance внешнего / включающего класса. Обратите внимание, что связано с экземпляром, а не с классом. Теперь связывание с экземпляром явно означает, что (из концепции переменной экземпляра) он будет существовать внутри экземпляра и будет отличаться для разных экземпляров.

Теперь, когда мы делаем что-то статическое, мы ожидаем, что оно будет инициализировано при загрузке класса и должно быть разделено между всеми экземплярами. Но из-за нестатичности даже сами внутренние классы (вы можете определенно забыть об экземпляре внутреннего класса сейчас) не являются общими для всех экземпляров внешнего / включающего класса (по крайней мере концептуально ), тогда как мы можем ожидать, что некоторая переменная внутреннего класса будет совместно использоваться всеми экземплярами внутреннего класса.

Итак, если Java позволяет нам использовать статическую переменную внутри не статического вложенного класса. будет два случая.

• Если он используется совместно со всем экземпляром внутреннего класса, это нарушит концепцию context of instance (переменная экземпляра). Тогда это НЕТ.
• Если он не является общим для всех экземпляров, это нарушит концепцию статичности. Снова НЕТ.

Начиная с версии Java 16, это уже не так. Цитата из JEP 395 (о завершении записей):

Ослабьте давнее ограничение, согласно которому внутренний класс не может объявить член, который является явно или неявно статическим. Это станет законным и, в частности, позволит внутреннему классу объявлять член, который является классом записи.

Действительно, следующий код можно скомпилировать с Java 16 (пробовал с 16.ea.27):

public class NestingClasses {

    public class NestedClass {

        static final String CONSTANT = new String(
                "DOES NOT COMPILE WITH JAVA <16");

        static String constant() {
            return CONSTANT;
        }

    }

}

Вот мотивация, которую я считаю наиболее подходящей для этого «ограничения»: вы можете реализовать поведение статического поля внутреннего класса как поле экземпляра внешнего объекта; Таким образом, вам не нужны статические поля / методы. Я имею в виду, что все экземпляры внутреннего класса некоторого объекта совместно используют поле (или метод).

Итак, предположим, вы хотите подсчитать все экземпляры внутреннего класса, вы бы сделали:

public class Outer{
    int nofInner; //this will count the inner class 
                  //instances of this (Outer)object
                  //(you know, they "belong" to an object)
    static int totalNofInner; //this will count all 
                              //inner class instances of all Outer objects
    class Inner {
        public Inner(){
            nofInner++;
            totalNofInner++;
        }
    }
}

Проще говоря, нестатические внутренние классы являются переменной экземпляра для внешнего класса, и они создаются только тогда, когда создается внешний класс и объект внешнего класса создается во время выполнения, в то время как статические переменные создаются во время загрузки класса. Итак, нестатический внутренний класс - это вещь времени выполнения, поэтому static не является частью нестатического внутреннего класса.

ПРИМЕЧАНИЕ: всегда относитесь к внутренним классам как к переменной для внешнего класса, они могут быть статическими или нестатическими, как и любые другие переменные.

Потому что это вызовет двусмысленность в значении слова «статика».

Внутренние классы не могут объявлять статические члены, кроме констант времени компиляции. Значение слова «статика» было бы двусмысленным. Означает ли это, что на виртуальной машине только один экземпляр? Или только один экземпляр на внешний объект? Разработчики языка решили не заниматься этим вопросом.

Взято из "Core Java SE 9 для нетерпеливых" Кея С. Хорстманна. Стр. 90 Глава 2.6.3

Думаю, это для последовательности. Хотя для него нет никаких технических ограничений, вы не сможете получить доступ к статическим членам внутреннего класса извне, то есть OuterClass.InnerClass.i, потому что средний шаг не статичен.