جاوا ۾ ڊيزائن جا نمونا

نمونن يا ڊيزائن جا نمونا ڊولپر جي نوڪري جو اڪثر نظر انداز ٿيل حصو آهن، ڪوڊ کي برقرار رکڻ ۽ نئين گهرجن کي ترتيب ڏيڻ ڏکيو آهي. مان توهان کي صلاح ڏيان ٿو ته اهو ڇا آهي ۽ اهو JDK ۾ ڪيئن استعمال ٿيندو آهي. قدرتي طور تي، سڀني بنيادي نمونن هڪ شڪل يا ٻئي ۾ هڪ ڊگهي وقت تائين اسان جي چوڌاري آهن. اچو ته انهن کي هن جائزي ۾ ڏسو. مواد:

• ٽيمپليٽس
• تخليقي نمونو
• ساخت جا نمونا
• رويي جا نمونا
• نتيجو

ٽيمپليٽس

خالي جاين ۾ سڀ کان وڌيڪ عام ضرورتن مان هڪ آهي ”معلومات جو علم“. سڀ کان پهريان، اهو هڪ سادي سوال جو جواب ڏيڻ جي قابل آهي - "ڊيزائن جو نمونو ڇا آهي؟" پيٽرن کي انگريزيءَ مان ترجمو ڪيو ويو آهي “template”. اهو آهي، اهو هڪ خاص نمونو آهي جنهن جي مطابق اسان ڪجهه ڪندا آهيون. ساڳيو پروگرامنگ ۾ سچ آهي. عام مسئلا حل ڪرڻ لاءِ ڪي قائم ڪيل بهترين طريقا ۽ طريقا آهن. هر پروگرامر هڪ معمار آهي. ايستائين جو جڏهن توهان صرف چند ڪلاس يا هڪ به ٺاهيندا آهيو، اهو توهان تي منحصر هوندو آهي ته ڪوڊ ڪيتري وقت تائين زنده رهي سگهي ٿو تبديلين جي ضرورتن تحت، اهو ٻين لاءِ استعمال ڪرڻ ڪيترو آسان آهي. ۽ هي آهي جتي ٽيمپليٽس جي ڄاڻ مدد ڪندي، ڇاڪاڻ ته ... اهو توهان کي جلدي سمجهڻ جي اجازت ڏيندو ته ڪوڊ کي ٻيهر لکڻ کان سواءِ ڪيئن لکجي. جئين توهان کي خبر آهي، پروگرامر سست ماڻهو آهن ۽ اهو آسان آهي ته ڪجهه صحيح طور تي لکڻ لاء ان کي ڪيترائي ڀيرا ٻيهر ڪرڻ جي ڀيٽ ۾) نمونن کي شايد الگورتھم سان ملندڙ جلندڙ نظر اچن ٿا. پر انهن ۾ هڪ فرق آهي. الورورٿم مخصوص مرحلن تي مشتمل آهي جيڪي ضروري ڪارناما بيان ڪن ٿا. نمونن صرف طريقي جي وضاحت ڪن ٿا، پر عمل درآمد جي مرحلن کي بيان نه ڪندا آھن. نمونا مختلف آهن، ڇاڪاڻ ته ... مختلف مسئلا حل ڪرڻ. عام طور تي هيٺين قسمن ۾ فرق آهي:

• پيدا ڪندڙ

  اهي نمونا اعتراض جي تخليق کي لچڪدار بڻائڻ جو مسئلو حل ڪن ٿا

• ساخت وارو

  اهي نمونا شيون جي وچ ۾ رابطي جي تعمير جو مسئلو حل ڪن ٿا

• رويي وارو

  اهي نمونا شيون جي وچ ۾ موثر رابطي جو مسئلو حل ڪن ٿا

مثالن تي غور ڪرڻ لاءِ، مان آن لائن ڪوڊ گڏ ڪرڻ وارو repl.it استعمال ڪرڻ جي صلاح ڏيان ٿو.

تخليقي نمونو

اچو ته شين جي زندگي جي چڪر جي شروعات کان شروع ڪريون - شين جي تخليق سان. تخليقي ٽيمپليٽ شيون وڌيڪ آساني سان ٺاهڻ ۾ مدد ڪن ٿيون ۽ هن عمل ۾ لچڪ فراهم ڪن ٿيون. سڀ کان مشهور مان هڪ آهي " بلڊر ". هي نمونو توهان کي پيچيده شيون ٺاهڻ جي اجازت ڏئي ٿو قدم قدم سان. جاوا ۾، سڀ کان وڌيڪ مشهور مثال آهي StringBuilder:

