Set, Get and Constructors в Java

Question

Несмотря на учебные пособия по Java, поиск в Википедии, троллирование с использованием стека и часы чтения образцов кода, конструкторы все еще путают меня дерьмо. У меня есть три связанных вопроса, на которые я пытался ответить, чтобы помочь мне понять конструкторы немного лучше.

Во-первых, у меня создалось впечатление, что конструкторы нужно называть такими же, как и их классы. Рассмотрите:

public class Money { 
    public Money(long l) { 
     this.value = l; 
    } 

    public Money(String s) { 
     this.value = toLong(s); 
    } 

    public long getLong() { 
     return this.value; 
    } 

    public String getString() { 
     return toString(this.value); 
    } 
} 

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

Во-вторых, у меня, похоже, есть блок против понимания множества и получения методов. Рассмотрим:

public class GetSetSample { 
    public int getFoo() { 
return int Foo; 
} 
public void setFoo(int fooValue) { 
int Foo = fooValue; 
} 
} 

Почему я не могу просто сделать это:

public class getFoo(int fooValue){ 
    foo=fooValue; 
} 

и использовать foo = getFoo(12) из другого класса/метода?

Третий вопрос - немного более эзотерический, но поможет мне понять большую картину ..., что является моим стилем обучения, и способствует моей способности отслеживать поток программы при отладке. Методы get и set предлагают отношение «к» и «от» ко мне. например, передавая значение «в» конструктору, получая результат «из» метода get. Мне кажется, что «to» и «from» будут меняться в зависимости от вашей перспективы. Я думаю, что любой setMethod задает параметры для объекта, даже если переменная поступает из другого класса или метода, а GetMethod - get, обрабатывая полученный объект (скажем, this.foo) с соответствующим параметром set. Независимо от того, где используется get или set, в основном методе или отдельном классе с одним конструктором, «набор» всегда связан с отправкой параметра, и get всегда связан с получением объекта с этим параметром. Это хорошее понимание? или мне не хватает жизненно важной части?

Answer 1

Вопрос 1:

Я вижу это как четыре конструкторов .. .верный?

Нет, этот класс имеет два конструктора и два метода. (getLong и getString являются методы.)

Вопрос 2:

Почему я не могу просто сделать это:

public class getFoo(int fooValue){ 
    foo=fooValue; 
} 

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

Вопрос 3:

ГЭТ и установить методы предложить «в» и «из» отношения ко мне.

Ну, это действительно не Отношения IMO. Отношения предлагают нечто более длительное, чем любой из этих методов. Установщик обычно каким-то образом изменяет состояние объекта, а получатель обычно просто возвращает какой-то аспект состояния объекта. Не совсем ясно, что означало остальное ваше объяснение, потому что вы играете довольно быстро и свободно с терминологией. Например: «get всегда связано с получением объекта с этим параметром», на самом деле для меня это не имеет смысла. Объекты не имеют параметров, методы/конструкторы - и геттеры могут извлекать примитивные значения или ссылки ...

Я подозреваю, что вам будет полезно прочитать "Classes" part of the Java tutorial, в котором рассказывается о конструкторах и методах.

Answer 2

Вы показали 2 конструктора, которые должны иметь то же имя, что и класс.

Вы также указали два метода «getter», которые возвращают значение переменной класса в запрошенной пользователем форме. Вы также можете создавать методы «сеттера», которые используются для передачи значений в переменные класса.

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

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

Таким образом, вы могли бы добавить сеттер и обновить конструктор, чтобы использовать его:

public Money(long l) { 
    setValue(l); 
} 

public Money(String s) { 
    setValue(toLong(s)); 
} 

// Example setter that validates `l` by prohibiting negative values 
public Money setValue(long l) { 
    if (l < 0) { 
    // Warn about negative values 
    } 
    this.value = l; 
    return this; // Return the current object to allow chaining; see below. 
} 

Обратите внимание, что сеттер обычно не нужно возвращать значение (то есть, это может быть тип void), но часто бывает полезно вернуть сам объект.Это позволяет писать код, как это:

Money earnings = new Money().setValue(4).setOtherField("foo"); 

Это создает объект типа Money, устанавливает различные атрибуты, и сохраняет его в переменной earnings. Ясно, что это не очень полезно для простого класса, как это, но это может быть очень полезно для более сложных классов:

Paycheck check = new Paycheck("MyCompany") 
    .setEmployee("YourName") 
    .setSalary(50,000) 
    .setPaySchedule(Schedule.BIWEEKLY) 
    .setAccountNumber("1234567") 
    .setDefaultTaxRate(); 

Answer 3

Что касается первого ответа, то есть только 2 конструктора. Разница заключается в том, как они будут называться (вызов с использованием строки будет использовать конструкцию с строкой, которая имеет параметр и вызывается с использованием long, будет использовать другую). Поэтому, чтобы ответить, да, конструктор имеет то же имя, что и класс.

