Лучшая практика Java: вложенные геттеры? Или делегатов?

Без сомнения, это вопрос n00b, но я был бы признателен за руководство или ссылку.

Я пишу приложение для Android-игр, которое включает в себя большое количество взаимодействия между Activity и другими классами. При этом я не уверен, что лучше использовать, например, для вызова метода «updatePlayer».

Выбор А – это цепные геттеры, поэтому у меня может быть в myActivity:

mGame.getPlayerList().getCurrentPlayer().updateScore(score); 

Выбор B – это делегирование (надеюсь, я правильно использую этот термин):

 mGame.updateCurrentPlayerScore(score); 

Затем в игре:

 playerList.updateCurrentPlayerScore(score); 

Затем в PlayerList:

 currentPlayer.updateScore(score); 

Я вижу преимущество Choice B, потому что тогда я свободен, чтобы изменить структуру и поведение playerList и Game, но он уверен, добавляет много однострочных методов.

Думаю ли я правильно? Есть ли выбор C или D?

Лично я всегда думал о стилях кодирования как о мнении. Если ваша кодировка только для вас, вы делаете то, что работает и является самым простым для вас. Например, в java вы называете переменные в верблюжьем случае ( intVar ), но в python вы используете int_var подчеркивания ( int_var ). Было бы неважно, если бы вы использовали символы подчеркивания в java и camel case в python в независимой среде.

Однако…

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

Для вашего сценария, что когда-либо плавает лодкой. Традиционно геттеры и сеттеры являются принятым стилем кодирования для java.

Расширение ваших классов также может помочь не показывать вашу реализацию классов более высокого уровня.

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

Взгляните на следующие примеры: использование делегирования

 class A { void a1() {} void a2() {} } class B { A a; void b_a1() { a.a1(); } void b_a2() { a.a2(); } void b1() {} void b2() {} } class C { B b; void c_b_a1() { b.b_a1(); } void c_b_a2() { b.b_a2(); } void c_b1() { b.b1(); } void c_b2() { b.b2(); } } 

По сравнению с обычными цепными геттерами :

 class A { void a1() {} void a2() {} } class B { A a; void b1() {} void b2() {} } class C { B b; } 

Это не общее правило для всех ситуаций, но второй пример приводит к более чистому дизайну, классы не связаны так же, как в первом примере.