Каков Ваш Java 'правила'?

Считайте эффективный Java блоховским.

Это точно, что Вы просите, ряд правил для написания действительно большого, идиоматического кода Java.

Я видел довольно хороший совет, который я пытаюсь применить: постарайтесь не инициализировать поля класса к значениям по умолчанию.

Я все еще часто вижу:

public class Foo
{
  boolean b = false;
  int n = 0;
  float x = 0.0;
  SomeClass sc = null;
}

и так далее.

Это неэффективно (хотя на незначительном уровне), так как JVM уже установила значения в переменное время выделения, ужасное (и отвлечение читателя от значений не по умолчанию) и раздражающий при отладке времени (мы должны ступить туда во время создания класса).

Некоторые люди сказали, что существуют случаи, где такой init необходим, но не не мог представить реальный случай. Если у кого-то есть больше информации здесь...

1. Используйте рекурсию как можно меньше. Существует использование для рекурсии, но большую часть времени простой цикл сделает то же задание без издержек, созданных с рекурсией.

2. используйте Дженерики, если это возможно. Много раз класс может использоваться для приложения, о котором Вы никогда не думали, когда он был разработан. Дженерики упрощают процесс повторного использования без рефакторинга.

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

• Создайте объекты когда это применимо.

• Гарантируйте эффективность в своем коде, разве повторитесь, не кодируют (никакой copy+paste mkay?.

Код, Завершенный Steven McConnel, имеет много полезных подсказок, не только для программирования в Java, но и для программирования обычно.

Большой набор совета!

Давайте посмотрим, что я не видел упомянутый..

используйте много маленьких классов. Каждый класс должен сделать одну вещь хорошо. Я никогда не видел слишком много классов, фактически всегда лишь немногие.

прочитайте книгу Рефакторинга - раздел по Плохим Запахам Кода перечисляет много материала для внимательности.

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

Не инициализируйте локальные переменные как привычку (Представьте s=null в виде строки;), иначе компилятор не может поймать эту проблему:

String s;
if(x == 5)
    s="5";

if(y == 5) 
    s.append("5"); // Compiler will tell you s might not have been assigned
                   // UNLESS your first line was "String s=null"

Изучите Javadocs. Просто привыкните использовать их, они не сложный.

Используйте Eclipse или NetBeans. Поднимите проверку ошибок. Обратите внимание на ошибки. Некоторые, что можно решить, не важны, но многие помогут.

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

В SDK существуют некоторые библиотеки AMAZING. Усовершенствованное управление поточной обработкой, Классы ссылки, NIO и отражение все пропущены многими программистами - и это просто царапает поверхность.

Тем не менее не злоупотребляйте отражением - оно может сделать Ваш код трудно для поддержания - просто знают, что это там и что оно может сделать.

Не "Аннулируйте" переменные к свободной памяти - это никогда не фактически полезно и делает, Вы быть похожими на Вас не понимаете Сборку "мусора". Еще более глупый выполнить в нем завершить метод.

Хм, в то время как мы там - не используют, завершают методы. Когда-либо. Если необходимо очистить внешний ресурс, искать классы ссылки (WeakReference).

В моем уме самые важные вещи:

1. Форматирование: Я не могу понять код с неверным форматом.
2. Хорошее именование: хорошее соглашение о присвоении имен является первым шагом к хорошему коду.
3. Документация: всегда пишите документацию о том, что код и почему это сделано этот путь
4. Не повторяйте код
5. Используйте технику, упомянутую в "эффективном Java". Эта книга предоставляет очень полезную инструкцию.

Используйте и поймите Платформу Набора Java.

Используйте класс ArrayList вместо Vector. Использовать HashMap вместо Hashtable.

Для синхронизируемого доступа используйте Collections служебный класс.

Только используйте Hashtable и Vector если действительно необходимо кодировать против некоторого API прежней версии.

Будьте либеральны в том, что Вы принимаете и конкретный в том, что Вы возвращаете.

Например, возьмите метод общего назначения со следующей подписью:

public void doXY(LinkedList widgets)

С этой подписью клиенты не могут использовать Ваш метод общего назначения с другим Lists или даже a Set ввести. Входной тип параметра может часто расширяться для создания метода более гибким для использования, например:

public void doXY(Collection widgets)

Никогда не выполняйте трудоемкие задачи в потоке отправки события AWT, или у Вас будет небыстро реагирующий GUI.

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

Рассмотрите Java API. Особенно util пакет. Существуют многие библиотеки там, чтобы сделать общие задачи, и многократное использование их намного лучше, чем прокрутка Вашего собственного.

Если Вы используете наследование вместо состава, Вы, вероятно, делаете его неправильно.

Вещи необходимо всегда делать.

Прочитайте спецификацию языка Java. Это окупается чрезвычайно, если у Вас есть некоторые знания, по крайней мере, в еще одном языке ООП.

Необходимо зарегистрировать Вас код!

• Необходимо зарегистрировать весь код, который Вы пишете. Когда Вы возвращаетесь и читаете его 3 месяца спустя, крайне важно, чтобы Вы оставили некоторые подсказки, что делает код.
• Вы не должны документировать то, что делает код, как это тут же в коде.
• Необходимо, однако, зарегистрировать, почему код там. Вы будете обладать намного большим преимуществом 'почему' комментарии затем 'какой' комментарии в конечном счете.
• Если это твердо к документу, возможности - Вы, не думали достаточно о проблеме.

Сравнения равенства

При выполнении сравнения равенства думайте о том, хотите ли Вы выдержать сравнение для равенства значения (сделайте два объекта имеют то же значение), или ссылочное равенство (они тот же самый экземпляр объекта). Для ссылочного равенства используйте == оператор; для равенства значения Вы будете обычно хотеть использовать .equals() метод.

(Обратите внимание, что неосновные классы Java могут или не могут иметь значимого .equals () реализация; большинство базовых классов действительно имеет хороший .equals () реализацией.)

Например, частая ошибка состояла бы в том, чтобы сделать (string1 == string2) попытаться определить ли строковые переменные string1 и string2 представьте то же строковое значение.

При повторении себя, такой как копией и вставкой, Вы делаете ее неправильно. Java является языком OO, используйте его тот путь.

Если Вы не используете шаблоны разработки, Вы изобретаете велосипед. Удивительно, сколько проблем лучше всего решено исходными шаблонами разработки GOF. Только после рассмотрения их должен Вы делать что-то другое.

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

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

Перегрузка метода хороша, и она может сохранить Вас от преобразования типа повсеместно.

Постарайтесь не быть "умными" таким способом, который делает более трудным понять код, который Вы написали. Используйте как можно больше созданное в функциях языка (например, Итераторы). Сделайте самую простую вещь, которая могла возможно работать. Вы будете благодарить себя позже.

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

После отладки начальной буквы ничто не должно быть трудно кодировано. Для объектов, используемых через приложение, таких как среда и похожие сообщения, хранилище как можно больше объектов в базе данных. Если Вы будете думать, что эти объекты никогда не будут изменяться, использовать файлы свойств и globals файл Java для вещей, что Вы убеждены, то никогда не будет изменяться, потому что они будут.

Автоматически форматируйте свой код с помощью IDE, даже если он делает это ужасным, Вы все еще более обеспечены в конечном счете.

Если существует известная, и надежная платформа для чего-то, используйте ее. JSF или Struts будут лучше, чем что-нибудь, что Вы могли разработать самостоятельно, даже если Вы думаете, что Ваша собственная платформа MVC действительно прохладна. То же самое с персистентностью, используйте что-то господствующая тенденция. Попытайтесь использовать в качестве немногих или одной платформы, если это возможно. Вы могли бы произвести на своих друзей впечатление, чтобы иметь Spring, Сланец, JSF, использование проекта Struts В спящем режиме наряду с некоторой другой платформой, которую Вы разработали сами, но это - действительно просто сложность ради сложности.

Одно мое должно придерживаться Sun, кодирующего конвенции.

Хорошо, мозговая атака:

• Думайте в классах и объектах, не в функциях.
• Избегайте пустых пунктов выгоды (особенно выгода (Throwable t) {})
  • Обработайте ошибку, не игнорируйте ее.
  • Обработайте только тип исключения, которое Вы хотите обработать в месте, можно обработать его.
• Используйте Javadoc.
  • Заставляет Вас думать о том, что Вы делаете.
  • Генерирует документацию при разработке.
  • Позволяет IDE как Eclipse показать подсказки при использовании классов и методов.
• Попытайтесь использовать дженерики и аннотации для привыкания к нему.

Существуют намного больше, но они, где первое, которое вошло в мой ум.

Между прочим, если Вы будете совершенствоваться от новичка эксперту, то Вы будете знать, когда сделать исключения к тем правилам ;)

всегда пишите модульные тесты как можно больше. Существует 2 основных платформы модульного теста - junit и TestNG. У каждого из них есть экосистема других расширений тестирования. наличие модульных тестов вселяет в Вас веру. После того, как кто-то добавил новый код или изменил код, можно найти, повреждается ли система или НЕ путем выполнения модульных тестов на всем протяжении.

Кроме того, сообщество Java охватило Непрерывные системы Интеграции. Многие из них являются открытым исходным кодом - планируют создание Вашего программного обеспечения регулярно. Если Вы, разверните его и выполните Интеграционные тесты на них, НО по крайней мере, может создать и регулярно выполнять модульные тесты.