Setter Methoden oder Konstruktoren

Wenn Sie möchten, haben eine unveränderliche Klasse Konstruktor anderweitig zu verwenden setter.

InformationsquelleAutor der Antwort Evgeniy Dorofeev

Ich denke, Sie fragte eine gute Frage: - Aber, wenn wir Konstruktoren verwenden und Wann verwenden wir setter?

Erste, beginnen wir mit einigen Konzepten. Ich hoffe, diese Erläuterung hilft allen, die wissen wollen, Wann Konstruktoren oder setter() und get() Methoden (Zugriffsmethoden und Mutatoren). Konstruktoren ähnlich sind Methodenes gibt jedoch einige Unterschiede zwischen Konstruktor und Methode in java:

1) Konstruktor wird verwendet, um zu initialisieren, die den Zustand eines Objekts. Methode verwendet wird, zu entlarven Verhalten eines Objekts.

2) Konstruktor muss nicht wieder geben. Methode müssen zurück geben.

3) Konstruktor aufgerufen wird, implizit. Methode aufgerufen wird, ausdrücklich.

4) Getter()oder Accessoren, sind Methoden, die den Zugriff auf ein Objekt die Instanz-Variablen. Setter()oder Mutatoren, werden die Methoden, die dem Aufrufer eine Gelegenheit, um den Wert zu aktualisieren, der eine bestimmte Instanz-variable.

Dass dies zu verdeutlichen, denken wir im Begriff der objektorientierten Programmierung (OOP), um die Anforderung zu erfüllen OOP-Prinzipien (Die Objekte-Orientierte Programmierung (OOP) ist gebaut über vier großen Prinzipien: KapselungAbstraktion der DatenPolymorphismus und Vererbung.), Get() und Setter() Methoden ist der Schlüssel, dies zu erreichen.

Hier ist eine Formel, die gehen, um Ihnen zu zeigen, was ich meine:

Private Felder + Öffentliche Zugriffsmethoden == Kapselung;

Wie Sie sehen können, basierend auf dieser Formel, wenn wir uns private Felder und öffentliche accesors wir durchführen Kapselung einer der 4 OOP-Prinzipien.

Hier bin ich Los, um Ihnen beiden Klassen habe ich noch kommentieren, zu versuchen, mein code selbsterklärend. Nehmen Sie diese Klassen als lab auf Methoden mit Customer und TestCustomer [das mit den main() Methode] Klassen, kopieren Sie den code und führen Sie es selbst. Hinweis: ich verwendete zwei Konstruktoren, um zu erklären, eine Klasse mit mehreren Konstruktoren und die öffentliche setters() und getters() Methoden, um Zugriff auf private Instanz-Variablen:

package com.exercise.lecture2;

/**
 * 1) Create a Customer class that has the following attributes:
 * name, SSN.
 * 2) This class should have two methods: getName() and getSSN().
 * 3) If the class is instantiated with only a SSN, then give the default name of "John Doe". (HINT: Use two constructors)
 * 4) Also, add a method toString(), that returns a string representation of the customer object (name and SSN concatenated).
 *      Make sure to set this method public.
 * 5) Create a class to test your program (e.g. a class that include the main() method). In your test program, instantiate
 *      three customers and print out the value using toString() method.
 * 
 * @author Samuel M.
 *
 */

//this class is complemented with class  TestLabCustomer.java
public class LabCustomer {

//Private filds: name and socialSecurityNum
    private String name;
    private int socialSecurityNum;

    //constructors
    public LabCustomer(String name, int socialSecurityNum) {
        this.name = name;
        this.socialSecurityNum = socialSecurityNum;
    }

    /** The keyword 'this' can be used to call a constructor from a constructor,
     * when writing several constructor for a class, there are times when
     * you'd like to call one constructor from another to avoid duplicate code.
     */
    //Account with This() on a second constructor
    public LabCustomer(int socialSecurityNum) {
        this("John Doe", socialSecurityNum); //default name is printed if only the SSN is provided
    }

