Подтвердить что ты не робот

Установить и получить методы в java?

Как я могу использовать методы set и get, и почему я должен их использовать? Действительно ли они полезны? А также можете ли вы привести примеры методов set и get?

4b9b3361

ОТВЕТЫ

Ответ 1

Методы Set и Get - это образец инкапсуляции данных. Вместо прямого доступа к переменным-членам класса вы определяете методы get для доступа к этим переменным и методы set для их изменения. Инкапсулируя их таким образом, вы контролируете открытый интерфейс, если вам нужно изменить внутреннюю работу этого класса в будущем.

Например, для переменной-члена:

Integer x;

У вас могут быть методы:

Integer getX(){ return x; }
void setX(Integer x){ this.x = x; }

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

Ответ 2

Я хочу добавить к другим ответам, что установщики могут использоваться, чтобы предотвратить помещение объекта в недопустимое состояние.

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

private String taxId;

public void setTaxId(String taxId) {
    this.taxId = taxId;
}

Однако нам лучше помешать использовать объект с недопустимым taxId, поэтому мы можем ввести чек:

private String taxId;

public void setTaxId(String taxId) throws IllegalArgumentException {
    if (isTaxIdValid(taxId)) {
        throw new IllegalArgumentException("Tax Id '" + taxId + "' is invalid");
    }
    this.taxId = taxId;
}

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

private final TaxId taxId = new TaxId()

public void setTaxId(String taxIdString) throws IllegalArgumentException {
    taxId.set(taxIdString); //will throw exception if not valid
}

Аналогично для getter, что, если у нас еще нет значения? Возможно, мы хотим иметь другой путь, мы могли бы сказать:

public String getTaxId() throws IllegalStateException {
    return taxId.get(); //will throw exception if not set
}

Ответ 3

Я думаю, вам нужно что-то вроде этого:

public class Person {

  private int age;

  //public method to get the age variable
  public int getAge(){
       return this.age
  }

  //public method to set the age variable
  public void setAge(int age){
       this.age = age;
  }
}

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

  public void setAge(int age){

       this.age = age;

       double averageCigarettesPerYear = this.smokedCigarettes * 1.0 / age;

       if(averageCigarettesPerYear >= 7300.0) {
           this.eventBus.fire(new PersonSmokesTooMuchEvent(this));
       }
  }

Конечно, это может быть опасно, если кто-то забывает называть setAge(int), где он должен, и устанавливает age напрямую, используя this.age.

Ответ 4

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

Ответ 5

Сеттеры и получатели используются для замены прямого доступа к переменным-членам из внешних классов. если вы используете setter и getter для доступа к свойству, вы можете включить инициализацию, проверку ошибок, сложные преобразования и т.д. Некоторые примеры:

private String x;

public void setX(String newX) {
    if (newX == null) {
        x = "";
    } else {
        x = newX;
    }
}

public String getX() {
    if (x == null) {
        return "";
    } else {
       return x;
    }
}

Ответ 6

Некоторые преимущества использования геттеров и сеттеров (известный как encapsulation или data-hiding):

(первоначально ответил здесь)

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

Пример:

class EncapsulationExample {
    private int readOnly = -1;  // this value can only be read, not altered
    private int writeOnly = 0;    // this value can only be changed, not viewed
    public int getReadOnly() {
        return readOnly;
    }
    public int setWriteOnly(int w) {
        writeOnly = w;
    }
}

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

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

Пример (получение значения):

class EncapsulationExample {
    private int value;
    public int getValue() {     
        return value; // return the value
    }
}

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

class EncapsulationExample {
    private int value;
    public int getValue() {
        return value*2; // return twice the value
    }
}

3. Делает очиститель кода более понятным и понятным.

Вот пример:

Нет инкапсуляции:

class Box {
    int widthS; // width of the side
    int widthT; // width of the top
    // other stuff
}

// ...
Box b = new Box();
int w1 = b.widthS;  // Hm... what is widthS again? 
int w2 = b.widthT;  // Don't mistake the names. I should make sure I use the proper variable here!

С инкапсулированием:

class Box {
    private int widthS; // width of the side
    private int widthT; // width of the top
    public int getSideWidth() {
        return widthS;
    }
    public int getTopWIdth() {
        return widthT;
    }
    // other stuff
}

