Ի՞նչ նախագծման նմուշներ կարելի է օգտագործել Kotlin լեզվում։

Կոտլինում հաճախ կիրառվում են հետևյալ օրինակները:

• Singleton: Հեշտությամբ իրականացվում է object-ի միջոցով:

  object MySingleton {
      fun doSomething() {
          // ...
      }
  }
  

• Factory Method: Աբստրակտ ֆունկցիա վերևում կամ ինտերֆեյսում, որը իրականացնում են ենթակլասները օբյեկտներ ստեղծելու համար:

  interface Product {
      fun operation()
  }
  
  class ConcreteProductA : Product {
      override fun operation() {
          // ...
      }
  }
  
  abstract class Creator {
      abstract fun factoryMethod(): Product
  
      fun someOperation(): Product {
          val product = factoryMethod()
          // ...
          return product
      }
  }
  
  class ConcreteCreatorA : Creator() {
      override fun factoryMethod(): Product {
          return ConcreteProductA()
      }
  }
  

• Abstract Factory: Գործարանների խումբ՝ կապված սերունդների ստեղծման համար:

  interface AbstractProductA {
      fun usefulFunctionA()
  }
  
  interface AbstractProductB {
      fun usefulFunctionB()
      fun anotherUsefulFunctionB(collaborator: AbstractProductA)
  }
  
  interface AbstractFactory {
      fun createProductA(): AbstractProductA
      fun createProductB(): AbstractProductB
  }
  
  // Կոնկրետ արտադրանքներ և գործարաններ...
  

• Builder: Օգտակար է բարդ օբյեկտների կառուցման համար քայլ առ քայլ:

  class Pizza private constructor(
      val crust: String,
      val sauce: String?,
      val toppings: List<String>
  ) {
      data class Builder(
          var crust: String = "thin",
          var sauce: String? = null,
          val toppings: MutableList<String> = mutableListOf()
      ) {
          fun withCrust(crust: String) = apply { this.crust = crust }
          fun withSauce(sauce: String) = apply { this.sauce = sauce }
          fun addTopping(topping: String) = apply { this.toppings.add(topping) }
          fun build() = Pizza(crust, sauce, toppings)
      }
  }
  
  fun main() {
      val pizza = Pizza.Builder()
          .withCrust("thick")
          .withSauce("tomato")
          .addTopping("pepperoni")
          .addTopping("mushrooms")
          .build()
      // ... օգտագործել պիցա
  }
  

• Adapter: Հնարավորություն է տալիս անհամատեղելի ինտերֆեյսներով օբյեկտներին աշխատել միասին:

  open class Adaptee {
      fun specificOperation() {
          // ...
      }
  }
  
  interface Target {
      fun operation()
  }
  
  class Adapter(private val adaptee: Adaptee) : Target {
      override fun operation() {
          adaptee.specificOperation()
      }
  }
  

• Decorator: Ավելացնում է նոր ֆունկցիոնալություն առկա օբյեկտներին՝ առանց նրանց կառուցվածքը փոխելու:

  interface DataSource {
      fun readData(): String
      fun writeData(data: String)
  }
  
  class FileDataSource(private val filename: String) : DataSource {
      override fun readData(): String {
          // Ֆայլից կարդալ
          return ""
      }
  
      override fun writeData(data: String) {
          // Ֆայլում գրել
      }
  }
  
  class EncryptionDecorator(private val source: DataSource) : DataSource by source {
      override fun readData(): String {
          // Դեկոդավորել տվյալները
          val data = source.readData()
          return data // դեկոդավորված տվյալներ
      }
  
      override fun writeData(data: String) {
          // Կոդավորել տվյալները
          source.writeData(data) // կոդավորված տվյալներ
      }
  }
  

• Observer: Կարգավորում է "մեկից շատ" կախվածությունը:

  // Պարզ իրականացում առանց Flow
  interface Observer {
      fun update(message: String)
  }
  
  class Subject {
      private val observers = mutableListOf<Observer>()
  
      fun attach(observer: Observer) {
          observers.add(observer)
      }
  
      fun detach(observer: Observer) {
          observers.remove(observer)
      }
  
      fun notifyObservers(message: String) {
          observers.forEach { it.update(message) }
      }
  }
  

• Strategy: Հավաքում է ալգորիթմների ընտանիքը, նրանց ինկապսուլացնում և փոխարինելի դարձնում:

  interface PaymentStrategy {
      fun pay(amount: Double)
  }
  
  class PayByCreditCard(private val cardNumber: String) : PaymentStrategy {
      override fun pay(amount: Double) {
          println("Վճարում $amount՝ կրեդիտ քարտով $cardNumber")
      }
  }
  
  class PayByPayPal(private val email: String) : PaymentStrategy {
      override fun pay(amount: Double) {
          println("Վճարում $amount՝ PayPal-ով $email")
      }
  }
  
  class Order(private val paymentStrategy: PaymentStrategy) {
      fun processOrder(amount: Double) {
          // ... որոշակի պատվերի մշակում
          paymentStrategy.pay(amount)
      }
  }
  

• State: Թույլ է տալիս օբյեկտին փոխել իր վարքագիծը՝ կախված ներսի վիճակից:

  sealed class State {
      object Idle : State()
      object Loading : State()
      data class Error(val message: String) : State()
      data class Success(val data: Any) : State()
  }
  
  class Context {
      var state: State = State.Idle
  
      fun handleEvent() {
          when (state) {
              State.Idle -> {
                  println("Ինքնակառավարում Idle վիճակում")
                  state = State.Loading
              }
              State.Loading -> {
                  println("Ինքնակառավարում Loading վիճակում, անտեսում")
              }
              is State.Error -> {
                  println("Ինքնակառավարում Error վիճակում: ${state.message}")
                  // հնարավոր է անցում այլ վիճակի
              }
              is State.Success -> {
                  println("Ինքնակառավարում Success վիճակում: ${state.data}")
                  // հնարավոր է անցում այլ վիճակի
              }
          }
      }
  }
  

• Repository: Աբստրակտացնում է տվյալների մուտքի լոգիկան բիզնես լոգիկայից:

Կան բազմաթիվ այլ օրինակներ, ինչպիսիք են Facade, Proxy, Command, Iterator, Template Method և Visitor, որոնք նույնպես կիրառելի են Kotlin-ում: Kotlin-ի լեզվական առանձնահատկությունները, ինչպիսիք են ընդլայնումները, դելեգատները, data դասերը և sealed դասերը, հաճախ դարձնում են օրինակների իրականացմանը ավելի իդիոմատիկ և կարճ: