Что такое метод-локальный внутренний класс?

Ответ 1

Использование методов-локальных классов может повысить удобочитаемость вашего кода, совместив связанные части. Предположим, что у вас есть метод, который должен создать поток, чтобы сделать что-то в фоновом режиме:

class Test {
    void f() {
        // lots of stuff
        new Thread(new Runnable() {
            public void run() {
                doSomethingBackgroundish();
            }
        }).start();
        // lots more stuff
    }
}

Без методов-локальных классов вам придется либо:

• создать новый именованный класс внутри Test для выполнения фоновой обработки или
• создайте новый именованный класс в отдельном исходном файле для выполнения фоновой обработки.

Оба эти параметра могут уменьшить читаемость кода, перемещая соответствующую обработку в другом месте в исходном дереве (возможно, в том же исходном файле, возможно, в другом исходном файле). Использование локального класса method сохраняет логику обработки в том месте, где она используется.

Это, конечно, неприменимо для всех ситуаций, но может быть очень полезно в ряде распространенных ситуаций. Такой код обычно используется для прослушивателей действий GUI, которые представляют собой очень маленькие классы, которые обычно просто передают вызовы метода действий из одного места в другое.

Ответ 2

Поскольку большинство людей, вероятно, никогда не видели локальный внутренний метод method, вот пример:

public class TestMethodLocalInnerClass
{
    public static void main(String[] args)
    {
        class Greeter implements Runnable
        {
            private final String _greeted;

            public Greeter(String greeted)
            {
                super();
                _greeted = greeted;
            }

            public void run()
            {
                System.out.printf("Hello %s!\n", _greeted);
            }
        }

        new Greeter("world").run();
        new Greeter("dog").run();
    }
}

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

Поэтому, на мой взгляд, не стоит включать его в новый язык.

Ответ 3

Локальные внутренние классы (кроме анонимных внутренних классов) полезны только время, хотя у меня нет статистики для вас. Вероятно, подавляющее большинство программистов Java не знают, что они существуют, поэтому не собираются их использовать.

Почему? Ну, хорошо иметь ступеньку между анонимным внутренним классом и стандартным внутренним классом. То, как все сложилось, я бы не ожидал, что они будут в JLS, если бы это было стандартизировано сейчас. Во время обновления был относительно небольшой опыт работы с новыми функциями, хотя новая модель событий AWT была тесно связана.

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

Ответ 4

Он позволяет иметь конструктор (или несколько) и возможность вызова новых методов в классе и по-прежнему получать доступ к конечным переменным, объявленным в содержащем методе.

Стоит ли накладные расходы? Возможно, не в ретроспективе, но я думаю, что в то время совершенно не было очевидно, что ограничения, стоящие за анонимными внутренними классами (никаких конкретных конструкторов и отсутствие возможности вызывать новые методы вне класса) были чем-то, что можно было просто оставить без альтернатива.

Ответ 5

Я предполагаю, что вы имеете в виду анонимный внутренний класс? Это в основном закрытие. Вы можете передать его обратно из метода, и он сохраняет область переменных, где он был определен. Это полезно для таких вещей, как UI-слушатели в Swing.

Ответ 6

Ответ на этот вопрос - вопрос:

Как вы определяете класс таким образом, что вы собираетесь использовать этот класс только с одной функцией? Например: класс A имеет 2 функции fun1 и fun2. Как вы определяете класс, чтобы он использовался только fun2?

Если вы определяете этот класс вне методов, то каждый метод начнет его использовать. Как вы отделяете его для использования только в функции? Это можно сделать, сделав этот класс локальным внутренним классом для этой функции. Вы можете считать это локальной переменной функции, которая не может использоваться другими функциями. Эта концепция также называется повышенным уровнем безопасности или инкапсуляции.

Ответ 7

Это может быть полезно для инкапсуляции/масштабирования. Например. остальная часть кода не загрязняется определением класса, предоставляемая функциональность которого относится только к этому методу.

Это в основном те же преимущества, что и анонимные внутренние классы, но есть некоторые преимущества перед анонимным внутренним классом:

• несколько экземпляров могут быть созданы внутри метода
• может расширить класс AND реализовать еще один интерфейс.
• может иметь конструктор