Зачем нужны геттеры и сеттеры java

Геттеры и сеттеры

Если переменная имеет уровень доступа private , к ней невозможно обратиться извне класса, в котором она объявлена. Но все равно необходим способ обращения к private переменным из другого класса, иначе такие изолированные переменные не будут иметь смысла. Это достигается с помощью объявления специальных public методов. Методы, которые возвращают значение переменных, называются геттеры. Методы, которые изменяют значение свойств, называются сеттеры.

Существуют правила объявления таких методов, рассмотрим их:

1. Если свойство НЕ типа boolean , префикс геттера должно быть get. Например: getName() это корректное имя геттера для переменной name .
2. Если свойство типа boolean , префикс имени геттера может быть get или is . Например, getPrinted() или isPrinted( ) оба являются корректными именами для переменных типа boolean .
3. Имя сеттера должно начинаться с префикса set. Например, setName() корректное имя для переменной name .
4. Для создания имени геттера или сеттера, первая буква свойства должна быть изменена на большую и прибавлена к соответствующему префиксу ( set , get или is ).
5. Сеттер должен быть public , возвращать void тип и иметь параметр соответствующий типу переменной. Например:

public void setAge(int age) < this.age = age; >​

public int getAge() < return 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; >> 

public class PersonDemo < public static void main(String[] args) < Person person = new Person(); person.setFullName("Петров Иван Иванович"); person.setAge(56); person.setRetired(false); System.out.println("Полное имя " + person.getFullName()); System.out.println("Возраст " + person.getAge()); System.out.println("Пенсионер? " + person.isRetired()); >> 

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

Рассмотрим класс CircleWrong , у которого две переменные — радиус и диаметр, объявленные с уровнем доступа по умолчанию.

public class 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; >>

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

public class CircleDemo < public static void main(String[] args) < Circle circle = new Circle(); circle.setDiam(25); circle.setRadius(10); System.out.println(circle.getDiam()); System.out.println(circle.getRadius()); >>

В следующем примере рассмотрим возможности геттера. Класс 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; >>

public class UserDemo < public static void main(String[] args) < User user = new User("mylogin", "mypassword"); System.out.println("Логин: " + user.getLogin()); System.out.println("Пароль: " + user.getPassword()); >>

Логин: mylogin Пароль: m*****

Геттеры и Сеттеры

Следующее понятие из мира ООП, которое следует рассмотреть — это геттеры и сеттеры (getter — от англ. «get» — получать, и setter — от англ. «set» — устанавливать). Это общепринятый способ вводить данные («set») или получать данные («get»). Например, у меня есть класс Cat — кошка. Я задаю (используя setter) имя, пол, цвет глаз и окрас кошки (или кота):

А потом, если нужно узнать, какое у кошки имя — получаю с помощь getter — в данном случае get CatName :

Зачем они нужны?

Действительно — если я сам все задаю, зачем все эти геттеры и сеттеры?

Тут, нам стоит вспомнить про такой принцип ООП как инкапсуляция (если Вы не знаете, что это такое, вернитесь назад и прочитайте статью «Что такое ООП»). С помощью геттеров и сеттеров Вы защищаете содержимое программы — когда ей пользуется кто-то другой.

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

Как это работает?

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

Что такое геттеры и сеттеры в программировании

Это будет текст об архитектуре объектно-ориентированных программ. Это для тех, кто планирует серьёзно заниматься разработкой.

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

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

Одно из понятий ООП — инкапсуляция, и в нём часто применяется такая идея:

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

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

Такие механизмы доступа к данным через посредника называются геттеры и сеттеры.

Что такое геттер и сеттер

Эти слова пришли из английского от слов get (получать) и set (устанавливать).

Задача геттера — получить данные о чём-то внутри объекта и передать их наружу. Например, водитель не может постоянно заглядывать в бензобак и смотреть, сколько бензина. Вместо этого водитель смотрит на индикатор топлива — тот показывает, сколько бензина осталось в баке. Индикатор топлива — это геттер: он берёт данные из объекта (автомобиль) и отдаёт их тому, кто их попросил (водитель).

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

Геттеры и сеттеры в программировании

Чаще всего в программировании эти инструменты используются как метод или интерфейс объекта: вы создаёте объект и указываете, что с ним можно делать. Поясним на примере.