// ...
Box b = new Box();
int w1 = b.getSideWidth(); // Ok, this one gives me the width of the side
int w2 = b.getTopWidth(); // and this one gives me the width of the top. No confusion, whew!

Посмотрите, сколько у вас больше контроля, какая информация вы получаете и насколько это яснее, во втором примере. Имейте в виду, что этот пример тривиален и в реальных классах вы будете иметь дело с большим количеством ресурсов, к которым обращаются многие различные компоненты. Таким образом, инкапсуляция ресурсов делает более ясным, к каким из них мы обращаемся и каким образом (получение или настройка).

Вот good SO thread по этой теме.

Здесь good read для инкапсуляции данных.

Ответ 7

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

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

private String foo;

public void setFoo(String bar) {
    this.foo = bar;
}

Что произойдет, если где-нибудь по дороге вы решите, что вам больше не нужно foo, или вы хотите сделать его целым? Каждый объект, который использует метод setFoo, теперь необходимо изменить вместе с foo.

Ответ 8

только потому, что правило ООП: Скрытие и инкапсуляция данных. Очень плохо, когда объявлять объект публичным и менять его на лету в большинстве ситуаций. Также есть много других причин, но корень - это инкапсуляция в ООП. и "купи книгу или прочитай об объектно-ориентированном программировании", вы поймете все это после того, как прочитаете какую-либо книгу о ООП.

Ответ 9

Преимущества методов get() set() заключаются в следующем.

  • Вы можете легко сериализовать объект.
  • Вы можете создать постоянный объект из содержащего класса.
  • Вы можете легко преобразовать свойства в JSON.
  • В слое DAO (такие как Hibernate) вы можете напрямую сохранить объект в DB.
  • Простое понимание объектно-ориентированной концепции.
  • Требуется во всех шаблонах проектирования, за исключением, возможно, одного шаблона тона.
  • Безопасность для свойств, защищающих прямой доступ.
  • Полиморфизм, инкапсуляция может быть легко понята и реализована этим типом класса.

Пример:

private String personName;
private int personId;

    public void setPersonName(String name) throws Exception{
    if(!(name.equals("")||name=="")){
      this.personName = name;
    }
  }
  public String getPersonName(){
    return this.personName;
  }
  public void setPersonId(int id) throws Exception{
    this.personId = id;
  }
  public int getPersonId(){
    return this.personId;
  }

Ответ 10

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

С объектами данных отлично опустить геттеры и вместо этого иметь общедоступные поля. Обычно у них нет сеттеров, поскольку они чаще всего неизменяемы - их поля устанавливаются через конструкторы и никогда больше. Посмотрите на Боба Мартина "Чистый код" или "Прайс и фриман" Растущее программное обеспечение OO... для деталей.

Ответ 11

public class Person{

private int age;

public int getAge(){
     return age;
}

public void setAge(int age){
     this.age = age;
}
}

Я думаю, это ты хочешь.. и это также называется pojo

Ответ 12

Этот ответ сливается с другим вопросом.

Ваш метод getAge() называется методом экземпляра в Java.

Чтобы вызвать метод экземпляра, вы должны иметь объект класса, в котором этот метод определен.

Например, если этот метод в классе с именем Person, то

  • Создайте объект Person с помощью нового оператора

     Person p = new Person();

  • Чтобы получить возраст объекта Person, используйте этот метод

    p.getAge()

Ответ 13

это код для метода set

public void setAge(int age){
  this.age = age;
}

Ответ 14

Похоже, вы пытаетесь сделать что-то похожее на С#, если хотите метод createAge create setAge(int age){ this.age = age;}

Ответ 15

Я не вижу простого ответа на второй вопрос (почему) здесь. Так вот.

Скажем, у вас есть общедоступное поле, которое очень часто используется в вашем коде. Всякий раз, когда вы решаете, что вам нужно сделать что-то лишнее, прежде чем давать или устанавливать это поле, у вас есть проблема. Вы должны создать специальный геттер и сеттер для этого поля и изменить свой полный код с помощью поля непосредственно на использование getter и seters.

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

Использование getters и seters - это будущее планирование кода, что делает его более гибким. Конечно, вы можете использовать общедоступные поля, особенно для простых классов, которые просто содержат некоторые данные. Но всегда полезно просто сделать поле конфиденциальным и закодировать метод get и set для него.