Отступ код группы вызова переменной функции условность

Question

У меня есть эта привычка отступов группу вызовов функций, как это:

List <Dog> dogs = new ArrayList<>(); 
    dogs.add(new Dog(1)); 
    dogs.add(new Dog(2)); 
    dogs.add(new Dog(3)); 
    dogs.add(new Dog(4)); 
    dogs.add(new Dog(5)); 
System.out.println("list of dogs: " + dogs); 
Cat cat1 = new Cat(1); 
    cat.meow(); 
    cat.startsRunningFrom(dogs); 
Dog d1 = dogs.get(1); 
d1.catches(cat1); 

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

Для меня, приведенных выше код гораздо более удобная для чтения, чем без:

List<Dog> dogs = new ArrayList<>(); 
dogs.add(new Dog(1)); 
dogs.add(new Dog(2)); 
dogs.add(new Dog(3)); 
dogs.add(new Dog(4)); 
dogs.add(new Dog(5)); 
System.out.println("list of dogs: " + dogs); 
Cat cat1 = new Cat(1); 
cat.meow(); 
cat.startsRunningFrom(dogs); 
Dog d1 = dogs.get(1); 
d1.catches(cat1); 

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

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

Answer 1

Действительно ли это плохая практика в кодексе, или на самом деле об этом не говорят?

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

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

Другое дело, что я привык видеть общепринятые соглашения, которые ниже фрагмента кода обманывают меня, предполагая начало и конец блока.

List<Dog> dogs = new ArrayList<>(); 
----> dogs.add(new Dog(1)); 
     dogs.add(new Dog(2)); 
     dogs.add(new Dog(3)); 
     dogs.add(new Dog(4)); 
     dogs.add(new Dog(5)); <---- 
System.out.println("list of dogs: " + dogs); 

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

Answer 2

Я ценю ваше мышление, и я не думаю, что есть что-то по своей сути плохое в том, что вы делаете. Но дело в том, что в организациях, где несколько разработчиков будут работать над одним и тем же кодом, важно иметь согласованные правила стиля. Точные правила будут варьироваться от организации к организации или от команды к команде внутри организации (где я работаю, разные команды могут принимать разные стили, хотя они не будут радикально отличаться). Но когда дело доходит до таких вещей, как отступы, интервалы, где начинать новую строку и т. Д., Преимущество последовательного стиля обычно перевешивает любые выгоды, которые вы можете получить, делая это таким образом, который кажется вам более логичным. Мне иногда не нравятся варианты стиля, которые навязываются мне, но в таких вопросах не стоит спорить. Однако, если вы в команде, вы можете попытаться убедить их, что ваш стиль лучше в таком случае. Недостатком этого является то, что более простой набор правил может быть запрограммирован в среду IDE, которая затем автоматически будет перемещать вещи в соответствии с стилем вашей команды.

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

Кроме того, в случае, когда у вас есть список и добавляется ряд элементов к нему, вы должны изучить Google Guava, который имеет некоторые методы для настройки списка с вызовом, который принимает переменное количество аргументов (например newArrayList в Lists class.

Answer 3

это несколько спорный вопрос/на усмотрение команды. Тем не менее, я согласен, что ваш отступы лучше не отступа. Я не думаю, что ни на есть лучшее решение. Как об этом :

List<Dog> dogs = initializeDogs(); 
System.out.println("list of dogs: " + dogs); 
initializeCat(dogs); 
Dog d1 = dogs.get(1); 
d1.catches(cat1); 

И затем объявите вспомогательные методы для выполнения необходимых действий:

private ArrayList<Dog> initializeDogs() { 
ArrayList<Dog> dogs = new ArrayList<>(); 
dogs.add(new Dog(1)); 
dogs.add(new Dog(2)); 
dogs.add(new Dog(3)); 
dogs.add(new Dog(4)); 
dogs.add(new Dog(5)); 
return dogs; 
} 

private void initializeCat(List<Dog> dogs) { 
Cat cat1 = new Cat(1); 
cat.meow(); 
cat.startsRunningFrom(dogs); 
} 

Дело в том, что ваше соглашение об отступлении, вероятно, не обязательно, если вы инкапсулируете свои методы, используя лучшие практики.