Public int get java
Вопрос, почему мы не задаем в конструкторе класса значение через сеттер (в котором выполнена проверка на валидность), а задаем что-то типа this.value = value (вместо setValue(value)) ?? Ниже написал код в виде примера. Если бы в конструкторе было this.value = value, то при инициализации объекта значением например -3 в конструкторе всё было бы ОК. А сеттер в конструкторе не даст сделать такой глупости.
public class Main < public static void main(String[] args) < //это значение не вызовет ошибку, пока оно положительное: MyClass myClass = new MyClass(3); //MyClass myClass = new MyClass(-3) //тут будет ошибка! myClass.setValue(4); //это значение не вызовет ошибку //myClass.setValue(-4); //а это вызовет ошибку! System.out.println(myClass.getValue()); >> class MyClass < private int value; public MyClass(int value) < setValue(value); >public int getValue() < return value; >public void setValue(int value) < if (value < 0) < throw new IllegalArgumentException ("Значение value должно быть положительным числом!"); >this.value = value; > > Для быстрого создания getter и setter в IntelliJ IDEA выделяете переменную класса и нажимаете alt + insert, во всплывшем окошке можно выбрать что хотите создать.
Интересно, почему в гетере пишут просто return name а можно написать так public String getName() < return this.name; >потому что так просто короче? Или функционал меняется?
Что-то я не совсем понял, даже если я объявил переменную класса private но создал сеттер, то мой объект извне можно все равно изменять, разница лишь в проверке значений. А если я не хочу чтобы мой объект изменяли, то я просто не пишу сеттер? Но смогу ли я сам менять значения объекта?
в конструкторе ведь то же можно указать ограничения при создании объекта?,и еще вопрос в Idea можно изменить название переменной сделав пару кликов,и оно меняется везде в коде вот эта замена это аналог замены через сеттер без потери потерь или там более простая логика и он тупо меняет названия?
А если я при создании объекта передам не корректные значения? Cat barsik = new Cat(«noname», -1000, 1000); Надо ли делать валидацию в конструкторе?
Методы класса, сеттеры и геттеры, public, private, protected
На предыдущих занятиях мы с вами объявляли классы с набором переменных и указывали конструкторы. Пришло время узнать как добавлять функции в класс. По общепринятой терминологии, функции внутри класса называются методами и объявляются согласно следующему синтаксису:
[модификаторы] тип имя_метода([аргументы]) <// тело метода
>
Например, запишем класс для представления прямоугольника и в нем пропишем метод для вычисления площади прямоугольника:
Здесь square – это обычная функция, объявленная внутри класса Rect и благодаря этому имеет доступ ко всем полям экземпляра этого класса. То есть, если в функции main() создать два таких объекта:
Rect r1 = new Rect(0, 0, 10, 20); Rect r2 = new Rect(40, 20, 100, 200);
а, затем, вызвать метод square:
int s1 = r1.square(); int s2 = r2.square();
то первый вызов будет оперировать данными первого объекта r1, а второй – данными второго объекта r2:
В результате, при выводе в консоль:
System.out.println(s1); System.out.println(s2);
мы увидим разные значения.
Метод, как и любая Java-функция, может иметь самый разный тип данных и любое число входных аргументов. Например, добавим еще один метод, который будет задавать координату верхнего левого угла:
void setLeftTop(int x, int y) { this.x1 = x; this.y1 = y; }
Здесь тип метода void, т.к. он не возвращает никаких данных и прописаны два аргумента x, y. По аналогии можно добавлять в класс любое число самых разных методов.
Модификаторы доступа
Теперь, когда мы научились объявлять классы и создавать объекты, пришла пора поближе познакомиться с китом ООП по имени инкапсуляция.
- public – для определения публичных (общедоступных) членов класса;
- private – для определения частных (закрытых) членов класса;
- protected – для определения защищенных (частично закрытых) членов класса.
- модификатор по умолчанию – задает общедоступный режим ко всем членам класса текущего пакета.
Геттеры и сеттеры
Давайте вернемся к классу Rect и сделаем так, чтобы поля x1, y1, x2, y2 были скрыты от внешнего пользователя класса и были доступны только изнутри. Для этого нам нужно добавить модификатор private перед типом этих переменных:
class Rect { private int x1, y1; private int x2, y2; . }
то возникнет ошибка доступа: к полю private нельзя обращаться напрямую через ссылку на объект, то есть, извне. А если убрать этот модификатор в классе Rect, то ошибки не будет. В этом отличие между закрытым (private) полем и общедоступным, который определяется модификатором по умолчанию. Также открытое (публичное) поле можно определять с помощью модификатора public:
class Rect { public int x1, y1; public int x2, y2; . }
Здесь также не будет ошибок, при обращении к переменной x1 напрямую через ссылку на экземпляр класса. В чем же тогда разница между модификатором по умолчанию и public? На уровне одного пакета, то есть, когда файлы программы находятся в одном каталоге, разницы нет. Но, когда два класса расположены в разных пакетах (разных каталогах), то поля с модификатором public будут доступны всюду, а без него (по умолчанию) только в пределах одного пакета (каталога). Во всем остальном они схожи. Давайте вернем для полей x1, y1, x2, y2 модификатор private и будем полагать, что изменение координат возможно только через конструкторы и методы класса. Для этого определим еще один метод setCoords:
void setCoords(int x1, int y1, int x2, int y2) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; }
И, так как у этого метода не указан никакой модификатор, то используется модификатор по умолчанию и он может быть вызван напрямую через ссылку на класс:
Rect r1 = new Rect(); r1.setCoords(0, 0, 10, 20);
То есть, мы сначала создаем объект, а потом определяем координаты прямоугольника. Причем, напрямую обратиться к полям x1, y1, x2, y2 нельзя, мы это можем сделать только через метод setCoords(). Такие методы получили название сеттеры. От префикса set, который обычно записывают в названиях таких методов. Но спрашивается: зачем все так усложнять и не использовать обращение к полям x1, y1, x2, y2 напрямую? Дело в том, что у сеттеров есть одно важное преимущество: они позволяют не только записывать данные в заданные поля, но и выполнять необходимую проверку на корректность переданных данных. Например, мы требуем от пользователя, чтобы координаты прямоугольника были положительными и варьировались в пределах: 0
void setCoords(int x1, int y1, int x2, int y2) { if(isCorrect(x1) && isCorrect(y1) && isCorrect(x2) && isCorrect(y2)) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; } }
private boolean isCorrect(int arg) { return (0 arg && arg MAX_COORD); }
private static final int MAX_COORD = 1000;
Здесь используется ключевое слово static, о котором мы еще будем говорить. Все, теперь мы уверены, что координаты прямоугольника будут находиться в указанных пределах. И это стало возможно использованию закрытых полей и публичному сеттеру setCoords. Также этот пример показывает, что методы класса также можно делать закрытыми (private) и функция isCorrect доступна только внутри класса и не доступна извне. Что вполне логично для нашей текущей реализации. Нам здесь не хватает еще одного важного метода – для получения текущих координат прямоугольника. Чтобы сейчас не усложнять программу, я запишу четыре таких метода – по одному для каждого значения:
public int getX1() {return x1;} public int getX2() {return x2;} public int getY1() {return y1;} public int getY2() {return y2;}
Здесь используется модификатор public для указания общедоступности этих методов, а также префикс get, от которого пошло название – геттеры. То есть, геттеры – это методы, служащие для получения информации из закрытых полей экземпляра класса. Давайте воспользуемся этими методами и выведем значения координат в консоль:
System.out.println(r1.getX1() + ", " + r1.getY1() + ", " + r1.getX2() + ", " + r1.getY2());
Геттеры и сеттеры
Если переменная имеет уровень доступа private , к ней невозможно обратиться извне класса, в котором она объявлена. Но все равно необходим способ обращения к private переменным из другого класса, иначе такие изолированные переменные не будут иметь смысла. Это достигается с помощью объявления специальных public методов. Методы, которые возвращают значение переменных, называются геттеры. Методы, которые изменяют значение свойств, называются сеттеры.
Существуют правила объявления таких методов, рассмотрим их:
- Если свойство НЕ типа boolean , префикс геттера должно быть get. Например: getName() это корректное имя геттера для переменной name .
- Если свойство типа boolean , префикс имени геттера может быть get или is . Например, getPrinted() или isPrinted( ) оба являются корректными именами для переменных типа boolean .
- Имя сеттера должно начинаться с префикса set. Например, setName() корректное имя для переменной name .
- Для создания имени геттера или сеттера, первая буква свойства должна быть изменена на большую и прибавлена к соответствующему префиксу ( set , get или is ).
- Сеттер должен быть public , возвращать void тип и иметь параметр соответствующий типу переменной. Например:
public void setAge(int age) < this.age = age; >В языке Java при проектировании классов принято ограничивать уровень доступа к переменным с помощью модификаторов private или protected и обращаться к ним через геттеры и сеттеры.
Существует также такое понятие как JavaBeans классы — это классы содержащие свойства. В Java мы можем рассматривать свойства как private переменные класса. Так как они private , доступ к ним извне класса может быть осуществлен только с помощью методов класса.
Рассмотрим пример реализации концепции JavaBeans на классе Person , у которого есть три переменные. Они объявлены как private и доступ к ним возможен только через соответствующие геттеры и сеттеры
public class Person < private String fullName; private int age; private boolean retired; public Person() < >public Person(String fullName, int age, boolean retired) < this.fullName = fullName; this.age = age; this.retired = retired; >public String getFullName() < return fullName; >public void setFullName(String fullName) < this.fullName = fullName; >public int getAge() < return age; >public void setAge(int age) < this.age = age; >public boolean isRetired() < return retired; >public void setRetired(boolean retired) < this.retired = retired; >> Геттеры и сеттеры делают код более громоздким, поэтому часто задается вопрос о том, можно ли обойтись без них. Объясню их необходимость на следующих двух примерах.
Рассмотрим класс CircleWrong , у которого две переменные — радиус и диаметр, объявленные с уровнем доступа по умолчанию.
Любой класс в том же пакете может обратиться к ним напрямую и изменить их значение. Значения этих двух переменных должно соответствовать друг другу, но пользователь этого класса может задать любые значения, например:
public class CircleWrongDemo < public static void main(String[] args) < CircleWrong circle = new CircleWrong(); circle.diam = 25; circle.radius = 10; System.out.println("Диаметр: " + circle.diam); System.out.println("Радиус: " + circle.radius); >>Это может привести к неправильным дальнейшим вычислениям. Перепишем этот класс с использованием концепции JavaBeans, но немного изменим сеттеры. Метод setRadius() вместе с радиусом задает правильное значение для диаметра. Метод setDiam() написан соответствующим образом:
public class Circle < private int radius; private int diam; public int getRadius() < return radius; >public void setRadius(int radius) < this.radius = radius; this.diam = radius * 2; >public int getDiam() < return diam; >public void setDiam(int diam) < this.diam = diam; this.radius = diam / 2; >>Пользователь данного класса не может напрямую добраться к переменным, доступ осуществляется только через сеттеры, где мы контролируем правильную установку значений нашим переменным:
В следующем примере рассмотрим возможности геттера. Класс User содержит две переменные — логин и пароль. Пароль содержит чувствительную информацию, которую не рекомендуется показывать. Достигается это с помощью объявления переменной с модификатором private и доступом к ней только через геттер метод, в котором вместо полного пароля показываем только первую букву, а остальные заменяются звездочками:
public class User < private String login; private String password; public User(String login, String password) < this.login = login; this.password = password; >public String getLogin() < return login; >public void setLogin(String login) < this.login = login; >public String getPassword() < return password.charAt(0) + "*****"; >public void setPassword(String password) < this.password = password; >>