class Main {
  public static void main(String[] args) {
    StringBuilder builder = new StringBuilder();
    builder.append("Hello");
    builder.append(',');
    builder.append("World!");
    System.out.println(builder.toString());
  }
}

هڪ شئي ٺاهڻ لاءِ هڪ ٻيو مشهور طريقو اهو آهي ته تخليق کي الڳ طريقي سان منتقل ڪيو وڃي. اهو طريقو بڻجي ويو، جيئن ته هو، هڪ اعتراض ڪارخانو. اهو ڇو ته نمونو سڏيو ويندو آهي " فیکٹري جو طريقو". جاوا ۾، مثال طور، ان جو اثر ڪلاس ۾ ڏسي سگھجي ٿو java.util.Calendar. طبقو خود Calendarخلاصو آهي، ۽ ان کي ٺاهڻ لاءِ طريقو استعمال ڪيو ويندو آهي getInstance:

import java.util.*;
class Main {
  public static void main(String[] args) {
    Calendar calendar = Calendar.getInstance();
    System.out.println(calendar.getTime());
    System.out.println(calendar.getClass().getCanonicalName());
  }
}

اهو اڪثر ڪري ٿو ڇاڪاڻ ته اعتراض جي تخليق جي پويان منطق پيچيده ٿي سگهي ٿي. مثال طور، مٿين صورت ۾، اسان بنيادي طبقي تائين رسائي حاصل ڪندا آهيون Calendar، ۽ هڪ ڪلاس ٺهيل آهي GregorianCalendar. جيڪڏهن اسان ڪنسٽرڪٽر تي نظر وجهون ٿا، اسان ڏسي سگهون ٿا ته حالتن جي لحاظ سان مختلف عمل پيدا ڪيا ويا آهن Calendar. پر ڪڏهن ڪڏهن هڪ ڪارخاني جو طريقو ڪافي نه آهي. ڪڏهن ڪڏهن توهان کي مختلف شيون ٺاهڻ جي ضرورت آهي ته جيئن اهي گڏ هجن. هڪ ٻيو ٽيمپليٽ اسان کي هن سان مدد ڪندي - " خلاصي ڪارخانو ". ۽ پوء اسان کي هڪ جاء تي مختلف ڪارخانا ٺاهڻ جي ضرورت آهي. ساڳئي وقت، فائدو اهو آهي ته عملدرآمد تفصيلات اسان لاء اهم نه آهن، يعني. اهو مسئلو ناهي ته اسان کي ڪهڙي مخصوص ڪارخاني ملي ٿي. بنيادي شيء اها آهي ته اهو صحيح عمل ٺاهي ٿو. سپر مثال: اهو آهي، ماحول (آپريٽنگ سسٽم) تي منحصر ڪري، اسان هڪ خاص ڪارخانو حاصل ڪنداسين جيڪو مطابقت رکندڙ عناصر پيدا ڪندو. ڪنهن ٻئي جي ذريعي پيدا ڪرڻ جي طريقي جي متبادل جي طور تي، اسان استعمال ڪري سگهون ٿا " پروٽوٽائپ " نموني. ان جو جوهر سادو آهي - نئين شين جي تصوير ۾ ٺاهيا ويا آهن ۽ اڳ ۾ موجود شين جي مشابهت، يعني. سندن prototype موجب. جاوا ۾، هرڪو هن نموني ۾ آيو آهي - هي هڪ انٽرفيس جو استعمال آهي java.lang.Cloneable:

class Main {
  public static void main(String[] args) {
    class CloneObject implements Cloneable {
      @Override
      protected Object clone() throws CloneNotSupportedException {
        return new CloneObject();
      }
    }
    CloneObject obj = new CloneObject();
    try {
      CloneObject pattern = (CloneObject) obj.clone();
    } catch (CloneNotSupportedException e) {
      //Do something
    }
  }
}

جئين توهان ڏسي سگهو ٿا، ڪالر کي خبر ناهي ته ڪيئن clone. اهو آهي، هڪ پروٽوٽائپ جي بنياد تي هڪ اعتراض ٺاهڻ خود اعتراض جي ذميواري آهي. هي ڪارائتو آهي ڇو ته اهو استعمال ڪندڙ کي ٽيمپليٽ اعتراض جي عمل درآمد سان ڳنڍي نه ٿو. خير، هن فهرست تي تمام آخري هڪ آهي "سنگلٽن" نمونو. ان جو مقصد سادو آهي - سڄي ايپليڪيشن لاءِ هڪ شئي جو هڪ مثال مهيا ڪرڻ. اهو نمونو دلچسپ آهي ڇاڪاڻ ته اهو اڪثر ڪري ڏيکاري ٿو گھڻائي واري مسئلن کي. وڌيڪ تفصيلي نظر لاءِ، ڏسو هي مضمون:

