Использовать get и set или объявлять переменную печатает?

Часто переменные класса в java высказываются как уборные, чтобы иметь encapsulamiento.

Другие вопросов, чтобы объявлять переменную как уборную, он для того, чтобы он только смог быть доступным с того же класса, но в конце концов в большинстве случаев заканчивается делая методы set и get для modifcar переменная или чтобы получать ее вне класса.

Тогда то, о чем я осведомляюсь, если есть какой-то хороший мотив объявлять частную переменную и помещать его set и get вместо того, чтобы объявлять ее, он печатает и set и get предотвращаются.

8
задан 24.01.2017, 02:28
0 ответов

Позволять свободный доступ к признакам класса не отверженный рисунок, только отличается. Обычно предотвращает это, подобно чему класс манипулирует учеником закрытого учебного заведения, любая логика дела, которое могло бы ассоциироваться в поля. Pör помещать пример:

public class Foo {
    public List<String> listaNombres;
    public Foo() {
        listaNombres = new ArrayList<>(Arrays.asList("Friky", "Luiggi"));
    }
}

public class Otro {
    public List<String> listaNombresOtro;
    public void obtieneDeFoo(Foo foo) {
        listaNombresOtro = foo.listaNombres;
    }

    public static void main(String[] args) {
        Foo foo = new Foo();
        System.out.println(foo.listaNombres);
        Otro otro = new Otro();
        otro.obtieneDeFoo(foo);
        otro.listaNombresOtro.set(0, "Cambio");
        System.out.println(foo.listaNombres);
        System.out.println(otro.listaNombresOtro);
    }
}

Если бы потом мы захотели добавить утверждения для этого кода, осложняется ситуация. Конечно в предыдущем примере не возможно видеть, потому что только есть 3 вызова в Foo#listaNombres, но если бы он был рассеянным через десятки методов, ситуация осложняется. Кроме того, также осложни, если менялось определение признака (имя, тип, и т.д.), из-за всех изменений, которые были бы сделаны. Добавочная проблема, - что, получив список Foo#listaNombres мы не хотим переместить список прямо, в Вашем месте мы хотим копию ее. Мы могли бы делать копию в каждом расположении foo.listaNombres но это ведет в дублированный код (хороший, умноженный больше, чем дубликат).


Использование методов get и set (предпочтения публика) будь согласно спецификации JavaBean:

7 Properties

Properties пахал discrete, named attributes of в Java Bean that хан affect its appearance or its behavior. For example, в GUI button might have в property named “Label” that represents the text displayed in the button.

Properties шоу up in в number of ways:

Properties май be exposed in scripting environments эксперт though they were fields of objects. So in в Javascript environment I might do “b. Label = foo” to set the оцените of в property. Properties хан be accessed programmatically by other components calling their getter and сеттер methods (see Section 7.1 below). (...)

7.1 Accessor methods

Properties пахал always accessed путь method calls on their owning object. For readable properties there will be в getter method to read the property оцените. For writable properties there will be method to allow the property оцените сеттера to be updated.

Переведенный:

7 Свойства

Свойства - благоразумные признаки и с именем Java Bean, который может затрагивать Ваш внешний вид или поведение. Например, у кнопки GUI могло бы быть свойство названное "Label", которое представляло бы текст, который появляется в кнопке.

Свойства ты показываешь нескольких способов:

Свойства могут выставляться в атмосферах рукописного шрифта как будто это были поля объектов. Так, в атмосфере язык сценариев JavaScript мог бы делать "b. Label = foo", чтобы распределять стоимость свойства. Свойства могут быть соглашенными programáticamente другими компонентами, которые звонят в Ваши методы get и set (смотреть секцию 7.1 внизу). (...)

7.1 Методы доступа

Всегда соглашаются на свойства через призывы к методам в объекте, который обладает ими. Для свойств, которые могут читаться, будет существовать метод get, чтобы читать стоимость свойства. Для свойств, которые могут писаться, будет существовать метод set, что позволяет обновлять стоимость свойства.

Это значит, что методы get и set они позволяют доступ к свойствам (признаки) класса. Много frameworks извлекают пользу из этого определения. Из-за того, что упоминает о каких-то:

  • Спринг, CDI, Guice (IoC, вставка зависимостей)
  • Hibernate, MyBatis (доступ к данным)
  • XStream, Джексон, Gson (превращение между объектами и JSON, XML и другими форматами)
  • Спринг МВК, JSF, Экспрессион Лангвахе, JSTL, и т.д. (Веб MVC)
  • JavaFX (GUI рабочего стола)
  • Метр, Апачи CXF, Апачи Axis (осуществление / потребление Веб услуг)
  • И т.д. Или скорее: любой framework, который работал бы объекты используя отражение (reflection), что обычно основывается в использовании классов с назначенными по умолчанию строителями, и я имею доступ в признаки посредством методов get и set.

