2012-03-01 3 views
4

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

private static int number; 

И они, как правило, имеют методы доступа, такие как

public static int returnNumber(){ 

    return number; 

} 

Но мой вопрос, в чем смысл? То, как я это сделать это

int number; 

Вслед за этим, когда мне нужно, чтобы получить доступ к этому

int numberToBeAssigned = someClass.number; 

вместо

int numberToBeAssigned = someClass.getNumber(); 

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

Спасибо

+1

Это будет закрыто как «неконструктивное» реальное быстро, но позвольте мне просто сказать, что вы не ошибаетесь *, вы, вероятно, никогда не работали ни на что на самом деле * большой *. 'private' позволяет вам гарантировать« переменные только для чтения », и без них отладка может быть непредусмотренным кошмаром. –

ответ

6

Точки аксессоров как это позволит вам перепроектировать реализации, не нарушая все остальные ваш код. Например, что, если позже вы решите, что number должен поступать из файла? Или нужно переместить в другой класс?

Если у вас есть ограниченный доступ для доступа к аксессуру, вы можете вносить такие изменения, и вам остается только изменить аксессор - вам не нужно изменять весь другой код, который зависит от него.

+0

Отлично! Теперь это имеет гораздо больший смысл. Спасибо. – Blackvein

0

Вот в перспективе wikipedia:

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

2

Это все об инкапсуляции. Открытые поля позволяют любому классу ol прийти и изменить ваши ценности и, возможно, нарушить ваши инварианты. Если у вас есть только public int foo, любой может установить его. Если это private int foo, и вы предоставляете геттер, люди могут его получить. Если вы предоставляете геттер и сеттер, то они могут делать оба: , но у вас все еще есть контроль над ним; вы можете отклонить изменение, которое нарушит предположения, которые класс должен (или хочет) сделать.

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

Действительно, это касается основных принципов OO: ваш класс - это не просто капля состояния, это что-то, у которого есть свойства и действия - и под капотом есть состояние, отражающее эти действия. Так, например, когда вы запрашиваете length(), вы не концептуально заботитесь о том, было ли это сообщено назад как кешированное значение, или же он повторил эти элементы и пересчитал их; вы просто хотите его длину.

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

0

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

0

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

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

Хорошо зарекомендовавший себя способ - это написать «Единичные тесты», но это только подтверждает тип изоляции. Минимизируя изложение состояния типа и ограничивая его на хорошо понятные и планируемые операции, программист пытается свести к минимуму сбои модели, которую он или она смог проверить.

Наоборот, если внешние компоненты имеют способы доступа к состоянию компонента за пределы тех, которые планируются дизайнером этого типа, им легко непреднамеренно нарушить его поведение. И взаимодействия между компонентами экспоненциальны: по моему опыту, когда программа охватывает более 20 000 строк кода, автор нескольких разработчиков, каждый из которых специализируется в отдельных модулях, и проходит через несколько версий, никто не будет иметь идеального представления о целом код больше.

На эту тему написано много книг и статей, и я уверен, что они будут более красноречивыми и убедительными, чем я могу быть. Для общих рекомендаций на Java я настоятельно рекомендую эффективную Java Josh Bloch (2-е издание).

Смежные вопросы