• " جاوا ۾ سنگلٽن کي درست ڪريو "
• " جاوا ۾ سنگلٽن عملدرآمد "
• " سنگلٽن جو نمونو "

ساخت جا نمونا

شين جي تخليق سان اهو واضح ٿي ويو. هاڻي وقت آهي ساخت جي نمونن کي ڏسڻ لاء. انهن جو مقصد آسان سهولتن واري طبقي جي درجي بندي ۽ انهن جي رشتن کي تعمير ڪرڻ آهي. پهرين ۽ معروف نمونن مان هڪ آهي “ ڊپٽي ” (Proxy). پراکسي وٽ ساڳيو انٽرفيس آهي حقيقي اعتراض جيان، تنهن ڪري اهو ڪو فرق نٿو پوي ته ڪلائنٽ کي پراکسي ذريعي ڪم ڪرڻ يا سڌو سنئون. سادو مثال آهي java.lang.reflect.Proxy :

import java.util.*;
import java.lang.reflect.*;
class Main {
  public static void main(String[] arguments) {
    final Map<String, String> original = new HashMap<>();
    InvocationHandler proxy = (obj, method, args) -> {
      System.out.println("Invoked: " + method.getName());
      return method.invoke(original, args);
    };
    Map<String, String> proxyInstance = (Map) Proxy.newProxyInstance(
        original.getClass().getClassLoader(),
        original.getClass().getInterfaces(),
        proxy);
    proxyInstance.put("key", "value");
    System.out.println(proxyInstance.get("key"));
  }
}

جئين توھان ڏسي سگھو ٿا، مثال ۾ اسان وٽ اصل آھي - اھو اھو آھي HashMapجيڪو انٽرفيس کي لاڳو ڪري ٿو Map. اسان اڳتي هلي هڪ پراڪسي ٺاهيندا آهيون جيڪا اصل هڪ کي بدلائي HashMapکلائنٽ جي حصي لاءِ، جيڪو ڪال ڪري ٿو put۽ طريقا get، ڪال دوران اسان جي پنهنجي منطق کي شامل ڪندي. جيئن اسان ڏسي سگهون ٿا، نموني ۾ رابطي انٽرفيس ذريعي ٿيندي آهي. پر ڪڏهن ڪڏهن هڪ متبادل ڪافي نه آهي. ۽ پوءِ ” ڊيڪاريٽر “ جو نمونو استعمال ڪري سگھجي ٿو. سجاڳيءَ کي به چادر يا چادر چئبو آهي. Proxy ۽ decorator بلڪل هڪجهڙا آهن، پر جيڪڏهن توهان مثال کي ڏسو، توهان کي فرق نظر ايندو:

import java.util.*;
class Main {
  public static void main(String[] arguments) {
    List<String> list = new ArrayList<>();
    List<String> decorated = Collections.checkedList(list, String.class);
    decorated.add("2");
    list.add("3");
    System.out.println(decorated);
  }
}

هڪ پراکسي جي برعڪس، هڪ سينگار پاڻ کي ڪنهن شيء جي چوڌاري لپي ٿو جيڪو ان پٽ جي طور تي گذري ٿو. هڪ پراڪسي ٻنهي کي قبول ڪري سگهي ٿو جيڪو پراڪس ٿيڻ جي ضرورت آهي ۽ پراڪس ٿيل اعتراض جي زندگي کي پڻ منظم ڪري سگهي ٿو (مثال طور، هڪ پراڪس ٿيل اعتراض ٺاهيو). اتي هڪ ٻيو دلچسپ نمونو آهي - " اڊاپٽر ". اهو سجاڳيءَ سان ملندڙ جلندڙ آهي - سجاڳيءَ هڪ شئي کي انپٽ طور وٺي ٿو ۽ هن اعتراض جي مٿان هڪ لفافي موٽائي ٿو. فرق اهو آهي ته مقصد ڪارڪردگي کي تبديل ڪرڻ نه آهي، پر هڪ انٽرفيس کي ٻئي کي ترتيب ڏيڻ لاء. جاوا هن جو هڪ تمام واضح مثال آهي:

import java.util.*;
class Main {
  public static void main(String[] arguments) {
    String[] array = {"One", "Two", "Three"};
    List<String> strings = Arrays.asList(array);
    strings.set(0, "1");
    System.out.println(Arrays.toString(array));
  }
}

