Ադապտեր (նախագծման ձևանմուշ)

Վիքիպեդիայից՝ ազատ հանրագիտարանից
Ադապտեր
Անգլերեն անվանում` Adapter
Տեսակ` Կառուցվածքային
Նշանակություն` Ֆունկցիայի օբյեկտների օգտագործում կազմակերպելու համար հատուկ ստեղծված ինտերֆեյսի միջոցով (բերում է մեկ կամ մի քանի դասերի ինտերֆեյսները պահանջված ինտերֆեյսի)։
Կառուցվածք` ObjectAdapter.png
Կիրառություն` Համակարգը սպասարկում է անհրաժեշտ տվյալներն ու վարքը, բայց չունի համապատասխան ինտերֆեյս: Հաճախ Ադապտեր ձևանմուշն օգտագործվում է նոր դաս ստեղծելու ժամանակ, որն իր հերթին ստեղծվել է արդեն գոյություն ունեցող աբստրակ դասի կամ էլ վերասահմնաված դասի հիման վրա:
Առավելություններ` Հետևյալն է.
  • ներքին դասերի (կոմպոնենտներ, գրադրաններ) իրականացման ինկապսուլացիա: Համակարգը դառնում է ներքին դասերի ինտեֆեյսերից անկախ:
  • ներքին դասերի օգտագործամանն անցնելիս համակարգի փոփոխություններ չի պահանջվում: Բավարար է իրականացնել միայն Adapter դասը:
Նկարագրությունը ԳօՖի
"Design Patterns" գրքում`
Այո

Ադապտեր (անգլ.՝ Adapter), կառուցվածքային նախագծման ձևանմուշ, որը նախատեսված է օբյեկտի ֆունկցիաների կազմակերպման նպատակով հատուկ ինտերֆեյս ստեղծելու համար։

Ընդհանուր հասկացողություններ[խմբագրել | խմբագրել կոդը]

  • Client - հայցող
  • Instance - նմուշ
  • Implementation - իրականացում
  • Product - արգասիք

Նկարագրություն[խմբագրել | խմբագրել կոդը]

Ադապտերն համատեղում է երկու տարբեր ինտերֆեյսները։ Ինտերֆեյսները կարող են լինել անհամատեղելի, բայց ներքին ֆունկցիանալությունը պետք է համապատասխանի պահանջներին։ Ադապտերը թույլ է տալիս անհամատեղելի ինտերֆեյսներով դասերը համատեղել և այն բերել հայցողի պահանջված ինտերֆեյսին։

Կառուցվածք[խմբագրել | խմբագրել կոդը]

Գոյություն ունի երկու ձևի Ադապտեր ձևանմուշ[1].

  • Օբյեկտ ադապտեր ձևանմուշ
  • Դաս ադապտեր ձևանմուշ

Օբյեկտ ադապտեր ձևանմուշ[խմբագրել | խմբագրել կոդը]

Այս մոդելի դեպքում ադապտերն իր մեջ որպես դասի նմուշ պարունակում է փոփոխման ենթակա ինտերֆեյսով դասը։ Այս դեպքում ֆունկցիաների կանչն իրականավում է նմուշի համապատասխան ֆունկցիան կանչելով։

Օբյեկտ ադապտեր ձևանմուշի UML դիագրամը: Ադապտերը թաքցնում է ադապտացված դասի ինտերֆեյսը հայցողից:

Դաս ադապտեր ձևանմուշ[խմբագրել | խմբագրել կոդը]

Այս տիպի ադապտերն օգտագործում է բազմակի պոլիֆորմ ինտերֆեյսների իրականացում կամ էլ ժառանգում է և՜ ադապտացնող դասը, և՜ ադապտացվողը։ Այսպիսով ստեղծվում է դաս միայն ինտերֆեյս ապահովելու համար։ Նման օրինակի ադապտերների օգտագործումը բնորոշ է այնպիսի ծրագրավորման լեզուներին, որոնք չեն ապահովում բազմակի ժառանգում (օրինակ Java)[1]։

Օբյեկտ ադապտեր ձևանմուշի UML դիագրամը

Օրինակներ[խմբագրել | խմբագրել կոդը]

C#[խմբագրել | խմբագրել կոդը]

 using System;
 
 namespace Adapter
 {
  
  class MainApp
  {
    static void Main()
    {
      // Create adapter and place a request
      Target target = new Adapter();
      target.Request();
 
      // Wait for user
      Console.Read();
    }
  }
 
  // "Target"
 
  class Target
  {
    public virtual void Request()
    {
      Console.WriteLine("Called Target Request()");
    }
  }
 
  // "Adapter"
 
  class Adapter : Target
  {
    private Adaptee adaptee = new Adaptee();
 
    public override void Request()
    {
      // Possibly do some other work
      // and then call SpecificRequest
      adaptee.SpecificRequest();
    }
  }
 
  // "Adaptee"
 
  class Adaptee
  {
    public void SpecificRequest()
    {
      Console.WriteLine("Called SpecificRequest()");
    }
  }
 }

Java (ժառանգման միջոցով)[խմբագրել | խմբագրել կոդը]

// Target
public interface Chief
{
  public Object makeBreakfast();
  public Object makeLunch();
  public Object makeDinner();
}

// Adaptee
public class Plumber
{
  public Object getScrewNut()
  { ... }
  public Object getPipe()
  { ... }
  public Object getGasket()
  { ... }
}

// Adapter
public class ChiefAdapter extends Plumber implements Chief
{
  public Object makeBreakfast()
  {
    return getGasket();
  }
  public Object makeLunch()
  {
    return getPipe();
  }
  public Object makeDinner()
  {
    return getScrewNut();
  }
}

// Client
public class Client
{
  public static void eat(Object dish)
  { ... }

  public static void main(String[] args)
  {
    Chief ch = new ChiefAdapter();
    Object dish = ch.makeBreakfast();
    eat(dish);
    dish = ch.makeLunch();
    eat(dish);
    dish = ch.makeDinner();
    eat(dish);
    callAmbulance();
  }
}

Java (կոմպոզիցիայի միջոցով)[խմբագրել | խմբագրել կոդը]

// Ֆայլ Chief.java

public interface Chief {

	public Object makeBreakfast();
	public Object makeDinner();
	public Object makeSupper();
	
}

// Ֆայլ Plumber.java

public class Plumber {

	public Object getPipe(){
		return new Object();
	}
	
	public Object getKey(){
		return new Object();
	}
	
	public Object getScrewDriver(){
		return new Object();
	}
	
}

// Ֆայլ ChiefAdapter.java

public class ChiefAdapter implements Chief{

	private Plumber plumber = new Plumber();

	@Override
	public Object makeBreakfast() {
		return plumber.getKey();
	}

	@Override
	public Object makeDinner() {
		return plumber.getScrewDriver();
	}

	@Override
	public Object makeSupper() {
		return plumber.getPipe();
	}

}

// Ֆայլ Client.java

public class Client {

	public static void main (String [] args){
		Chief chief = new ChiefAdapter();
		
		Object key = chief.makeDinner();
	}
	
}

Ծանոթագրություններ[խմբագրել | խմբագրել կոդը]

  1. 1,0 1,1 Freeman Eric, Freeman Elisabeth, Kathy Sierra, Bates Bert (2004)։ «Head First Design Patterns» (paperback)։ O'Reilly Media։ էջ 244։ ISBN 978-0-596-00712-6։ OCLC 809772256։ Վերցված է ապրիլի 30, 2013