Я знаю, что анонимные классы сохраняют ввод текста, когда дело доходит до реализации Listener и подобных материалов. Они пытаются заменить некоторые способы закрытия.
Но что думает сообщество о ценности этой языковой функции? Это имеет смысл, и вы используете его регулярно? Это делает код более понятным, понятным и более удобным для обслуживания? Или анонимные классы делают код менее удобочитаемым?
Каково ваше мнение и, пожалуйста, приложите примеры/аргументы, чтобы поддержать ваше мнение?
Я склонен использовать анонимные внутренние классы в ситуациях, когда мне не нужно иметь полномасштабный класс, чтобы выполнить какую-то задачу. Например, если я хочу реализовать ActionListener или Runnable, но я не думаю, что нужен внутренний класс. Например, для запуска простого Thread использование анонимного внутреннего класса может быть более читаемым:
public void someMethod()
{
new Thread(new Runnable() {
public void run()
{
// do stuff
}
}).start();
}
В некоторых случаях, таких как пример выше, он может повысить удобочитаемость, особенно для одноразовых задач, поскольку код, который должен быть выполнен, записывается в одном месте. Использование внутреннего класса "делокализует" код:
public void someMethod()
{
new Thread(new MyRunnable()).start();
}
// ... several methods down ... //
class MyRunnable implements Runnable
{
public void run()
{
// do stuff
}
}
Однако, если будут случаи, когда одно и то же будет повторяться, это должен быть отдельный класс, будь то обычный класс или внутренний класс.
Я предпочитаю использовать анонимные внутренние классы в программах, где я просто пытаюсь что-то сделать, а не как центральную функцию реального приложения.
Еще одно хорошее использование анонимного внутреннего класса - это когда вам нужно инициализировать коллекции, такие как ArrayList и Set. Эта практика также известна как инициализация двойной скобки Например,
private static final Set<String> VALID_CODES = new HashSet<String>() {{
add("XZ13s");
add("AB21/X");
add("YYLEX");
add("AR2D");
}};
Очевидно, что это не ограничивается коллекциями; его можно использовать для инициализации любого объекта - например объектов Gui:
add(new JPanel() {{
setLayout(...);
setBorder(...);
add(new JLabel(...));
add(new JSpinner(...));
}});
Мое мнение анонимных классов делает код менее удобочитаемым. Для реализации прослушивателей полезны анонимные классы. Для разработки GWT анонимные классы - лучший выбор. Для этих случаев, если мы не используем анонимные классы, количество строк кода будет увеличиваться.
Мы регулярно используем анонимные классы. Я нахожу их простыми в использовании для реализации интерфейсов, которые имеют только один или два метода и что там, где функциональность не не используется нигде. Если вы снова используете ту же функциональность где-то еще, должен существовать реальный класс для повторного использования.
Я использую анонимные классы в основном для интерфейсов, которые имеют только один метод, т.е. Runnable или ActionListener. Большинство более крупных интерфейсов защищают свои собственные классы или реализацию в уже существующем классе. И, как мне кажется, мне не нужны аргументы, чтобы поддержать его.
Если использование анонимного класса улучшает или ухудшает удобочитаемость, это вопрос вкуса. Главный вопрос определенно не здесь.
Анонимные классы, такие как внутренние классы, содержат ссылку на охватывающий класс, тем самым делая не частные вещи, которые без него были бы. Короче говоря, ссылка this охватывающего класса может выйти из внутреннего класса. Таким образом, ответ таков: очень плохой практикой является использование внутреннего класса, если он опубликовал себя, поскольку это автоматически опубликует охватывающий класс. например:
changeManager.register(new ChangeListener() {
public void onChange(...) {
...
}});
Здесь анонимный ChangeLstener передается методу register ChangeManager. Это также автоматически опубликует класс-оболочку.
Это определенно плохая практика.
Анонимный класс в основном рассматривается в приложении GUI специально для обработки событий. Анонимный класс полезен в случаях реализации небольших интерфейсов, содержащих один или два метода. Например.. у вас есть класс, в котором у вас есть два или три потока и вы хотите выполнить две или три разные задачи, используя эти потоки. В этой ситуации вы можете воспользоваться анонимным классом для выполнения ваших желаемых задач. посмотрите следующий пример
class AnonymousClass{
public static void main(String args[]){
Runnable run1=new Runnable(){
public void run(){
System.out.println("from run1");
}
};
Runnable run2=new Runnable(){
public void run(){
System.out.println("from run2");
}
};
Runnable run3=new Runnable(){
public void run(){
System.out.println("from run3");
}
};
Thread t1=new Thread(run1);
Thread t2=new Thread(run2);
Thread t3=new Thread(run3);
t1.run();t2.run();t3.run();
}
}
выход:
из run1
из run2
из run3
В приведенной выше ссылке кода я использовал три потока для выполнения трех разных задач. Посмотрите, что я создал три анонимных класса, которые содержат реализацию метода run для выполнения трех разных небольших задач.
Имеет смысл использовать их, но вы должны знать, что делается под ним. Я использую их только в том случае, если мне нужен класс, чтобы сделать что-то очень специфическое, что мне больше не нужно.
Это зависит от того, к чему вы их сравниваете. Я предпочел бы иметь их, чем не иметь их, но тогда я предпочел бы предоставить простые блоки кода таким методам, как Arrays.sort(), вместо того, чтобы явно создавать класс, содержащий мою реализацию compare().
Если ограничение объема и доступ как можно больше - это хорошо, то анонимные классы очень хороши. Они ограничены по охвату одним классом, который им нужен. Когда это уместно, я бы сказал, что анонимные классы хороши.
В тот момент, когда вы дублируете одну и ту же функцию, это становится плохой идеей. Реорганизуйте его в открытый класс, который стоит сам по себе. IDE с функциями рефакторинга делают это проще.
В анонимных классах нет ничего особенного или особенного. Это, в конечном счете, просто синтаксический сахар с поддержкой ссылки на внешний класс. Это упрощает создание адаптеров - как и большинство реализаций Iterator, возвращаемых структурой коллекций.
Я использую только анонимные классы a) сокращенное обозначение, если интерфейс имеет один или два метода и не влияет на читаемость
b) ситуация, когда я не смогу оправдать создание нового класса, например, в swing, когда вам нужно прикрепить actionlistner, чтобы позволить JButton для некоторой тривиальной операции.
Я согласен с тем, что многие другие говорили, что они полезны для небольших интерфейсов, когда они используются только один раз. Но я также добавил бы, что если код, внешний для анонимного класса, должен быть изменен для его работы, тогда не используйте анонимный класс.
Если вам нужно начать объявлять переменные как final для размещения класса anon, так как он ссылается на них, тогда вместо этого используйте внутренний класс. Я также видел некоторые неприятные запахи кода, где конечные массивы (размером 1) используются для возврата результатов из классов anon.
Анонимные классы не "скрывают" код, но они делают TEND, чтобы сделать его несколько менее многоразовым. Обратите внимание, что это относится и к закрытию.
В некотором смысле они разрешают некоторые хорошие рефакторы, потому что вам разрешено передавать код в метод. Это можно эффективно использовать для уменьшения дублирования, и я, конечно, не против анонимных классов/закрытий, однако есть несколько случаев, когда они могут быть недостатком.
Сначала подумайте, что код анонимного внутреннего класса, который вы передаете, не может повторно использоваться в вашем коде. Если вы делаете то же самое в каком-то другом коде, вам придется переписать его как нечто иное, чем анонимный внутренний класс, чтобы повторно использовать его, и в этот момент было бы трудно даже знать, что есть код в другом месте повторное использование.
Наряду с отсутствием повторного использования трудно определить параметризацию, что приводит к моей самой большой жалобе... они, как правило, приводят к копированию и вставке кода.
Я видел немало графических интерфейсов, где кто-то начинал с анонимных внутренних классов в качестве респондентов событий. Многим приходилось делать что-то немного другое: например, 5 строк кода, где единственная разница - это строка в середине. Как только вы привыкли использовать внутренние классы, простым решением является копирование и вставка блока и замена этой строки.
Решение о создании нового класса "Именованный", имеющего строковый параметр и передающего этот класс ко всем методам, редко встречается у кого-то в этой точке. Этот именованный класс может использовать параметры или наследование для определения разных типов поведения, а также кода.
Я поклонник закрытий и не ненавижу анонимные классы - просто указывая на некоторые подводные камни, которые я видел.