ان پٽ تي اسان وٽ هڪ صف آهي. اڳيون اسان ھڪڙو اڊاپٽر ٺاھيو آھي جيڪو صف کي انٽرفيس ڏانھن آڻيندو آھي List. جڏهن ان سان ڪم ڪري رهيا آهيون، اسان اصل ۾ هڪ صف سان ڪم ڪري رهيا آهيون. تنهن ڪري، عناصر شامل ڪرڻ ڪم نه ڪندو، ڇاڪاڻ ته ... اصل صف تبديل نه ٿي ڪري سگھجي. ۽ انهي صورت ۾ اسان حاصل ڪنداسين UnsupportedOperationException. طبقاتي ڍانچي کي ترقي ڪرڻ لاءِ ايندڙ دلچسپ طريقو جامع نمونو آهي . اهو دلچسپ آهي ته عناصر جو هڪ مخصوص سيٽ هڪ انٽرفيس استعمال ڪندي هڪ خاص وڻ وانگر ترتيب ڏنل آهي. والدين عنصر تي هڪ طريقو سڏڻ سان، اسان سڀني ضروري ٻار عناصر تي هن طريقي کي ڪال حاصل ڪندا آهيون. ھن نموني جو ھڪڙو وڏو مثال UI آھي (اھو java.awt يا JSF):

import java.awt.*;
class Main {
  public static void main(String[] arguments) {
    Container container = new Container();
    Component component = new java.awt.Component(){};
    System.out.println(component.getComponentOrientation().isLeftToRight());
    container.add(component);
    container.applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
    System.out.println(component.getComponentOrientation().isLeftToRight());
  }
}

جيئن اسان ڏسي سگهون ٿا، اسان ڪنٽينر ۾ هڪ جزو شامل ڪيو آهي. ۽ پوء اسان ڪنٽينر کان پڇيو ته اجزاء جي نئين تعارف کي لاڳو ڪرڻ لاء. ۽ ڪنٽينر، ڄاڻو ته ان ۾ ڪھڙا حصا شامل آھن، ھن حڪم جي عمل کي سڀني ٻارن جي اجزاء کي سونپيو. ٻيو دلچسپ نمونو آهي " پل " نموني. ان کي سڏيو ويندو آهي ڇاڪاڻ ته اهو ٻن مختلف طبقن جي درجه بندي جي وچ ۾ ڪنيڪشن يا پل کي بيان ڪري ٿو. انهن درجي بندين مان هڪ کي تجريد ۽ ٻيو عمل درآمد سمجهيو ويندو آهي. اهو نمايان ڪيو ويو آهي ڇو ته تجريد خود ڪارناما انجام نه ڏيندو آهي، پر هن عمل کي عمل درآمد جي نمائندگي ڪري ٿو. اهو نمونو اڪثر استعمال ڪيو ويندو آهي جڏهن اتي "ڪنٽرول" ڪلاس ۽ "پليٽ فارم" طبقن جا ڪيترائي قسم آهن (مثال طور، ونڊوز، لينڪس، وغيره). هن طريقي سان، انهن مان هڪ hierarchy (Abstraction) هڪ ٻئي جي درجه بندي (تطبيق) جي شين جو حوالو حاصل ڪندو ۽ انهن کي مکيه ڪم جي نمائندگي ڪندو. ڇاڪاڻ ته سڀئي عمل هڪ عام انٽرفيس جي پيروي ڪندا، انهن کي تجزيه ۾ تبديل ڪري سگهجي ٿو. جاوا ۾، هن جو هڪ واضح مثال آهي java.awt: وڌيڪ معلومات لاءِ، ڏسو مضمون " Patterns in Java AWT ". ساخت جي نمونن جي وچ ۾، مان پڻ نوٽ ڪرڻ چاهيندس " Facade " نموني. ان جو جوهر اهو آهي ته لائبريرين/ فريم ورڪ کي استعمال ڪرڻ جي پيچيدگي کي هن API جي پويان هڪ آسان ۽ جامع انٽرفيس جي پويان. مثال طور، توھان استعمال ڪري سگھو ٿا JSF يا EntityManager JPA کان مثال طور. اتي پڻ هڪ ٻيو نمونو آهي جنهن کي " فلائي وزن " سڏيو ويندو آهي. ان جو خلاصو اهو آهي ته جيڪڏهن مختلف شيون هڪ ئي حالت ۾ آهن، ته پوء ان کي عام ڪري سگهجي ٿو ۽ هر شئي ۾ نه، پر هڪ جاء تي. ۽ پوءِ هر شئي هڪ عام حصو حوالي ڪرڻ جي قابل ٿي ويندي، جيڪا ذخيري لاءِ ياداشت جي قيمت گھٽائي ويندي. اهو نمونو اڪثر ڪري اڳ-ڪيشنگ يا شين جي تلاء کي برقرار رکڻ ۾ شامل آهي. دلچسپ ڳالهه اها آهي ته اسان هن نموني کي شروعات کان ڄاڻون ٿا: ساڳئي قياس ذريعي، تارن جو هڪ تلاء هتي شامل ڪري سگهجي ٿو. توهان هن موضوع تي مضمون پڙهي سگهو ٿا: " فلائي ويٽ ڊيزائن جو نمونو ".

