რომელ დავალებებს გადაჭრიდით დიზაინის ნიმუშების გამოყენებით?

მონაცემთა სტრუქტურის და შენარჩუნების გაუმჯობესებისთვის სხვადასხვა ნიმუშების გამოყენება:

შექმნითი:

• Singleton: ერთეული ობიექტის შექმნისთვის, მაგალითად კონფიგურაციის მენეჯერი ან მონაცემთა ბაზის კავშირის პული.

  public final class ConfigManager {
      private static ConfigManager instance;
      private ConfigManager() {} //პირადი კონსტრუქტორი
      public static synchronized ConfigManager getInstance() {
          if (instance == null) {
              instance = new ConfigManager();
          }
          return instance;
      }
  }
  

• Factory Method: ობიექტების შექმნა გარკვეული თვისებებით, კონკრეტული კლასების პირდაპირი მითითების გარეშე. გამოიყენებოდა ფაილური პარსერების სხვადასხვა ტიპებთან მუშაობისას.
• Abstract Factory: დაკავშირებული ან დამოკიდებული ობიექტების ოჯახების შექმნა, მათი კონკრეტული კლასების მითითების გარეშე. გამოიყენებოდა სხვადასხვა მონაცემთა წყაროების ტიპებთან (მაგ. ფაილური სისტემა, მონაცემთა ბაზა) და შესაბამის ობიექტებთან მუშაობისას.

სტრუქტურული:

• Adapter: ერთ კლასის ინტერფეისის ადაპტაცია მეორესთან, რომელიც მომხმარებელი ელოდება. გამოიყენებოდა მესამე მხარის ბიბლიოთეკების ინტეგრაციისთვის შეუთავსებელი ინტერფეისებით.

  public interface Target {
      void request();
  }
  
  public class Adaptee {
      public void specificRequest() {
          System.out.println("Adaptee's specific request");
      }
  }
  
  public class Adapter implements Target {
      private Adaptee adaptee;
  
      public Adapter(Adaptee adaptee) {
          this.adaptee = adaptee;
      }
  
      @Override
      public void request() {
          adaptee.specificRequest();
      }
  }
  

• Decorator: ახალი ფუნქციონალების დინამიური დამატება ობიექტებს მათი სტრუქტურის შეცვლის გარეშე. გამოიყენებოდა ლოგირების ან ქეშირების ფუნქციონალების დამატებისთვის არსებული ობიექტებზე.
• Composite: ობიექტების გაერთიანება ხის სტრუქტურებში, რათა წარმოდგენილ იქნას "ნაწილი- მთლიანი" იერარქიები. გამოიყენებოდა მომხმარებლის ინტერფეისის ელემენტებთან ან ფაილური სტრუქტურასთან მუშაობისას.

მოქმედებითი:

• Observer: დამოკიდებულების განსაზღვრა "ერთი-მრავალი" ობიექტებს შორის, بحيث ერთი ობიექტის მდგომარეობის ცვლილებისას ყველა დამოკიდებული ობიექტი იუწყება და ავტომატურად განახლდება. გამოიყენებოდა შეტყობინებების სისტემის რეალიზაციისთვის.

  import java.util.ArrayList;
  import java.util.List;
  
  public class Subject {
      private List<Observer> observers = new ArrayList<>();
      private int state;
  
      public void attach(Observer observer) {
          observers.add(observer);
      }
  
      public void setState(int state) {
          this.state = state;
          notifyObservers();
      }
  
      private void notifyObservers() {
          for (Observer observer : observers) {
              observer.update();
          }
      }
  }
  
  public interface Observer {
      void update();
  }
  

• Strategy: ალგორითმების ოჯახების განსაზღვრა, თითოეული მათგანის ინკაფსულაცია და მათი ურთიერთგამომრიცხველობის უზრუნველყოფა. გამოიყენებოდა მონაცემების დამუშავების სხვადასხვა სტრატეგიის არჩევისთვის კონტექსტის მიხედვით.
• Template Method: ალგორითმის რბილი სქემის განსაზღვრა ოპერაციაში, გარკვეული ნაბიჯების გადადებით ქვესაფრებზე. გამოიყენებოდა მოთხოვნების დამუშავების პროცესის სტანდარტიზაციისთვის.