Wzorce projektowe Java podstawy + przykładowe pytania rekrutacyjne

Singleton

Zapewnia, że klasa ma tylko jedną instancję i globalny punkt dostępu do niej.

Factory Method

Definiuje interfejs do tworzenia obiektów, ale pozwala podklasom decydować, która klasa będzie instancjonowana.

Abstract Factory

Udostępnia interfejs do tworzenia rodzin powiązanych lub zależnych obiektów bez określania ich konkretnych klas.

Adapter

Przekształca interfejs na inny interfejs oczekiwany przez klienta, umożliwiając współpracę klas, które w przeciwnym razie nie mogłyby ze sobą współpracować.

Bridge

Oddziela abstrakcję od jej implementacji, co pozwala na niezależny rozwój obu tych elementów.

Composite

Składa obiekty w strukturę drzewiastą, aby reprezentować hierarchie części i całości, umożliwiając klientom traktowanie pojedynczych obiektów i ich kompozycji w jednolity sposób.

Observer

Definiuje zależność jeden-do-wielu między obiektami, tak aby zmiana stanu jednego obiektu skutkowała powiadomieniem i aktualizacją wszystkich zależnych obiektów.

Strategy

Definiuje rodzinę algorytmów, enkapsuluje je i sprawia, że są wymienne, pozwalając na dynamiczną zmianę algorytmu używanego przez klienta.

Command

Przekształca żądanie w obiekt, co pozwala na parametryzowanie obiektów innymi żądaniami, kolejkowanie lub logowanie żądań oraz obsługę operacji undo.

Kluczowe cechy

Jedna instancja: gwarantuje, że klasa posiada tylko jedną instancję.

Globalny dostęp: umożliwia globalny dostęp do tej instancji.

Kontrola nad instancją: zapewnia kontrolę nad procesem tworzenia instancji.

Implementacja w Javie

public class SingleInstance {
    private static SingleInstance instance;
    
    // Private constructor prevents the creation of external objects.
    private SingleInstance() { }
    
    // Public method that returns a single instance of Singleton
    public static synchronized SingleInstance getInstance() { 
        if (instance == null) {
            instance = new SingleInstance(); 
        }

        return instance; 
    }
}

W powyższym przykładzie:

Prywatny konstruktor: zapobiega tworzeniu instancji z zewnątrz.

Statyczna metoda getInstance: zapewnia globalny punkt dostępu do jedynej instancji. Napisanie słowa kluczowego Synchronized zapewnia,że metoda jest bezpieczna w środowiskach wielowątkowych. 

Zarządzanie konfiguracją

Singleton może być używany do przechowywania i udostępniania ustawień konfiguracyjnych aplikacji, zapewniając, że wszystkie części aplikacji korzystają z tych samych ustawień.

public class ConfigurationManager {
    private static ConfigurationManager instance; 
    private Properties config;
    
    private ConfigurationManager() {
        config = new Properties();
        // Load properties from a file
        // config.load(new FileInputStream("config.properties"));
    }
    
    public static synchronized ConfigurationManager getInstance() { 
        if (instance == null) {
            instance = new ConfigurationManager(); 
        }
    
        return instance; 
    }
    
    public String getProperty(String key) { 
        return config.getProperty(key);
    } 
}

Singleton w Spring Framework

Spring Framework automatycznie zarządza beanami w kontekście aplikacji jako singletonami. Domyślnie, każdy bean w Springu jest singletonem, co oznacza, że Spring zarządza pojedynczą instancją beana w całym kontekście aplikacji.

Przykład definicji beana jako singleton w konfiguracji Springa:

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() { 
        return new MyService();
    } 
}

W Springu zawsze można stworzyć Singleton w bardzo prosty sposób, wystarczy dodać adnotacje @Repository, @Service, @Controller, @Component̨, a kontener Springa zajmie się resztą.

Zalety Singletona

Globalny dostęp: umożliwia dostęp do tej samej instancji z dowolnego miejsca w aplikacji.

Kontrola zasobów: zapewnia centralizację zarządzania zasobami, takimi jak konfiguracje czy połączenia z bazą danych.

Łatwość implementacji: prosta i intuicyjna konstrukcja.

Wady Singletona

Problemy z testowaniem: trudność w testowaniu jednostkowym z powodu globalnego stanu, który może być trudny do resetowania między testami.