رويي جا نمونا

تنهن ڪري، اسان اهو معلوم ڪيو ته شيون ڪيئن ٺاهي سگھجن ٿيون ۽ ڪئين طبقن جي وچ ۾ ڪنيڪشن کي منظم ڪري سگهجي ٿو. سڀ کان وڌيڪ دلچسپ شيء ڇڏي ويو آهي شيون جي رويي کي تبديل ڪرڻ ۾ لچڪ فراهم ڪرڻ. ۽ رويي جي نمونن اسان کي هن سان مدد ڪندي. سڀ کان وڌيڪ ذڪر ڪيل نمونن مان هڪ آهي " حڪمت " جو نمونو. هي اهو آهي جتان ڪتاب ۾ نمونن جو مطالعو شروع ٿئي ٿو “ Head First. Design Patterns ”. "حڪمت" جي نموني کي استعمال ڪندي، اسان هڪ اعتراض جي اندر ذخيرو ڪري سگهون ٿا ته اسان ڪيئن عمل ڪنداسين، يعني. اعتراض اندر ذخيرو هڪ حڪمت عملي آهي جيڪا ڪوڊ جي عمل دوران تبديل ٿي سگهي ٿي. هي هڪ نمونو آهي جيڪو اسين اڪثر استعمال ڪندا آهيون جڏهن هڪ موازنہ استعمال ڪندي:

import java.util.*;
class Main {
  public static void main(String[] args) {
    List<String> data = Arrays.asList("Moscow", "Paris", "NYC");
    Comparator<String> comparator = Comparator.comparingInt(String::length);
    Set dataSet = new TreeSet(comparator);
    dataSet.addAll(data);
    System.out.println("Dataset : " + dataSet);
  }
}

اسان جي اڳيان - TreeSet. TreeSetان ۾ عناصر جي ترتيب کي برقرار رکڻ جو رويو آهي ، يعني. انهن کي ترتيب ڏئي ٿو (جيئن ته اهو هڪ ترتيب ڏنل سيٽ آهي). ھن رويي ۾ ھڪڙي ڊفالٽ حڪمت عملي آھي، جيڪا اسان جاوا ڊڪ ۾ ڏسون ٿا: "قدرتي ترتيب" ۾ ترتيب ڏيڻ (اسٽرنگ لاء، ھي لغتي ترتيب آھي). اهو ٿئي ٿو جيڪڏهن توهان استعمال ڪريو هڪ parameterless تعمير ڪندڙ. پر جيڪڏهن اسان حڪمت عملي کي تبديل ڪرڻ چاهيون ٿا، اسان پاس ڪري سگهون ٿا Comparator. ھن مثال ۾، اسان پنھنجي سيٽ کي ٺاھي سگھون ٿا new TreeSet(comparator)، ۽ پوء عناصر کي ذخيرو ڪرڻ جو حڪم (اسٽوريج جي حڪمت عملي) ھڪڙي کي تبديل ڪيو ويندو جيڪو موازنہ ۾ بيان ڪيو ويو آھي. دلچسپ ڳالهه اها آهي ته اتي لڳ ڀڳ ساڳيو نمونو آهي جنهن کي " رياست " سڏيو ويندو آهي. ”رياست“ جو نمونو چوي ٿو ته جيڪڏهن اسان وٽ مکيه شئي ۾ ڪو اهڙو رويو آهي جيڪو ان شئي جي حالت تي دارومدار رکي ٿو، ته پوءِ اسين رياست کي خود هڪ شئي طور بيان ڪري سگھون ٿا ۽ رياست جي شئي کي تبديل ڪري سگهون ٿا. ۽ نمائندو ڪالون مکيه اعتراض کان رياست ڏانهن. هڪ ٻيو نمونو جيڪو اسان کي جاوا ٻولي جي بنيادي ڳالهين جي مطالعي مان معلوم ٿئي ٿو اهو آهي " ڪمانڊ " نمونو. هي ڊزائن جو نمونو ڏيکاري ٿو ته مختلف حڪمن کي مختلف طبقن جي نمائندگي ڪري سگهجي ٿو. هي نمونو حڪمت عملي جي نموني سان بلڪل ملندڙ جلندڙ آهي. پر حڪمت عملي جي نموني ۾، اسان ٻيهر بيان ڪري رهيا هئاسين ته هڪ مخصوص عمل ڪيئن ڪيو ويندو (مثال طور، ترتيب ڏيڻ ۾ TreeSet). "ڪمانڊ" جي نموني ۾، اسان ٻيهر بيان ڪريون ٿا ته ڪهڙو عمل ڪيو ويندو. نموني حڪم اسان سان گڏ آهي هر روز جڏهن اسان موضوعن کي استعمال ڪندا آهيون:

