Я хочу знать, когда использовать методы get и set (getName, setName) в моем классе и когда просто classVariable.name = "" вместо а = classVariable.getName()
Вот пример класса с использованием методов 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;
}
}
Спасибо
Как правило:
используйте переменные непосредственно из одного и того же класса (фактически из одного и того же .java файла, поэтому внутренние классы тоже в порядке), используйте Getters/Setters из других классов.
Простым правилом является: никогда не использовать прямой доступ (за исключением, конечно, при обращении к ним изнутри класса).
Даже если этого не произойдет, что вам нужно какое-либо из них, это маловероятно. И если вы начнете с доступа к полю, это будет труднее изменить.
В Java использование геттера и сеттера обычно считается лучшей практикой.
Это связано с тем, что если вам когда-либо понадобится изменить свой код, чтобы сделать что-то еще, когда доступ к ресурсу или его изменение, вы можете просто изменить его в существующем геттере или сеттер.
Я склонен думать, что это вызывает некоторый беспорядок для простых объектов, но если вам когда-либо приходилось реорганизовывать общедоступное свойство в getter и setter, чтобы добавить дополнительные функции, вы увидите, что это может быть боль.
Я подозреваю, что большинство из них скажут, что всегда используют getters/setters для доступа к закрытым членам. Это не обязательно, но считается "лучшей практикой".
Одно из преимуществ заключается в том, что вы можете иметь не просто простое назначение и возврат. Пример:
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 and Setters позволяют позже изменить реализацию (например, сделать что-то более сложное), разрешить вам внедрять правила проверки (например, setName выдает исключение, если имя не более 5 символов, независимо.)
Вы также можете добавить геттер, но не сеттер, чтобы переменная была похожа на "только для чтения".
Чтобы теория, однако, во многих случаях (например, Hibernate, использующая сеттеры), вы не можете генерировать исключения в сеттерах, чтобы вы не могли выполнить какую-либо проверку. Обычно значение будет просто присвоено/возвращено. В некоторых компаниях, над которыми я работал, было обязательно писать геттеры и сеттеры для всех атрибутов.
В этом случае, если вы хотите получить доступ к атрибуту извне объекта и хотите, чтобы он был доступен для чтения/записи, я просто использую общедоступный атрибут. Это меньше кода, и это означает, что вы можете писать такие вещи, как obj.var += 5, который легче читать, чем obj.setVar(obj.getVar() + 5).
Если вы имеете в виду: когда использовать общедоступные методы доступа, вместо того чтобы сделать внутреннюю приватную переменную общедоступной, мой ответ "всегда", если не существует серьезной причины для производительности.
Если вы имеете в виду, позвоните по собственному методу get и set vs прямого доступа к vars w/in your class. Я все же говорю, что вы вызываете свои собственные методы доступа. Таким образом, любое преобразование, изменения или правила, которые вы реализуете как часть get/set, вызываются автоматически с помощью собственных внутренних вызовов, а также внешних вызывающих абонентов.
В чистых языках OO (например, Smalltalk) нет понятия public - все внутренние vars являются частными и поэтому вы должны использовать аксессоры. В менее чистых OO-языках вы можете сделать все общедоступным - однако разоблачение внутренних компонентов ваших структур данных и их реализация - исключительно плохая идея для стабильности и обслуживания в долгосрочной перспективе. Посмотрите на "тугое соединение", чтобы узнать больше об этом.
Проще говоря, если вы публично публикуете внутренние вары, люди могут получить к ним доступ напрямую, и если вы когда-либо меняете имя или вводите все по разрывам строки. Это называется побочными эффектами.
Это вопрос вкуса, но, вообще говоря, вы всегда должны использовать методы get/set для всех общедоступных свойств. Но для таких вещей, как Value Objects (VO), с которыми вы, вероятно, не будете беспокоиться, в течение некоторого времени вы можете использовать общедоступные переменные, не считая слишком много критики, я думаю.
В общем, вы хотите использовать сеттеры и геттеры, чтобы дать возможность разработчикам повторно использовать ваш код, изменив его или расширив его, чтобы добавить уровни обработки и управления при доступе и изменении внутренних данных. Это было бы невозможно в Java при использовании прямого доступа.
Скобка: Тем не менее, это вполне возможно в других языках, например, в Scala, когда линия между свойствами и методами может стать довольно хорошей. И это здорово, так как тогда это не становится проблемой кодирования, которая мешает и делает использование более прозрачным.
Вы также можете часто учитывать, что в своем классе вы можете свободно обращаться к своим внутренним (частным или защищенным) членам напрямую, так как вы должны знать, что делаете, и вам не нужно накладные расходы еще одного вызова метода.
На практике многие люди, работающие над классом, могут не знать, что делают все, и те строки проверки целостности в ваших геттерах и сеттерах могут быть полезны в большинстве случаев, в то время как микро-оптимизация не может.
Кроме того, существует только один способ доступа к переменной напрямую, тогда как вы можете определить как можно больше аксессуаров.
Инкапсулируйте частные поля класса и выставляйте их с классами getter/setter так, как вы хотите.