Размещая пример Спринг с конфигурацией XML:

<bean id="fooBean" class="paquete.de.mis.clases.Foo">
    <property name="listaNombres">
        <list>
            <value>Friky</value>
            <value>Luiggi</value>
        </list>
    </property>
</bean>

Класс Java, ассоциируемый с этим bean:

package paquete.de.mis.clases;

public class Foo {
    private List<String> listaNombres;
    public List<String> getListaNombres() {
        return this.listaNombres;
    }
    //permite a Spring asignar el valor de la lista mediante reflexión
    public void setListaNombres(List<String> listaNombres) {
        this.listaNombres = listaNombres;
    }
}

Пример в JSF для ассоциации cambpos используя Экспрессион Лангвахе:

<!-- permite a JSF llamar al getter mediante reflexión -->
<h:dataTable value="#{foo.listaNombres}" var="nombre">
    <h:column>
        #{nombre}
    </h:column>
</h:dataTable>

Класс присоединенный Java:

package paquete.de.mis.managedbeans;

@ManagedBean
@ViewScoped
public class Foo {
    private List<String> listaNombres;
    @PostConstruct
    public void init() {
        listaNombres = new List<>();
        listaNombres.add("Friky");
        listaNombres.add("Luiggi");
    }
    public List<String> getListaNombres() {
        return this.listaNombres;
    }
    public void setListaNombres(List<String> listaNombres) {
        this.listaNombres = listaNombres;
    }
}

Кроме того, "хорошее" (¿?) использования этих методов дело в том, что ты можешь добавлять логику дела в них, чтобы предотвращать непосредственный контакт с объектами, с которыми ты работаешь. Предыдущего случая, который мы показываем, что хочется получать копию списка вместо того, чтобы получать список прямо, мы могли бы добавлять вышеупомянутую логику в методе get:

public class Foo {
    private List<String> listaNombres;
    public List<String> getListaNombres() {
        //en lugar de devolver la lista directamente
        //devolvemos una nueva lista con los elementos
        //de mi lista actual
        return new ArrayList<>(this.listaNombres);
    }
}

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


Приспособленный Привате Лист with Getter/Setter vs Публик Лист

8
ответ дан 03.12.2019, 17:31
  • 1
    Quizá s serí в ú til упоминания о том, что преимущества есть у парадигмы разработки с JavaBean s? –  24.01.2017, 03:13
  • 2
    Конечно стоимость IOC-framework понятна, когда один это использует, только он думал, что этот вопрос podrí когда люди интересуют уже много прежде чем они начинают работать на этом уровне разработки. –  24.01.2017, 03:25
  • 3
    Нет, для меня ответ не должен совсем не быть больше, чем ú til и правильный, чтобы ориентироваться на уровне знания, существует возможность иметь разнообразие ответов на различных уровнях. Я только думал, что концепция JavaBeans - ú til для diseñ или модулировать уже перед тем, как знать и понимать эти frameworks. –  24.01.2017, 03:40
  • 4
    XD " Не это es" это крепость declaració n. И я не соглашаюсь, думаю, что он зависит от конкретного проекта, иногда он лучше, иногда не, и работая с IDE bá sicamente он не вызывает má s я работаю использовать их. –  24.01.2017, 03:50
  • 5
    @Michelle, когда у класса нет строителя, составитель добавляет его назначенный по умолчанию строитель, который светит así: public <NombreDeClase>() { }. А именно, он - строитель pú blico, без аргументов и без контента. –  22.09.2017, 18:12

Ты только что воплотил один из самых общепринятых вопросов разработчиков: "Я использую свойства или соглашаюсь прямо на признаки класса?" В других ответах у него есть хорошие примеры, я могу размещать простой один:

public class Point {
    int x = 0;
}
Point point = new Point();
point.x = 1;

Versus

public class Point {
    int x = 0;

    public int getX() {
        return this.x;
    }
    public void setX(int x) {
        this.x = x;
    }
}
Point point = new Point();
point.setX(1);

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

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

WindowManager.getInstance().getTopWindow().getInitialPoint().getX()

Когда он может быть читабельнее как:

WindowManager.instance.topWindow.initialPoint.x;

Но как я сказал раньше, будет зависеть от деловой логики твоего приложения, который использовать.