import java.util.*;
class Main {
  public static void main(String[] args) {
    Runnable command = () -> {
      System.out.println("Command action");
    };
    Thread th = new Thread(command);
    th.start();
  }
}

جئين توھان ڏسي سگھو ٿا، حڪم ھڪڙي عمل يا حڪم کي بيان ڪري ٿو جيڪو ھڪڙي نئين سلسلي ۾ عمل ڪيو ويندو. اهو پڻ غور ڪرڻ جي قابل آهي " ذميواري جو سلسلو " نموني. اهو نمونو پڻ تمام سادو آهي. اهو نمونو چوي ٿو ته جيڪڏهن ڪجهه عمل ڪرڻ جي ضرورت آهي، ته پوء توهان هڪ زنجير ۾ هٿيار گڏ ڪري سگهو ٿا. مثال طور، هي نمونو اڪثر ڪري ويب سرورز ۾ استعمال ٿيندو آهي. ان پٽ تي، سرور کي صارف کان ڪجهه درخواست آهي. اها درخواست وري پروسيسنگ زنجير ذريعي وڃي ٿي. هينڊلر جي هن زنجير ۾ فلٽر شامل آهن (مثال طور، IP پتي جي بليڪ لسٽ مان درخواستون قبول نه ڪريو)، تصديق ڪندڙ هينڊلر (صرف بااختيار استعمال ڪندڙن کي اجازت ڏيو)، هڪ درخواست هيڊر هينڊلر، ڪيشنگ هينڊلر، وغيره. پر جاوا ۾ ھڪڙو آسان ۽ وڌيڪ سمجھڻ وارو مثال آھي java.util.logging:

import java.util.logging.*;
class Main {
  public static void main(String[] args) {
    Logger logger = Logger.getLogger(Main.class.getName());
    ConsoleHandler consoleHandler = new ConsoleHandler(){
		@Override
            public void publish(LogRecord record) {
                System.out.println("LogRecord обработан");
            }
        };
    logger.addHandler(consoleHandler);
    logger.info("test");
  }
}

جئين توهان ڏسي سگهو ٿا، هينڊلر شامل ڪيا ويا آهن لاگر هينڊلر جي لسٽ ۾. جڏهن هڪ لاگر پروسيسنگ لاءِ هڪ پيغام وصول ڪري ٿو، هر هڪ اهڙو پيغام ان لاگر لاءِ هينڊلر جي زنجير مان گذري ٿو logger.getHandlers. هڪ ٻيو نمونو جيڪو اسان هر روز ڏسندا آهيون اهو آهي “ Iterator ”. ان جو جوهر اهو آهي ته شين جي مجموعن کي الڳ ڪرڻ (يعني هڪ ڪلاس جيڪو ڊيٽا جي ڍانچي جي نمائندگي ڪري ٿو. مثال طور، List) ۽ هن مجموعن جي ٽرورسل.

import java.util.*;
class Main {
  public static void main(String[] args) {
    List<String> data = Arrays.asList("Moscow", "Paris", "NYC");
    Iterator<String> iterator = data.iterator();
    while (iterator.hasNext()) {
      System.out.println(iterator.next());
    }
  }
}

جئين توهان ڏسي سگهو ٿا، آئٽرٽر گڏ ڪرڻ جو حصو نه آهي، پر هڪ الڳ طبقي جي نمائندگي ڪئي وئي آهي جيڪا گڏ ڪري ٿو. آئيٽرٽر جي استعمال ڪندڙ کي شايد اها به خبر نه هجي ته اهو ڪهڙو مجموعو ٻيهر ورجائي رهيو آهي، يعني. هو ڪهڙو مجموعو ڏسي رهيو آهي؟ گهمڻ وارو نمونو پڻ غور ڪرڻ جي قابل آهي . گهمڻ وارو نمونو تمام گهڻو ملندڙ جلندڙ آهي. هي نمونو توهان کي شين جي جوڙجڪ کي نظرانداز ڪرڻ ۽ انهن شين تي عمل ڪرڻ ۾ مدد ڪري ٿو. اهي تصور ۾ بلڪل مختلف آهن. آئٽرٽر ڪليڪشن کي پار ڪري ٿو ته جيئن ڪلائنٽ استعمال ڪري رهيو آهي آئٽرٽر کي پرواه ناهي ته مجموعو اندر ڇا آهي، صرف تسلسل ۾ عناصر اهم آهن. گهمڻ جو مطلب اهو آهي ته اسان جي دورو ڪرڻ واري شين جي هڪ خاص ترتيب يا جوڙجڪ آهي. مثال طور، اسان استعمال ڪري سگھون ٿا الڳ ڊاريڪٽري پروسيسنگ ۽ الڳ فائل پروسيسنگ. جاوا ۾ هن نموني جي باڪس کان ٻاهر عمل درآمد فارم ۾ آهي java.nio.file.FileVisitor:

