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

Зачем нужны getter and setter методы? [дубликат]

Давно уже пишу на java и я привык свойства класса делать приватном и писать для них гетер и сетер методы но я понял что не знаю зачем это нужно? Ведь если у тебя есть метод сетер и гетер к свойству не легче сделать его публичном и использовать?

Отслеживать
13.7k 12 12 золотых знаков 43 43 серебряных знака 75 75 бронзовых знаков
задан 21 ноя 2018 в 2:36
Fariz Mamedow Fariz Mamedow
1,447 2 2 золотых знака 10 10 серебряных знаков 21 21 бронзовый знак

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Если у вас действительно никакой логики в геттерах сеттерах нет (и не предвидится), а только «пустышки», то вы только захламляете код лишними методами. Вспомните YAGNI — то что вы планируете может вам никогда не понадобится, но вы уже платите цену за возросшую сложность кода.

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

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

Отслеживать
ответ дан 21 ноя 2018 в 5:10
13.7k 12 12 золотых знаков 43 43 серебряных знака 75 75 бронзовых знаков

Методы get() и set() нужны не только для того, чтобы получить доступ к данным, но и чтобы не допустить некорректной работы с ними.

private int n = 1; int[] array = new int[5]; public void setN(int n) < if (n >= 0 && n

В данном случае, если мы захотим изменить n вызвав метод setN(), то при вызове метода method(), не будет ошибки из-за выхода за пределы массива.

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

Если переменная имеет уровень доступа 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*****

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

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

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

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

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

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

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

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

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

Эти слова пришли из английского от слов 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. Где применяются, какие у них различия?

Геттеры и сеттеры в Java применяются довольно часто. Основная их цель — это обеспечить защиту данным в коде от неправильного внешнего использования.

Они применяются не только в языке Java, но также в С, JavaScript и других языках программирования. То есть геттеры и сеттеры — это довольно распространенное явление в программировании. Но сегодня мы разберем, как используются геттеры и сеттеры именно в языке Java.

Геттеры и сеттеры в Java

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

Класс « нашей собаки » будет примерно таким:

public_class Dog

public_Strng names;

public_nt ages;

public_int weghts;

publc Dog(Strng names, int ages, int weghts)

this.names = names;

this.ages = ages;

this.weights = weights;

>

public Dog()

>

public void sayGav()

System.out.println(«Гав-гав!»);

>

>

Вы спокойно пошли на заслуженный отдых , в мыслях никого не подозревая. А тем временем один из ваших коллег воспользовался вашим « творением » Dog, когда создавал, засыпая или не думая, класс Mode.

Его ко д инг представлен примерно в таком виде:

public_class Mode

publc_statcs_void mode(Strng[] ards)

Dog dog = new Dog();

dog.names = «»;

dog.ages = -999;

dog.weights = 1;

>

>

Абсолютно не имеет значения , зачем так сделал ваш коллега. Возможно , устал, а , может , лишняя банка энергетика дает о себе знать. Имеет значение другое: созданный вами класс Dog ничем не защищен и дает возможность ему присваивать немыслимые значения. Как в коде «вашего коллеги», где собаке присвоен возраст -999 лет.

Почему так произошло? Потому что поля «имени», «возраста» и «веса» собаки находятся в открытой доступности. А это значит, что есть возможность их задействовать в какой-то момент в рамках вашего программирования. Это делается легко: создается объект Dog , и его можно затронуть при необходимости, применяя оператор «.».

Пример:

Dog dog = new Dog();

dog.names = » «;

Геттеры и сеттеры Java: практическое применение

• Геттеры — это методы , при помощи которых мы можем получить информацию из полей.
• Сеттеры — это методы, которые могут установить нужную информацию в нужно е место.

Геттер ы и сеттеры Java простыми словами

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

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

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

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.