Ի՞նչ խնդիրներ եք լուծել նախագծման նմուշների օգտագործմամբ։

Ես կիրառել եմ տարբեր նմուշներ՝ կոդի կառուցվածքը և սպասարկելիությունը բարելավելու համար:

Ստեղծողներ:

• 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-ի հատուկ պահանջը");
      }
  }
  
  public class Adapter implements Target {
      private Adaptee adaptee;
  
      public Adapter(Adaptee adaptee) {
          this.adaptee = adaptee;
      }
  
      @Override
      public void request() {
          adaptee.specificRequest();
      }
  }
  

• Decorator: Դինամիկ կերպով նոր պարտականություններ ավելացնել օբյեկտներին՝ առանց նրանց կառուցվածքը փոխելու։ Օգտագործվում էր լոգավորման կամ կեշավորման ֆունկցիոնալությունը ավելացնելու համար։
• Composite: Օբյեկտների հավաքածու՝ ծառային կառուցվածքով՝ ներկայացնելու մաս-օբյեկտ հարաբերություններ։ Օգտագործվում էր UI տարրերի կամ ֆայլային համակարգի կառուցվածքների հետ աշխատելիս։

Արտահայտական:

• 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: Ալգորիթմի հյուսվածքը սահմանել՝ որոշ քայլեր թողնելով ենթակլասների վրա։ Օգտագործվում էր գործընթացը ստանդարտացնելու համար։