Java: Setter Getter и конструктор

Ответ 1

Конструктор по умолчанию

всегда присутствует

Ну на самом деле его не всегда есть. Конструктор по умолчанию - это тот, который предоставляется компилятором (конечно, это конструктор no-arg) Только в том случае, если в классе

почему мы используем конструктор с параметрами для инициализации значений вместо set get

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

Рассмотрим этот класс Book

public class Book {

    private String title;
    private String author;

    public Book(String title, String author){
        this.title = title;
        this.author = author;
    }
     //getters and setters here 
}

Рассмотрим условие, при котором книга может быть создана, только если она имеет title и author.

• Вы не можете сделать new Book(), потому что конструктор no-arg отсутствует, а компилятор не предоставит его, потому что один конструктор уже определен.
• Также вы не можете сделать new Book(), потому что наше условие не соответствует, так как каждая книга требует названия и автора.

Это условие, при котором полезен параметризованный конструктор.

Ответ 2

Иногда, создавая новый объект класса, некоторые значения должны быть предоставлены. Например, при подключении к базе данных и создании объекта класса Connection вы должны предоставить строку подключения, чтобы она знала, к чему вы подключаетесь. Создание нового соединения без спецификации целевой базы данных будет довольно бесполезным, не так ли?

Кроме того, взгляните на это

Foo foo=new Foo(1,2,3,4,5,6,7);

и этот

Foo foo=new Foo();
foo.setP1(1);
foo.setP2(2);
foo.setP3(3);
foo.setP4(4);
foo.setP5(5);
foo.setP6(6);
foo.setP7(7);

Первый выглядит лучше, верно?

Ответ 3

Мой вопрос в том, что если конструктор является точкой инициализации и конструктор по умолчанию всегда существует, поэтому мы используем конструктор с параметры для инициализации значений вместо set get.

Если вы думаете о переходе объекта в разные состояния, тогда имеет смысл иметь параметризованный конструктор наряду с сеттерами и геттерами. Позвольте мне попробовать сценарий реальной жизни: подумайте о классе Employee, присоедините нового сотрудника, вы не знаете много деталей, но мало, и вы создаете объект Employee с defualt и базовым значением его атрибутов. Вам необходимо зарегистрировать сотрудника в системе, и, следовательно, вы использовали параметризованный конструктор. Когда вы получите более подробную информацию о сотруднике, вы используете геттеры и сеттеры для обновления атрибутов.

Ответ 4

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

• чтобы инициализировать те значения, которые не следует изменять. (например, параметр имени пользователя для объекта person)

• чтобы инициализировать эти значения, не устанавливая, какой объект будет находиться в недопустимом состоянии.

Скажем, вы отправляете параметры входа в метод. Вы можете использовать их способами

Login obj = new Login();
obj.setUsername("user");
obj.setPassword("pw")// what if someone commented this out, or you forget to call it


and otherway,
Login obj = new Login("user", "pw");

в то время как вы можете отправить объект Login сразу после установки имени пользователя в 1-м случае, это будет недействительным при достижении конца. но второй метод менее подвержен ошибкам, bcz необходимо передать все необходимые параметры.

Ответ 5

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

Ответ 6

Иногда вам не нужно устанавливать все поля для определенных значений во время создания. Для примера, когда вы создаете массив. Кроме того, как уже говорилось, это безопаснее, когда вы используете геттеры - вы не можете получить nullpointer.

Не забудьте написать конструктор по умолчанию, когда вы определили конструктор с параметрами. Или не используйте его.

Ответ 7

Во-первых, оба метода: Constructor и Setter - безопасные способы изменения атрибутов объекта. Ожидается, что от автора класса обнаружит или не будет безопасным способом изменения экземпляра.

• Конструктор по умолчанию всегда предоставляется, если вы его не написали:

  // Example of a Class with a Default Constructor 
  public class GetSet {
  
      private String value;
  
      public String getValue() {
          return value;
      }
      public void setValue(String value) {
          this.value = value;
      }
  
  
      public static void main(String[] args) {
          // Theres a implicit Default Constructor here
          // Its ok to do that
          // GetSet obj = new GetSet();
          GetSet obj = new GetSet();
      }
  
  }
  
  
  // Example of a Class without a Default Constructor 
  public class GetSet2 {
  
      public GetSet2(String value) {
          this.value = value;
      }
  
      private String value;
  
      public String getValue() {
          return value;
      }
      public void setValue(String value) {
          this.value = value;
      }
  
      public static void main(String[] args) {
          // GetSet2 obj = new GetSet2(); // compile time error
          // Default constructor is not provided, since u wrote one
      }
  
  }
  

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

    // Example of modifing an obj via Setter and Constructor
    public class GetSet3 {

        public GetSet3(String value1, String value2, String value3, String value4) {
            this.value1 = value1;
            this.value2 = value2;
            this.value3 = value3;
            this.value4 = value4;
        }

        private String value1;
        private String value2;
        private String value3;
        private String value4;


        // ... Getters and Setters



        public static void main(String[] args) {

            // Its easier to this
            GetSet3 obj;

            obj= new GetSet3("j", "a", "v", "a");

            // instead that
            // its also easy to forget or do something wrong
            // when u have a lot of attributes to set
            obj.setValue1("j");
            obj.setValue2("a");
            obj.setValue3("v");
            obj.setValue4("a");

        }
    }

Ответ 8

Легче и безопаснее инициализировать переменные объекта через ваш конструктор, чтобы избежать нулевых указателей.

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

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

Ответ 9

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

Зачем использовать геттеры и сеттеры?

Ответ 10

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

Ответ 11

Чтобы ответить на этот вопрос, я говорю, написав getters/setters, мы создаем условие для добавления любого метода проверки в будущем, в настоящее время нет проверки, но если что-то пойдет не так в будущем, мы просто добавим логику проверки в установщик.

мы также можем написать логику/проверку в конструкторах, но это не очень хорошая практика. Конструктор должен использоваться только для инициализации состояния/полей вашего объекта. Вы должны делегировать ответственность за другие вещи другим методам. Обратите внимание, что конструктор вызывается только один раз, т.е. всякий раз, когда вы создаете новый объект с достаточно большим вводом, вы можете вызвать исключение в своем конструкторе. Это одна из нескольких причин, почему вы не должны использовать конструктор, содержащий "бизнес-логику".