Когда использовать методы get / set в java

Я хочу знать, когда использовать методы get и set (getName, setName) в моем classе и когда simple classVariable.name = "" вместо а = classVariable.getName()

Вот пример classа с использованием методов set и get

 public class ClassExampe { String name; String course; public String getName ( ) { return name; } public void setName (String studentName) { name = studentName; } public String getCourse ( ) { return course; } public void setCourse (String studentCourse) { course = studentCourse; } } 

благодаря

Использование Getters / Setters vs using Fields

Как правило большого пальца:

используйте переменные непосредственно из того же classа (фактически из одного и того же .java-файла, поэтому внутренние classы тоже в порядке), используйте Getters / Setters из других classов.

Простое правило: никогда не используйте прямой доступ (за исключением, конечно, при обращении к ним изнутри classа).

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

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

В Java использование геттера и сеттера обычно считается лучшей практикой.

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

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

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

Одно из преимуществ заключается в том, что вы можете иметь не просто простое назначение и возврат. Пример:

 public void setLevel(int lvl) { if (lvl<0) { this.level=1; } else this.level = lvl; } public int getLevel() { if (this.someIndicator==4) return this.level*7.1; else return level; } 

Getters и Setters позволяют позже изменить реализацию (например, сделать что-то более сложное), позволить вам реализовать правила проверки (например, setName выдает исключение, если имя не превышает 5 символов, что бы то ни было).

Вы также можете добавить геттер, но не сеттер, чтобы переменная была похожа на «только для чтения».

Это теория, однако во многих случаях (например, Hibernate, использующая сеттеры) вы не можете генерировать исключения в сеттерах, поэтому вы не можете выполнять какую-либо проверку. Обычно значение будет просто присвоено / возвращено. В некоторых компаниях, над которыми я работал, было обязательно писать геттеры и сеттеры для всех атрибутов.

В этом случае, если вы хотите получить доступ к атрибуту извне объекта и хотите, чтобы он был доступен для чтения / записи, я просто использую открытый атрибут. Это меньше кода, и это означает, что вы можете писать такие вещи, как obj.var += 5 что легче читать, чем obj.setVar(obj.getVar() + 5) .

Если вы имеете в виду: когда использовать общедоступные методы доступа, вместо того чтобы сделать внутреннюю, приватную переменную общедоступной, мой ответ «всегда», если не существует серьезной причины производительности.

Если вы имеете в виду, вызовите свои собственные методы get и set vs прямого доступа к vars w / your class, я все равно скажу, что вы вызываете свои собственные методы доступа. Таким образом, любое преобразование, изменения или правила, которые вы реализуете как часть get / set, вызывается автоматически с помощью собственных внутренних вызовов, а также внешних вызывающих абонентов.

В чистых языках OO (например, Smalltalk) нет понятия public – все внутренние vars являются частными и поэтому вы должны использовать аксессоры. В менее чистых OO-языках вы можете сделать все общедоступным – однако разоблачение внутренних компонентов ваших структур данных и их реализация – исключительно плохая идея для стабильности и обслуживания в долгосрочной перспективе. Посмотрите на «тугое соединение», чтобы узнать больше об этом.

Проще говоря, если вы публично публикуете внутренние вары, люди могут получить к ним доступ напрямую, и если вы когда-либо меняете имя или набираете все по разрывам строк. Это называется побочным эффектом.

Это вопрос вкуса, но, как правило, вы всегда должны использовать методы get / set для всех общедоступных свойств. Но для таких вещей, как Value Objects (VO), с которыми вы, вероятно, не будете беспокоиться, в течение некоторого времени вы можете использовать общедоступные переменные без чрезмерной критики, я думаю.

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

Parenthesis: Однако это вполне возможно на других языках, например, в Scala, когда линия между свойствами и методами может стать довольно хорошей. И это здорово, так как тогда это не становится проблемой кодирования, которая мешает и делает использование более прозрачным.


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

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


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

Инкапсулируйте частные поля classа и выставляйте их с classами getter / setter так, как вы хотите.