რა დიზაინის ნიმუშებს შეიძლება გამოიყენოს 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()
      // ... use pizza
  }
  

• Adapter: საშუალებას აძლევს შეუთანხმებელ ინტერფეისებს ერთად მუშაობას.

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

• Decorator: დამატებს ახალი ფუნქციებს არსებულ ობიექტებს მათი სტრუქტურის შეცვლის გარეშე. Kotlin-ის გაფართოებები და დელეგირებები ამაში ძალიან ეხმარება.

  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: განსაზღვრავს "ერთი მრავალი" დამოკიდებულებას. Coroutines Flow და Kotlin-ის დელეგირებული თვისებები შეიძლება გამოყენებულ იქნას.

  // მარტივი რეალიზაცია 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("Paying $amount using Credit Card $cardNumber")
      }
  }
  
  class PayByPayPal(private val email: String) : PaymentStrategy {
      override fun pay(amount: Double) {
          println("Paying $amount using PayPal $email")
      }
  }
  
  class Order(private val paymentStrategy: PaymentStrategy) {
      fun processOrder(amount: Double) {
          // ...some order processing
          paymentStrategy.pay(amount)
      }
  }
  

• State: საშუალებას აძლევს ობიექტს შეცვალოს თავისი ქცევა დამოკიდებული შინაგან მდგომარეობაზე. Sealed კლასები და when გამოთქმები ამაში ეხმარება.

  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("Handling event in Idle state")
                  state = State.Loading
              }
              State.Loading -> {
                  println("Handling event in Loading state, ignoring.")
              }
              is State.Error -> {
                  println("Handling event in Error state: ${state.message}")
                  // შესაძლებელია, გადასვლა სხვა მდგომარეობაში
              }
              is State.Success -> {
                  println("Handling event in Success state: ${state.data}")
                  // შესაძლებელია, გადასვლა სხვა მდგომარეობაში
              }
          }
      }
  }
  

• Repository: აბსტრაგირებს მონაცემთა წვდომის ლოგიკას ბიზნეს-ლოგიკიდან.

მეტი ნიმუშები, როგორიცაა Facade, Proxy, Command, Iterator, Template Method და Visitor, ასევე გამოიყენება Kotlin-შივე. Kotlin-ის ენობრივი მახასიათებლები, როგორიცაა გაფართოებები, დელეგირება, data კლასები და sealed კლასები, ხშირად ხდის ნიმუშების რეალიზაციას უფრო იდიომატულ და კოკეტულ.