PHP - Отправить cookie с file_get_contents
Во всех примерах исходного кода Java, которые я рассмотрел, слушатели всегда были объявлены во внутренних классах.
Почему - что такое причина кодирования таких классов вместо того, чтобы иметь слушателя (ов) в их собственном отдельном * .java файле \ классе?
Будет ли наличие отдельных классов для слушателей считаться плохим дизайном?
Если это не плохой дизайн \ оскорбление может кто-нибудь опубликовать короткий пример, демонстрирующий, как это реализовать?
Благодарю за чтение.
Edit \ Update - 10.8.2010: Спасибо всем, кто нашел время ответить. Следует учесть множество важных моментов. Прочитав все ответы, я думаю, что, если нет очень веской причины поступить иначе, лучше и проще объявить слушателей как внутренние классы.
Извиняюсь за то, что не вернусь к этому вопросу раньше, но я не всегда столько времени на кодирование, сколько мне бы хотелось: - (
Удачного кодирования.
6 ответов
Веские причины для использования внутренних классов:
- Избегает добавления дополнительных классов верхнего уровня в пространство имен вашего пакета
- Сохраняет код локально инкапсулированным (например, в компоненте, который требует поведения обработки событий)
- статические внутренние классы хорошо работают, когда им не нужен доступ к полям включающего класса
Возможные причины использования классов верхнего уровня:
- У вас есть специальный тип слушателя, который, как вы ожидаете, будет использоваться внешними пакетами или является частью вашего API (например, в самой библиотеке классов Java)
- Слушатель используется во многих местах и не является логически специфичным ни для одного из многих возможных включающих классов
Вкратце: внутренние классы обычно предпочтительны, но если у вас есть хорошие по причинам, тогда может быть вполне разумно вместо этого создавать классы верхнего уровня.
Нет, я не думаю, что они всегда должны быть внутренними классами. Это подразумевает, что пользовательский интерфейс сам всегда знает, как сделать лучший выбор слушателя.
Другой способ взглянуть на это может заключаться в том, что слушатели внедряются в пользовательский интерфейс. Возможно, их предоставляет контроллер, который инстанцирует UI и указывает ему, как реагировать на события UI.
Я думаю, что это больше похоже на взгляд на мир, основанный на инъекции зависимостей. В нем могут быть важные преимущества.
В этом ответе обсуждаются компромиссы различных способов.
Основной ответ заключается в том, что код графического интерфейса пользователя в программе обычно очень взаимосвязан и не может использоваться совместно между программами. Выполнение внутренних классов (особенно если вы примете способ, который я предлагаю в связанном ответе выше) позволяет вам структурировать код графического интерфейса так, чтобы его можно было поддерживать, при этом принимая, что графический интерфейс сильно связан.
Если вы видели их в примерах, возможно, вам будет проще. Скорее всего, вам будет предложено просто взять текущий класс и реализовать слушателя. Какой из них выглядит проще: создание 2 классов в 2 файлах, использование вложенного слушателя внутри основного класса или просто ваш основной класс в качестве слушателя? (Подсказка: это не первый)
Я ленив и просто использую основной класс, реализующий интерфейс ActionListener. Конечно, это работает только с очень простыми графическими интерфейсами. Для более крупных проектов их следует разделять.
Что касается сохранения Listener в отдельном классе, спросите себя: нужно ли это использовать другим классам? Классы должны быть в собственном файле ТОЛЬКО в том случае, если другим необходимо их использовать. И совместное использование Listeners - не самая лучшая идея, если у вас нет какой-то странной компоновки, в которой кнопки делают одно и то же, но расположены по-разному для каждого класса.
Вкратце: держите их вложенными или реализованными, а не отдельными, если это не необходимо. Однако необходимых случаев будет немного
Вы, конечно, можете реализовать прослушиватель в отдельном файле класса в отдельном файле .java. Java 1.1 представила идею анонимного класса и внутреннего класса вместе с редизайном события awt много лет назад. Причина в том, что часто записываемым вами слушателям необходимо обновлять и / или читать поля из класса, который содержит объекты, в которых генерируются события. Ссылка на эти поля из не внутреннего / анонимного класса затруднительна.
Если вы больше будете использовать анонимные классы, вы увидите, что это действительно упрощает написание и поддержку в дальнейшем. Современные IDE в любом случае даже сгенерируют большую часть кода за вас. Например, введите эти две строки в IntelliJ IDEA и нажмите ctrl-shift-space. IntellJ вставит анонимный класс, который реализует все методы интерфейса, указанного в addActionListener ().
JButton jb = new JButton("ok");
jb.addActionListener(new
Внутренний класс является локальным для текущего класса, что хорошо в том случае, если эти классы не нужно использовать в других местах. В примере в книге классу дается имя, что позволяет легко ссылаться на него из прозы.
Типичное применение слушателей состоит в том, что они используются только в одном месте, и для этой цели идеально подходят анонимные внутренние классы. Для интерфейсов с большим количеством методов (например, MouseListeners) обычно существует соответствующий адаптер с пустыми реализациями всех методов, которые затем могут быть переопределены по мере необходимости. См. MouseAdapter.