Jeśli moja strona Ci pomogła, i chcesz aby była bardziej rozwijana, wesprzyj mnie buy me a coffee

I. Wzorce kreacyjne
1. Singleton
2. Budowniczy
3. Prototyp
4. Fabryka
5. Fabryka abstrakcyjna
II. Wzorce strukturalne
1. Adapter
2. Most
3. Kompozyt
4. Dekorator
5. Fasada
6. Pyłek
7. Pełnomocnik
III. Wzorce czynnościowe
1. Łańcuch zobowiązań
2. Polecenie
3. Interpreter
4. Iterator
5. Mediator
6. Pamiątka
7. Obserwator
8. Stan
9. Strategia
10. Metoda szablonowa
11. Odwiedzający

Kompozyt (Composite) - wzorzec projektowy (design pattern) - java

1. Cel:
Kompozyt (Composite) reprezentuje hierarchię obiektów w formie drzewa.
Proszę nie mylić kompozyt (composite) z kompozycja (composition).
Kompozyt (Composite) jest wzorcem operującym na hierarchi obiektów.
kompozycja (Composition) jest to jeden obiekt zawieracjący drugi.

2. Problem:
Chcemy mieć powiązene ze sobą obiekty w formie drzewa. np Pracownik jak Manager, ma pod sobą innych pracowników,
ale sam również jest pracownikiem i jest pod dyrektorem.

3. Rozwiązanie:
Budujemy strukture drzewa, implementujemy interface komponentu, implementujemy na jego podstawie liście (dzieci, Leaf)
oraz composite (kompozyt) - który ma informację o liściach (dzieciach).

4. Diagram klas wzorca composite:


5. Implementacja:

Implementacja interfeju:

  1. public interface Employee {
  2.         void add(Employee employee);
  3.         void remove(Employee employee);
  4.         Rmployee getChild(int i);
  5.         String getName();
  6.         double getSalary();
  7.         void printDetails();
  8. }
  9.  


Implementacja klasy Manager:

  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  3. import java.util.List;
  4.  
  5. public class Manager implements Employee{
  6.         private String name;
  7.         private double salary;
  8.         private List<Employee> employees = new ArrayList <Employee>();
  9.  
  10.         public Manager(String name,double salary){
  11.                 this.name = name;
  12.                 this.salary = salary;
  13.         }
  14.  
  15.         public void add(Employee employee) {
  16.                 employees.add(employee);
  17.         }
  18.  
  19.         public void remove(Employee employee) {
  20.                 employees.remove(employee);
  21.         }
  22.  
  23.         public Employee getChild(int i) {
  24.                 return employees.get(i);
  25.         }
  26.  
  27.         public String getName() {
  28.                 return name;
  29.         }
  30.  
  31.         public double getSalary() {
  32.                 return salary;
  33.         }
  34.  
  35.         public void printDetails() {
  36.                 System.out.println("---------------------");
  37.                 System.out.println("Name: " + getName());
  38.                 System.out.println("Salary: " + getSalary());
  39.  
  40.         Iterator<Employee> employeeIterator = employees.iterator();
  41.                 while(Employee employee : employees){
  42.                         employee.print();
  43.                 }
  44.         }
  45. }
  46.  
  47.  


Implementacja klasy pracownika Developer:

  1. public class Developer implements Employee {
  2.         private String name;
  3.         private double salary;
  4.  
  5.         public Developer(String name,double salary){
  6.                 this.name = name;
  7.                 this.salary = salary;
  8.         }
  9.        
  10.         public void add(Employee employee) {
  11.                 throw new UnsupportedOperationException();
  12.         }
  13.  
  14.         public void remove(Employee employee) {
  15.                 throw new UnsupportedOperationException();
  16.         }
  17.  
  18.         public Employee getChild(int i) {
  19.                 return null;
  20.         }
  21.  
  22.         public String getName() {
  23.                 return name;
  24.         }
  25.  
  26.         public double getSalary() {
  27.                 return salary;
  28.         }
  29.  
  30.         public void printDetails() {
  31.                 System.out.println("---------------------");
  32.                 System.out.println("Name: " + getName());
  33.                 System.out.println("Salary: " + getSalary());
  34.         }
  35.  
  36. }
  37.  
  38.  
  39.  
Klasa testowa:

  1.  
  2. public class CompositeTest {
  3.         public static void main(String[] args) {
  4.                 Employee employee1 = new Developer("Mateusz Nowak", 4242);
  5.                 Employee employee2 = new Developer("Tomasz Kowalski", 7000);
  6.                 Employee manager1 = new Manager("Michal Malinowski",6000);
  7.                 manager1.add(employee1);
  8.                 manager1.add(employee2);
  9.                 Employee employee3 = new Developer("Jan Fasola", 2300);
  10.                 Manager generalManager=new Manager("Chuck Norris", 29000);
  11.                 generalManager.add(employee3);
  12.                 generalManager.add(manager1);
  13.                 generalManager.printDetails();
  14.         }
  15. }
  16.  
  17.  


Wypisane zostanie:

---------------------
Name: Mateusz Nowak
Salary: 4242.0
---------------------
Name: =Tomasz Kowalski
Salary: 7000.0
---------------------
NameL Bernhard Riemann
Salary =1900.0
---------------------
Name: Carl Gauss
Salary: 6000.0
---------------------
Name: Chuck Norris
Salary: 29000.0


6. Zastosowanie w kodzie java:
- java.awt.Container#add(Component) (praktycznie wszystkie elementy Swinga)
- javax.faces.component.UIComponent#getChildren() (praktycznie we wszystkich komponentach JSF UI)
created by cv.java.org.pl © 2023 All Rights Reserved.