Допустим, мы делаем голосовалку для интернет-магазина — люди выбирают, нравится им какой-то товар или нет. Одна из наших задач — сделать так, чтобы в коде программы ничто не могло напрямую влиять на значение счётчика. Всё, что мы разрешаем, — это увеличить счётчик на единицу или узнать текущее значение. Это избавит нас от ситуации, когда какая-то функция вдруг захочет накрутить счётчик сразу на 10 тысяч голосов. Чтобы так сделать, нам достаточно спрятать переменную счётчика в объект и там же объявить два метода — чтения (узнать результат) и записи (проголосовать, то есть увеличить строго на единицу). Для этого даже необязательно создавать отдельный класс. В JavaScript, например, это можно сделать за счёт стандартного замыкания, когда мы вкладываем одну функцию в другую.

// Объявляем новый объект-константу с помощью стрелочной функции const createCounter = () => < // Доступ к этой переменной возможен только внутри этой функции, снаружи поменять её не получится let count = 0; // Что возвращает функция return (< // Если вызван метод upvote(), увеличиваем переменную счётчика на 1 upvote: () =>count += 1, // Если вызван метод getVoteCount, возвращаем значение счётчика getVoteCount: () => count.toLocaleString() >); >; // Создаём новый объект на основе своего const counter = createCounter(); // Кликаем пару раз, увеличивая счётчик на единицу // Другим способом мы не сможем его изменить counter.upvote(); counter.upvote(); // Смотрим, что получилось в итоге (2) console.log(counter.getVoteCount());

А если в основной программе попробовать поменять значение переменной count, то ничего не изменится. А всё потому, что доступ к переменной count возможен только изнутри объекта и только двумя разрешёнными способами.

// ❌ Кажется, что это тоже сработает, но на самом деле значение счётчика не изменится
counter.count = 100

// На выходе всё так же будет число 2
console.log(counter.getCount());

Зачем они нужны

Основная задача геттеров и сеттеров — защитить данные внутри объекта, чтобы они менялись по своим правилам, а не кто как захочет. Проще говоря, это посредники, которые смотрят, можно что-то сделать с данными или нет. Если можно — делают, если нельзя — нет. В итоге и данные в безопасности, и у пользователя есть инструмент для работы с ними.

Получите ИТ-профессию

В «Яндекс Практикуме» можно стать разработчиком, тестировщиком, аналитиком и менеджером цифровых продуктов. Первая часть обучения всегда бесплатная, чтобы попробовать и найти то, что вам по душе. Дальше — программы трудоустройства.

Зачем нужны в java get и set когда можно использовать public? [дубликат]

Я не могу понять зачем в java нужны get и set когда есть public. Понятное дело что это модификаторы доступа, что если private то доступ к ним получить можно через get и set. Но зачем это все. Если есть public? почему нельзя просто использовать public int test; obj.test Вопрос в том что будет если я буду использовать public, вместо геттеров и сеттеров. Реальная причина почему так нельзя делать. Я это хочу узнать. А не то что создатели java просто решили что нужно ограничить переменные и придумали private, я хочу узнать что послужило создателям java добавить private. Просто если взять пример из жизни. У всех дома есть Розетки, но все знают что пальцы сувать туда не надо. Но ведь никто не закрывает эти розетки, они у всех открытые. @Виктор, Ваш ответ более менее несет ту информацию которую я ищу, но вот вопрос. Допустим переменная index имеет тип int. Но в этом классе есть метод get который возвращяет String. Вот тут и вопрос возникает, а разве это правильно, ведь куда понятнее и правильнее будет если бы используя даннйы класс программист получил бы int, и после вертел бы его как хотел) хоть в String хоть в массив. Почему вообще программисты используют get и set не для того чтобы добавить и получить значение переменной, а еще что — то свое добавляют в функции get и set. Ведь это же не правильно. get нужен чтобы получить переменную index типа int, а set чтобы положить данные в этот int, на вход который принимается int. Если так делать, то тогда правильнее будет не использовать эти лишние методы, а сразу использовать public index. Вот из — за \этого и возник данный вопрос

А вот самая главная причина почему мне нравиться использовать доступ к переменным на прямую

Вот напрямую public player.car.speed++; А это get и set getPlayer().getCar().setSpeed(getPlayer().getCar().getSpeed()+1); Такое ощущение что будто смотришь на Торт и пирожное =)