Skłonność do nadużywania: może prowadzić do nadmiernego używania globalnego stanu, co komplikuje utrzymanie i zrozumienie kodu.

Wielowątkowość: może być problematyczny w środowiskach wielowątkowych, jeśli nie jest odpowiednio zaimplementowany (konieczne są mechanizmy synchronizacji).

Podsumowanie

Użycie w Javie: Integer vs int

int: typ prymitywny reprezentujący liczby całkowite (np. 1, 2, -3).

Integer: klasa opakowująca dla int, która zapewnia dodatkowe funkcjonalności, takie jak metody pomocnicze, możliwość używania w kontekście generycznym i automatyczne konwertowanie do/z typu prymitywnego. Także możliwe jest tutaj przechowywanie null’a oraz wykonywanie takich funkcji jak equals() czy toString().

int primitiveInt = 10;
Integer wrappedInt = new Integer(10);

// Can be used in a generic context
List<Integer> integerList = new ArrayList<>(); 
integerList.add(1);
integerList.add(2);

// Automatic conversion between int and Integer
int intValue = wrappedInt.intValue();

Tworzenie prostego Wrappera w biznesowym kontekście

public class CustomerOrderWrapper { 
    private Customer customer; 
    private Order order;

    public CustomerOrderWrapper(Customer customer, Order order) { 
        this.customer = customer;
        this.order = order;
    }
    
    public Customer getCustomer() { 
        return customer;
    }
    
    public Order getOrder() { 
        return order;
    } 
}

W powyższym przykładzie CustomerOrderWrapper opakowuje obiekty customer i order w jeden wrapper, umożliwiając operowanie na obu obiektach jednocześnie w aplikacji.

Zalety Wrapperów

Adaptacja interfejsów: umożliwia adaptację istniejących interfejsów lub klas do nowych wymagań.

Łatwość używania różnych typów danych: Wrappery pozwalają na manipulowanie danymi w bardziej elastyczny sposób, w tym konwersję między różnymi typami.

Wady Wrapperów

Dodatkowy poziom abstrakcji: może wprowadzać dodatkowy poziom abstrakcji i złożoności w kodzie.

Overhead związany z opakowywaniem: może wprowadzać nieznaczny narzut wydajnościowy związany z tworzeniem i zarządzaniem obiektami wrapperów.

Podsumowanie

Użycie w Javie (kolekcje)

List<String> list = new ArrayList<>(); 
list.add("Element 1"); 
list.add("Element 2");
list.add("Element 3");

// Obtaining an iterator
Iterator<String> iterator = list.iterator();

// Iteration and display of elements
while (iterator.hasNext()) {
    String element = iterator.next(); 
    System.out.println(element);
}

W powyższym przykładzie iterator() zwraca Iterator dla listy ArrayList, który może być używany do sekwencyjnego przechodzenia przez elementy listy za pomocą metod hasNext() i next()

Implementacja własnego Iteratora

public class CustomCollection {
    private String[] elements = {"A", "B", "C"};
    
    public Iterator<String> iterator() { 
        return new CustomIterator();
    }
    
    private class CustomIterator implements Iterator<String> { 
        private int index = 0;
    
        @Override
        public boolean hasNext() {
            return index < elements.length; 
        }
        
        @Override
        public String next() { 
            if (!hasNext()) {
                throw new NoSuchElementException(); 
            }
            return elements[index++]; 
        } 
    } 
}

W tym przykładzie CustomCollection zawiera niestandardową tablicę elements, a CustomIterator jest zagnieżdżoną klasą implementującą interfejs Iterator. Dzięki temu możemy iterować po elementach CustomCollection tak samo jak po standardowych kolekcjach.

Zalety Iteratora

Oddzielenie interfejsu od implementacji: Iterator umożliwia dostęp do elementów kolekcji bez ujawniania szczegółów jej struktury.

Uniwersalność: umożliwia zastosowanie tych samych operacji iteracyjnych dla różnych rodzajów kolekcji.

Zastosowanie Iteratora

Przeglądanie i operowanie na elementach kolekcji: Iterator jest używany wszędzie tam, gdzie potrzebujemy sekwencyjnego dostępu do elementów kolekcji bez względu na jej konkretną implementację.

Wielokrotne przetwarzanie danych: Iterator pozwala wielokrotnie przechodzić przez te same dane bez konieczności kopiowania ich lub modyfikowania struktury kolekcji.

Podsumowanie