Два Конструкторы:

public Money(long l) { 
     this.value = l; 
    } 

    public Money(String s) { 
     this.value = toLong(s); 
    } 

Что касается второго ответа, геттеры анс сеттеры не должны быть классы. Они должны находиться внутри самого класса.

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

public class Printer { 

    @Inject @Informal Greeting greeting; 

    private String name; 
    private String salutation; 

    public void createSalutation() { 
     this.salutation = greeting.greet(name); 
    } 

    public String getSalutation() { 
     return salutation; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

    public String getName() { 
     return name; 
    } 
} 

Хорошо читать по этой ссылке может определенно помочь вам! Java oriented-object principles

Answer 4

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

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

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

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

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

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

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

Answer 5

Многие люди обнаружили, что если они потратили годы на изучение языков, таких как COBOL и FORTRAN, то переход на OO-программирование предполагает отказ от изучения старых языков. Я, конечно, нашел это, когда впервые занялся C++ 20 лет назад. Из вашего описания вы явно боретесь с концепциями, и я сочувствую.

Я не думаю, что есть простой рецепт. Практикуйте на простых примерах и не унывайте. Не бойтесь спросить об этом - если вопросы будут четко заданы, вы получите полезный ответ.

Получите хорошую среду IDE (Eclipse, Netbeans и т. Д.), Которая позволяет вам «заглядывать» в объекты с помощью отладчика. Надеюсь, на каком-то этапе все будет щелкать!

Answer 6

Вопрос 1 - Основные классы Java:

Там довольно много только 3 вещи, которые вы собираетесь найти в классе Java

• поле/атрибут (в зависимости от языка, происхождения)
• метод
• Конструктор (который выглядит как особый вид метода)

Каждый CLAs s будет иметь имя класса, который разделяет имя файла он находится в Таким образом, чтобы расширить деньги немного:.

Money.java 
---------- 
public class Money { 
    // This is a field/attribute 
    Long value; 

    // This is a constructor 
    public Money() { 
     this.value = Long(0L); 
    } 

    // This is a method 
    public Long getValue() { 
     return value; 
    } 

    // Another method 
    public void makeMoney(Long moreMoney) { 
     this.value = this.value + moreMoney; 
    } 
} // Everything in here is part of the Money class 

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

Другой способ взглянуть на это, если вы удалите все ключевые слова Java, не относящиеся к типу (общедоступные, частные и т. Д., Но не такие, как float и int), с передней стороны метода, который вы ищете (Список которых вы найдете here), есть ли что-нибудь, что осталось перед методом?

С деньгами мы имеем на данный момент, это будет выглядеть следующим образом:

• Деньги()
• Long ПолучитьЗначение()
• аннулируются makeMoney()

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

Вопрос 2/3 - Get/Set методы:

Я собираюсь сказать что-то потенциально спорный, но не беспокойтесь о них до сих пор. Get/Set - это, по сути, шаблоны для объектно-ориентированной разработки и, как правило, хороший стиль Java, но они не требуются. (Последнее, что я проверил, разработка Android фактически препятствует их использованию, когда это возможно по причинам оптимизации). Более того, не все поля в ваших объектах будут доступны или изменены, поэтому их запись не является обязательной.

Если вы объявляете все ваши поля, как общественность (как поле «значение» подразумевается, что прямо сейчас), вы просто можете сделать это:

Money myMoney = new Money(new Long(40L)); 
System.out.println(myMoney.value) // 40 
myMoney.value = new Long(20L); 
System.out.println(myMoney.value) // 20 

Помимо этого, понятие ГЭТ () и set() - это просто методы. В них нет ничего особенного. Основная причина, по которой они существуют, заключается в том, что для общего объектно-ориентированного программирования вам не нужно напрямую изменять внутреннюю работу объекта (это the principle of Encapsulation). Все, что вам нужно, чтобы повлиять на состояние или получить что-то из него, должно быть обработано методом.

В надежном однострочном пространстве: Если вам нужно знать поля объекта для его использования, вы разработали его неправильно.

Big Picture Так что получить() и установить() на самом деле является парой обычно написанных методов, которые происходят влиять на поле в объекте в очень простом способе (получить() простой доступ к поле, set() является присвоением этому полю). Просто другие методы, которые вы пишете, будут делать более сложные вещи, чем это.

Answer 7

---

-> Это следующие, что я Недвижимость Болгария Недвижимость знать о конструкторе.

1) конструкторы не имеют типа возврата. 2) Их имена всегда совпадают с именем класса. 3) Конструкторы всегда общедоступны **

---

-> эта ссылка может помочь еще поисковиков.

https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html

---