Jak w elegancki sposób zainicjować klasy z wieloma polami?

Możesz użyć konstruktora lub wzorca konstruktora lub wariantu wzorca konstruktora, aby rozwiązać problem posiadania zbyt wielu pól w kroku inicjalizacji.

Zamierzam rozszerzyć twój przykład trochę, aby udowodnić mój punkt, dlaczego te opcje są przydatne.

Zrozumienie twojego przykładu:

Powiedzmy, że Offer jest po prostu klasą kontenera dla 4 pól:

public class Offer {
    private int price;
    private Date dateOfOffer;
    private double duration;
    private HotelOnly hotelOnly;
    // etc. for as many or as few fields as you need

    public int getPrice() {
        return price;
    }

    public Date getDateOfOffer() {
        return dateOfOffer;
    }

    // etc.
}

W twoim przykładzie, aby ustawić wartości dla tych pól, używasz seterów:

    public void setHotelOnly(HotelOnly hotelOnly) {
        this.hotelOnly = hotelOnly;
    }

Niestety, oznacza to, że jeśli potrzebujesz oferty z wartościami we wszystkich polach, musisz zrobić to, co masz:

Offers offers = new Offers();
Offer offer = new Offer();
offer.setPrice(price);
offer.setDateOfOffer(date);
offer.setDuration(duration);
offer.setHotelOnly(hotelOnly);
offers.add(offer);

Spójrzmy teraz na poprawę tego.

Wariant 1: Konstruktorzy!

Konstruktor inny niż domyślny (konstruktor domyślny to obecnie Offer()) jest przydatny do inicjalizacji wartości pól w twojej klasie.

Wersja Offer z użyciem konstruktorów wyglądałaby następująco to:

public class Offer {
    private int price;
    private Date dateOfOffer;
    //etc.

    // CONSTRUCTOR
    public Offer(int price, Date dateOfOffer, double duration, HotelOnly hotelOnly) {
        this.price = price;
        this.dateOfOffer = dateOfOffer;
        //etc.
    }

    // Your getters and/or setters
}

Teraz możemy zainicjować to w jednej linii!

Offers offers = new Offers();
Offer offer = new Offer(price, date, duration, hotelOnly);
offers.add(offer);

Nawet lepiej, jeśli nigdy nie używasz offer innej niż ta pojedyncza linia: offers.add(offer); nie musisz nawet zapisywać jej w zmiennej!

Offers offers = new Offers();
offers.add( new Offer(price, date, duration, hotelOnly) ); // Works the same as above

Opcja 2: Wzorzec Konstruktora

Wzorzec konstruktora jest przydatny, jeśli chcesz mieć opcję domyślnych wartości dla dowolnego z twoich pól.

Problem, który rozwiązuje wzorzec konstruktora, to następujący bałagan w kodzie:

public class Offer {
    private int price;
    private Date dateOfOffer;
    // etc.

    // The original constructor. Sets all the fields to the specified values
    public Offer(int price, Date dateOfOffer, double duration, HotelOnly hotelOnly) {
        this.price = price;
        this.dateOfOffer = dateOfOffer;
        // etc.
    }

    // A constructor that uses default values for all of the fields
    public Offer() {
        // Calls the top constructor with default values
        this(100, new Date("10-13-2015"), 14.5, new HotelOnly());
    }

    // A constructor that uses default values for all of the fields except price
    public Offer(int price) {
        // Calls the top constructor with default values, except price
        this(price, new Date("10-13-2015"), 14.5, new HotelOnly());
    }

    // A constructor that uses default values for all of the fields except Date and HotelOnly
    public Offer(Date date, HotelOnly hotelOnly) {
        this(100, date, 14.5, hotelOnly);
    }

    // A bunch more constructors of different combinations of default and specified values

}

Zobacz jak bałagan, który może być?

Wzorzec budowniczy to kolejna klasa, którą wkładasz do swojej klasy.

public class Offer {
    private int price;
    // etc.

    public Offer(int price, ...) {
        // Same from above
    }

    public static class OfferBuilder {
        private int buildPrice = 100;
        private Date buildDate = new Date("10-13-2015");
        // etc. Initialize all these new "build" fields with default values

        public OfferBuilder setPrice(int price) {
            // Overrides the default value
            this.buildPrice = price;

            // Why this is here will become evident later
            return this;
        }

        public OfferBuilder setDateOfOffer(Date date) {
            this.buildDate = date;
            return this;
        }

        // etc. for each field

        public Offer build() {
            // Builds an offer with whatever values are stored
            return new Offer(price, date, duration, hotelOnly);
        }
    }
}

Teraz nie musisz mieć tak wielu konstruktorów, ale nadal możesz wybrać, które wartości chcesz pozostawić domyślne, a które chcesz zainicjować.

Offers offers = new Offers();
offers.add(new OfferBuilder().setPrice(20).setHotelOnly(hotelOnly).build());
offers.add(new OfferBuilder().setDuration(14.5).setDate(new Date("10-14-2015")).setPrice(200).build());
offers.add(new OfferBuilder().build());

Ta ostatnia oferta jest po prostu taka z wszystkimi domyślnymi wartościami. Pozostałe są wartościami domyślnymi, z wyjątkiem tych, które ustawiłem.

Wariant 3: Zmiana wzoru budowniczego

Możesz również użyć wzorca builder, po prostu sprawiając, że Twoje obecne setery zwrócą ten sam obiekt oferty. Jest dokładnie taki sam, tylko bez dodatkowej klasy OfferBuilder.

Ostrzeżenie: jak użytkownik WW stwierdza poniżej, ta opcja łamie JavaBeans-standardową konwencję programowania dla klas kontenerów, takich jak Offer. Nie powinieneś więc używać tego do celów zawodowych i powinieneś ograniczyć swoje użycie we własnym zakresie praktyki.

public class Offer {
    private int price = 100;
    private Date date = new Date("10-13-2015");
    // etc. Initialize with default values

    // Don't make any constructors

    // Have a getter for each field
    public int getPrice() {
        return price;
    }

    // Make your setters return the same object
    public Offer setPrice(int price) {
        // The same structure as in the builder class
        this.price = price;
        return this;
    }

    // etc. for each field

    // No need for OfferBuilder class or build() method
}

A Twój nowy kod inicjalizacyjny to

Offers offers = new Offers();
offers.add(new Offer().setPrice(20).setHotelOnly(hotelOnly));
offers.add(new Offer().setDuration(14.5).setDate(new Date("10-14-2015")).setPrice(200));
offers.add(new Offer());

Ta ostatnia oferta jest po prostu taka z wszystkimi domyślnymi wartościami. Pozostałe są wartościami domyślnymi, z wyjątkiem tych, które ustawiłem.

Więc, chociaż jest to dużo pracy, jeśli chcesz wyczyścić swój krok inicjalizacji, musisz użyć jednej z tych opcji dla każdej z klas, które mają pola w nich. Następnie użyj metod inicjalizacji, które dołączałem do każdej metody.