5
ответ дан 03.12.2019, 17:31
  • 1
    Отнесись к предотвращать формулировки как " Наверху он имеет...". Зависимый от распоряжения от ответов, или если в сообщество ему нравится твой ответ, закончись внизу, которое ты имеешь в виду ;) Я меняю это тебе в " в других respuestas". –  24.01.2017, 09:56
  • 2
    Я не вижу, что увеличилась читабельность, как использовал поля коснулся mé все как чтобы быть razó n, чтобы выбирать opció n или другая. Если твой aplicació n (или эта часть có я говорю) смоги " escalar" лучше использовать mé все с начала, что refactorizar весь có я говорю despué в. –  24.01.2017, 12:32
  • 3
    Не всегда необходимо добавлять mé все от доступа к полям в классе. в примере я размещаю упоминаю о случае очень bá sico координата (x, y), что могут брать любую стоимость numé богатое целое число. Просвет в случаях, где ты нуждался в том, чтобы санкционировать строгим способом será необходимый Ваши соответствующие get/set. –  25.01.2017, 04:38

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

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

Давайте считать этот класс:

public class Persona{

    public String nombre="";
    public String apellido="";
}

в сравнении в версию с get и set

public class Persona {

    private String nombre="";
    private String apellido="";
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public String getApellido() {
        return apellido;
    }
    public void setApellido(String apellido) {
        this.apellido = apellido;
    }

}

В каком-то моменте мы понимаем, что мы должны гарантировать, что никогда он не назвал, или фамилия они остаются null.

С первым классом это главным образом невозможно, persona.nombre = null; дело не совсем не в том, что мы могли бы запрещать. Однако в другой версии есть суперлегкий способ:

    public void setNombre(String nombre) {
        if (nombre!=null) throw new IllegalArgumentException("null no permitido");
        this.nombre = nombre;
    }

    public void setApellido(String apellido) {
        if (apellido!=null) throw new IllegalArgumentException("null no permitido");
        this.apellido = apellido;
    }

и у нас есть исключение, если кто-то старается размещать null.

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

public class Persona {

    private String nombre="";
    private String apellido="";
    private long timestamp=new Date().getTime();

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        if (!this.nombre.equals(nombre)) timestamp = new Date().getTime();
        this.nombre = nombre;
    }

    public String getApellido() {
        return apellido;
    }

    public void setApellido(String apellido) {
        if (!this.nombre.equals(nombre)) timestamp = new Date().getTime();
        this.apellido = apellido;
    }

    public Date getActualizado(){
        return new Date(timestamp);
    }

Так было возможно осуществления этот функциональности только в модели в классе.

В противоположность, парадигму, в которой getters и сеттеры - полностью в избытке звук Ты (я оценил objects, объекты стоимости) неизменные. Пример:

public class PersonaVO{

    public final String nombre;
    public final String apellido;

    public PersonaVO(String nombre, String apellido){
        this.nombre=nombre;
        this.apellido=apellido;
    }
}

В этом случае getters или сеттеры были бы полностью бессмысленными.

Поскольку ты видишь, есть ли мотивы, но все зависит от рисунка и контекста.

2
ответ дан 03.12.2019, 17:31
  • 1
    Относительно этой implementació n следуй упомянуть о том, что бросать исключения в сеттерах не prá ctica comú n и есть много discusió n по этому поводу. –  24.01.2017, 05:18
  • 2
    Ну конечно. prá ctica смоги быть очень полезным в каких-то контекстах, ужасным в других. Есть лучшие примеры, но пока usé этот. В algú n момент с má s время я могу издавать это, чтобы давать лучший пример. –  24.01.2017, 06:17
  • 3
    Я не думаю, что он испытывает недостаток в чувстве, иметь getters или сеттеры, если переменные неизменные: getter está ясно, что он ú til, чтобы получать переменную, если она не объявлена pú blica; сеттер, хотя она не сможет быть распределенной снова sí podrí когда изменять, если он не относится друг к другу примитивных (могут меняться свойства объекта, не распределяя целого объекта, так как я контролирую ló gica mé каждый set) –  24.01.2017, 12:27
  • 4
    @Awes0meM4n ú nica способ менять что-то на VO со всеми полями конец - reflexió n. Какое различие он делает, если я имею getters или сеттеры в этом случае? –  24.01.2017, 15:23
  • 5
    То же всегдашнее различие: ты контролируешь то, что делает mé совсем set. Это действительно фундаментальная часть использования mé все vs доступные поля. Поэтому не теряет чувство Ваше включенное использование, когда используются конечные переменные. –  24.01.2017, 15:37

Get - выводы и Set - поступающие данные класса. Это считается хорошей практикой осуществлять их из-за тем безопасности главным образом, так как мы делаем максимальным encapsulación.

Мы изолируем реальное представление данных и только мы имели бы доступ к поведению.

1
ответ дан 03.12.2019, 17:31
  • 1
    Он не является таким простым. Если ты хочешь доказать, как возможно изолировать representació n, ты должен давать примеры как. Если ты оставляешь это назначенным по умолчанию, они не дают тебе никакого преимущества, ни безопасности, ни representació n, только они готовят практики для того, чтобы осуществлять это без необходимости менять интерфейс. –  24.01.2017, 09:51