Что Вы называете индикатором выполнения цикличного выполнения?

в учебном руководстве по Java говорится :

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

Говоря обычным языком, термины, "вложенные" и "внутренние", используются попеременно большинством программистов, но я использую правильный термин, "вложил класс", который покрывает и внутренний и статичный.

Классы могут быть вложены до бесконечности , например, класс A может содержать класс B, который содержит класс C, который содержит класс D, и т.д. Однако больше чем один уровень вложения класса редок, поскольку это - вообще плохой дизайн.

существует три причины, Вы могли бы создать вложенный класс:

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

существует четыре вида вложенного класса в Java. Короче говоря, они:

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

, Позволило мне уточнить более подробно.

Статические Классы

Статические классы являются самым легким видом для понимания, потому что они не имеют никакого отношения к экземплярам содержания класса.

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

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

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

Внутренние Классы

внутренний класс является классом, объявленным как нестатический член другого класса:

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

    private void jerry() {
        Goat g = new Goat();
    }
}

Как со статическим классом, внутренний класс известен, как квалифицировано его содержанием имени класса, пицца. Носорог. Коза , но в содержании класса, это может быть известно его простым именем. Однако каждый экземпляр внутреннего класса связывается с конкретным экземпляром своего содержания класса: выше, Коза созданный в [1 120] Джерри , неявно связывается с Носорог экземпляр это в [1 123] Джерри . Иначе мы делаем связанное Носорог экземпляр явный, когда мы инстанцируем Коза :

Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();

(Замечают, Вы называете внутренний тип как всего Коза в странном новый синтаксис: Java выводит содержание типа из носорог часть. И, да новый носорог. Коза () имела бы больше смысла мне также.)

Поэтому, что это получает нас? Ну, внутренний экземпляр класса имеет доступ к членам экземпляра содержания экземпляра класса. Эти члены экземпляра включения упомянуты во внутреннем классе через [1 130] просто их простые имена, не через [1 131] это (, это во внутреннем классе относится к внутреннему экземпляру класса, не связанному, содержащему экземпляр класса):

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

Во внутреннем классе, можно обратиться к [1 134] это из содержания класса как [1 135] Rhino.this, и можно использовать это , чтобы относиться к его участникам, , например, Rhino.this.barry.

Локальные Внутренние Классы

А локальный внутренний класс является классом, объявленным в теле метода. Такой класс только известен в рамках его содержания метода, таким образом, это можно только инстанцировать и получать доступ к его участникам в рамках его содержания метода. Усиление - то, что локальный внутренний экземпляр класса связывается с и может получить доступ к заключительным локальным переменным своего содержания метода. Когда экземпляр использует финал, локальный из его содержания метода, переменная сохраняет значение, которое это содержало во время создания экземпляра, даже если переменная вышла из объема (это - эффективно сырая, ограниченная версия Java закрытий).

, поскольку локальный внутренний класс не является ни один членом класса или пакета, он не объявляется с уровнем доступа. (Будьте ясны, однако, как который у его собственных участников есть уровни доступа в нормальном классе.)

, Если локальный внутренний класс объявляется в методе экземпляра, инстанцирование внутреннего класса связывается с экземпляром, сохраненным содержанием метода это во время создания экземпляра, и таким образом, содержание членов экземпляра класса доступно как в экземпляре внутренний класс. Локальный внутренний класс инстанцируют просто через [1 139] его имя, , например, , локальный внутренний CAT класса инстанцируют как [1 142] новый CAT () , не новый это. CAT (), как Вы могли бы ожидать.

Анонимные Внутренние Классы

анонимный внутренний класс является синтаксически удобным способом записать локальный внутренний класс. Обычно, локальный внутренний класс инстанцируют самое большее только однажды каждый раз, когда его содержание метода выполняется. Было бы хорошо, тогда, если бы мы могли бы объединить локальное внутреннее определение класса и его единственное инстанцирование в одну удобную форму синтаксиса, и также было бы хорошо, если бы мы не должны были продумывать название класса (чем меньше бесполезных имен Ваш код содержит, тем лучше). Анонимный внутренний класс позволяет обе этих вещи:

new *ParentClassName*(*constructorArgs*) {*members*}

Это - выражение, возвращая новый экземпляр класса без имени, который расширяется ParentClassName. Вы не можете предоставить своего собственного конструктора; скорее каждый неявно предоставляется, который просто вызывает супер конструктора, таким образом, предоставленные аргументы должны соответствовать супер конструктору. (Если родитель содержит несколько конструкторов, “simplest”, которыми каждого называют, “simplest”, как определено довольно сложным рядом правил, который не стоит потрудиться учиться подробно - просто, обращают внимание на то, что NetBeans или Eclipse говорят Вам.)

, С другой стороны, можно определить интерфейс для реализации:

new *InterfaceName*() {*members*}

Такое объявление создает новый экземпляр класса без имени, который расширяет Объект и реализует InterfaceName. Снова, Вы не можете предоставить своего собственного конструктора; в этом случае Java неявно предоставляет пустого конструктора без аргументов (таким образом, никогда не будет аргументов конструктора в этом случае).

Даже при том, что Вы не можете дать анонимному внутреннему классу конструктора, можно все еще сделать любую установку, Вы хотите использовать блок инициализатора ({} блок, помещенный вне любого метода).

Быть ясным, что анонимный внутренний класс является просто менее гибким способом создать локальный внутренний класс с одним экземпляром. Если Вы хотите локальный внутренний класс, который реализует несколько интерфейсов или который реализует интерфейсы при расширении некоторого класса кроме [1 145] Объект или который определяет его собственного конструктора, Вы застреваете, создавая регулярный именованный локальный внутренний класс.