import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.*;
class Main {
  public static void main(String[] args) {
    SimpleFileVisitor visitor = new SimpleFileVisitor() {
      @Override
      public FileVisitResult visitFile(Object file, BasicFileAttributes attrs) throws IOException {
        System.out.println("File:" + file.toString());
        return FileVisitResult.CONTINUE;
      }
    };
    Path pathSource = Paths.get(System.getProperty("java.io.tmpdir"));
    try {
      Files.walkFileTree(pathSource, visitor);
    } catch (AccessDeniedException e) {
      // skip
    } catch (IOException e) {
      // Do something
    }
  }
}

ڪڏهن ڪڏهن ضرورت پوندي آهي ته ڪجهه شيون ٻين شين ۾ تبديلين تي رد عمل ظاهر ڪن، ۽ پوءِ ”مبصر“ نمونو اسان جي مدد ڪندو . سڀ کان وڌيڪ آسان طريقو آهي هڪ سبسڪرپشن ميڪانيزم مهيا ڪرڻ جيڪو ڪجهه شين کي مانيٽر ڪرڻ ۽ ٻين شين ۾ واقع ٿيندڙ واقعن جو جواب ڏيڻ جي اجازت ڏئي ٿو. اهو نمونو اڪثر ڪري مختلف ٻڌندڙن ۽ مبصرن ۾ استعمال ٿيندو آهي جيڪي مختلف واقعن تي رد عمل ڪندا آهن. هڪ سادي مثال طور، اسان JDK جي پهرين ورزن مان هن نموني جي عمل کي ياد ڪري سگهون ٿا:

import java.util.*;
class Main {
  public static void main(String[] args) {
    Observer observer = (obj, arg) -> {
      System.out.println("Arg: " + arg);
    };
    Observable target = new Observable(){
      @Override
      public void notifyObservers(Object arg) {
        setChanged();
        super.notifyObservers(arg);
      }
    };
    target.addObserver(observer);
    target.notifyObservers("Hello, World!");
  }
}

ھڪڙو ٻيو مفيد رويي جو نمونو آھي - " ثالث ". اهو مفيد آهي ڇاڪاڻ ته پيچيده سسٽم ۾ اهو مختلف شين جي وچ ۾ ڪنيڪشن کي هٽائڻ ۾ مدد ڪري ٿو ۽ سڀني شين جي وچ ۾ ڪنهن شئي جي وچ ۾ رابطي جي نمائندگي ڪري ٿو، جيڪو هڪ وچولي آهي. هن نموني جي سڀ کان وڌيڪ نمايان ايپليڪيشنن مان هڪ بهار MVC آهي، جيڪو هن نموني کي استعمال ڪري ٿو. توھان ھن بابت وڌيڪ پڙھي سگھوٿا ھتي: " بهار: ثالث جو نمونو ". توهان اڪثر مثالن ۾ ساڳيو ڏسي سگهو ٿا java.util.Timer:

import java.util.*;
class Main {
  public static void main(String[] args) {
    Timer mediator = new Timer("Mediator");
    TimerTask command = new TimerTask() {
      @Override
      public void run() {
        System.out.println("Command pattern");
        mediator.cancel();
      }
    };
    mediator.schedule(command, 1000);
  }
}