    //Public accessors (getters and setters)
    String getName() {
        return name;
    }

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

    int getSSN() {
        return socialSecurityNum;
    }

    void setSSN(int socialSecurityNum) {
        this.socialSecurityNum = socialSecurityNum;
    }


    //instance method
    public String toString() { //overriding the toString() method 
        return ("Customer name: " + getName() + ", SSN#: " + getSSN() ); //concatenating the name and SSN

    }
}

Hier ist der test-Klasse, die, die das main() - Methode und dem Aufruf einer Instanz-Methode nach der Instanziierung ein Objekt der Vorschau Klasse:

package com.exercise.lecture2;

//this class is complemented with class  LabCustomer.java
public class TestLabCustomer {

    public static void main(String[] args) {
        //Instantiating an object of class LabCustomer and creating three customers objects
        LabCustomer cust1 = new LabCustomer("Juan Melendez", 123457789);
        LabCustomer cust2 = new LabCustomer("Mary Lee", 125997536);
        LabCustomer cust3 = new LabCustomer(124963574); //when instantiating with no "name", the default (John Doe) is printed 

        /**
         * Once you've instantiated an object and have an object variable,
         * you can use object variable to call an instance method. 
         *  e.g.:
         *  object variables: cust1, cust2, cust3
         *  call the method toString() using the object variable and dot [.] in order to perform the method call.
         */
        //calling method toString() in class LabCustomer to print customer values
        System.out.println(cust1.toString());
        System.out.println(cust2.toString());
        System.out.println(cust3.toString());

    }

}

Ergebnis:

Kunde name: Juan Melendez, SSN#: 123457789

Kunde name: Mary Lee, SSN#: 125997536

Kunden-name: John Doe, SSN#: 124963574

InformationsquelleAutor der Antwort S. Mayol

In den meisten Fällen benutze ich beide 🙂 (seit Sie 9/10 mal wieder kommen wollen, und Bearbeiten Sie etwas (und das ist nicht eine gute practive, um eine neue Instanz davon)

Ich normalerweise so etwas wie tihs

public class User {

    private int id;
    private String initials;
    private String firstName;
    private String lastName;
    private String email;

    public User() {
        this(0, "", "", "");
    }

    public User(int id, String firstName, String lastName, String email) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }
   //Getters and setters should be here
}

Und wenn Sie wollen, zu Bearbeiten, etwas mit ihm können Sie einfach die setter, (eine gute Sache, wenn Sie zum Beispiel speichern Sie Ihre Benutzer in einer ArrayList, dann können Sie einfach Holen Sie das Objekt aus der arraylist und setzen Sie einfach das Feld, das Sie wollen, zu Bearbeiten, anstatt ein brandneues Objekt 🙂

InformationsquelleAutor der Antwort Kasper Franz

Im Falle der Konstruktoren, Wenn Sie die Felder aktualisieren, erstellen Sie ein neues Objekt jedes mal durch die Verwendung neue Stichwort.

Customer customer = new Customer("Tom", 23, 10000);

Zum Beispiel, wenn Sie aktualisieren möchten, das Gehalt von Tom, den Sie schreiben müssen, diese Linie wieder mit aktuellen Gehalt, das bedeutet, dass Speicher verschwendet wird.

Im Fall von setter-Methoden können Sie einzelne Felder in original-Objekt nur.

InformationsquelleAutor der Antwort Sushil kumawat

In einfachen Worten:

Verwenden Konstruktor wenn Sie denken, Objekt-Initialisierung ist zwingend vor der Verwendung des Objekts.

Verwenden setter - Methode bei der Initialisierung von Variablen ist nicht zwingend erforderlich, um das Objekt verwenden.

Finden Sie in der Dokumentation Seite für mehr details.

InformationsquelleAutor der Antwort Ravindra babu