مثال هڪ حڪم جي نموني وانگر وڌيڪ ڏسڻ ۾ اچي ٿو. ۽ ”ثالث“ جي نموني جو مادو Timer’الف‘ جي نفاذ ۾ لڪيل آهي. ٽائمر جي اندر هڪ ڪم جي قطار آهي TaskQueue، اتي هڪ موضوع آهي TimerThread. اسان، هن طبقي جي گراهڪ جي حيثيت ۾، انهن سان لهه وچڙ نه ڪندا آهيون، پر Timerاعتراض سان لهه وچڙ ۾، جيڪو، اسان جي سڏ جي جواب ۾، ان جي طريقن کي، ٻين شين جي طريقن تائين رسائي ڪري ٿو، جن مان اهو هڪ وچولي آهي. خارجي طور تي "Facade" سان بلڪل ملندڙ جلندڙ ٿي سگهي ٿو. پر فرق اهو آهي ته جڏهن هڪ Facade استعمال ڪيو ويندو آهي، اجزاء کي خبر ناهي ته منهن موجود آهي ۽ هڪ ٻئي سان ڳالهايو. ۽ جڏهن "ثالث" استعمال ڪيو ويندو آهي، اجزاء ڄاڻندا آهن ۽ وچولي استعمال ڪندا آهن، پر هڪ ٻئي سان سڌو رابطو نه ڪندا آهن. اهو غور ڪرڻ لائق آهي ته ” ٽيمپليٽ جو طريقو “ نمونو، نمونو ان جي نالي مان واضح آهي. هيٺئين لائن اها آهي ته ڪوڊ هن طرح لکيو ويو آهي ته ڪوڊ جي استعمال ڪندڙن (ڊولپرز) کي ڪجهه الگورتھم ٽيمپليٽ سان مهيا ڪيو ويو آهي، جن جي مرحلن کي ٻيهر بيان ڪرڻ جي اجازت ڏني وئي آهي. هي ڪوڊ استعمال ڪندڙن کي اجازت ڏئي ٿو ته اهي پوري الگورٿم کي نه لکن، پر صرف اهو سوچڻ لاءِ ته هن الورورٿم جو هڪ يا ٻيو مرحلو صحيح طريقي سان ڪيئن ڪجي. مثال طور، جاوا وٽ هڪ خلاصو طبقو آهي AbstractListجيڪو بيان ڪري ٿو هڪ آئٽرٽر جي رويي کي List. بهرحال، آئٽرٽر پاڻ پتي جا طريقا استعمال ڪندو آهي جهڙوڪ: get, set, remove. انهن طريقن جو رويو اولاد جي ڊولپر طرفان طئي ڪيو ويندو آهي AbstractList. اهڙيء طرح، iterator in AbstractList- هڪ شيٽ تي ٻيهر ڪرڻ لاء الگورتھم لاء هڪ ٽيمپليٽ آهي. ۽ مخصوص عملن جي ڊولپرز کي AbstractListمخصوص قدمن جي رويي جي وضاحت ڪندي هن تکرار جي رويي کي تبديل ڪري ٿو. آخري نمونن جو اسان تجزيو ڪريون ٿا " سنيپ شاٽ " (Momento) نمونو. ان جو جوهر اهو آهي ته ڪنهن شئي جي هڪ خاص حالت کي محفوظ ڪرڻ جي صلاحيت سان هن رياست کي بحال ڪرڻ جي صلاحيت سان. JDK مان سڀ کان وڌيڪ تسليم ٿيل مثال اعتراض سيريلائيزيشن آهي، يعني. java.io.Serializable. اچو ته هڪ مثال ڏسو:

import java.io.*;
import java.util.*;
class Main {
  public static void main(String[] args) throws IOException {
    ArrayList<String> list = new ArrayList<>();
    list.add("test");
    // Save State
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    try (ObjectOutputStream out = new ObjectOutputStream(stream)) {
      out.writeObject(list);
    }
    // Load state
    byte[] bytes = stream.toByteArray();
    InputStream inputStream = new ByteArrayInputStream(bytes);
    try (ObjectInputStream in = new ObjectInputStream(inputStream)) {
      List<String> listNew = (List<String>) in.readObject();
      System.out.println(listNew.get(0));
    } catch (ClassNotFoundException e) {
      // Do something. Can't find class fpr saved state
    }
  }
}

نتيجو

جيئن ته اسان جائزو کان ڏٺو، نمونن جي هڪ وڏي قسم آهن. انهن مان هر هڪ پنهنجو مسئلو حل ڪري ٿو. ۽ انهن نمونن جي ڄاڻ توهان کي وقت ۾ سمجهڻ ۾ مدد ڪري سگهي ٿي ته توهان جو سسٽم ڪيئن لکجي ته جيئن اهو لچڪدار، برقرار رکڻ ۽ تبديلي جي مزاحمتي هجي. ۽ آخرڪار، ڪجهه ڳنڍيون هڪ گہرے غوطه لاء:

• نمونن لاءِ سڀ کان وڌيڪ حيرت انگيز وسيلو: refactoring.guru
• وڊيو پبليڪيشن " آبجیکٹ اورينٽيڊ پروگرامنگ ۾ ڊيزائن جا نمونا "
• ڊيزائن پيٽرن جي مشق
• نموني ٽيسٽ
• Udemy تي نموني ڪورس
• Coursera تي نمونن جو ڪورس

#وياچسلاو