Shablonlar
Bo'sh ish o'rinlaridagi eng keng tarqalgan talablardan biri bu "Naqshlarni bilish". Avvalo, oddiy savolga javob berishga arziydi - "Dizayn namunasi nima?" Pattern ingliz tilidan "shablon" deb tarjima qilingan. Ya'ni, bu ma'lum bir naqsh bo'lib, unga ko'ra biz biror narsa qilamiz. Dasturlashda ham xuddi shunday. Umumiy muammolarni hal qilish uchun ba'zi o'rnatilgan eng yaxshi amaliyotlar va yondashuvlar mavjud. Har bir dasturchi arxitektordir. Hatto bir nechta sinflarni yoki hatto bittasini yaratganingizda ham, o'zgaruvchan talablar ostida kod qancha vaqt saqlanib qolishi, boshqalar tomonidan foydalanish qanchalik qulayligi sizga bog'liq. Bu erda shablonlarni bilish yordam beradi, chunki... Bu sizga kodni qayta yozmasdan qanday qilib eng yaxshi yozishni tezda tushunish imkonini beradi. Ma'lumki, dasturchilar dangasa odamlardir va uni bir necha marta takrorlashdan ko'ra darhol yaxshi yozish osonroq) Naqshlar ham algoritmlarga o'xshab ko'rinishi mumkin. Lekin ularning farqi bor. Algoritm kerakli harakatlarni tavsiflovchi aniq bosqichlardan iborat. Naqshlar faqat yondashuvni tavsiflaydi, lekin amalga oshirish bosqichlarini tasvirlamaydi. Naqshlar har xil, chunki... turli muammolarni hal qilish. Odatda quyidagi toifalar ajratiladi:-
Generativ
Ushbu naqshlar ob'ekt yaratishni moslashuvchan qilish muammosini hal qiladi
-
Strukturaviy
Ushbu naqshlar ob'ektlar orasidagi aloqalarni samarali o'rnatish muammosini hal qiladi
-
Xulq-atvor
Ushbu naqshlar ob'ektlar orasidagi samarali o'zaro ta'sir muammosini hal qiladi
Yaratilish naqshlari
Keling, ob'ektlarning hayot aylanishining boshidan - ob'ektlarni yaratishdan boshlaylik. Generativ shablonlar ob'ektlarni yanada qulayroq yaratishga yordam beradi va bu jarayonda moslashuvchanlikni ta'minlaydi. Eng mashhurlaridan biri " Quruvchi ". Ushbu naqsh murakkab ob'ektlarni bosqichma-bosqich yaratishga imkon beradi. Java-da eng mashhur misolStringBuilder:
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. Sinfning o'zi Calendarmavhum va uni yaratish uchun quyidagi usul qo'llaniladi 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());
}
}Calendarva sinf yaratiladi GregorianCalendar. Agar biz konstruktorga qarasak, sharoitga qarab turli xil ilovalar yaratilganligini ko'rishimiz mumkin Calendar. Ammo ba'zida bitta zavod usuli etarli emas. Ba'zan siz bir-biriga mos keladigan turli xil ob'ektlarni yaratishingiz kerak. Bunda bizga yana bir shablon yordam beradi - “ Abstrakt zavod ”. Va keyin biz bir joyda turli zavodlar yaratishimiz kerak. Shu bilan birga, afzallik shundaki, amalga oshirish tafsilotlari biz uchun muhim emas, ya'ni. qaysi aniq zavodni olishimiz muhim emas. Asosiysi, u to'g'ri amalga oshirishni yaratadi. Super misol:
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. Ya'ni, prototip asosida ob'ekt yaratish ob'ektning o'zi uchun javobgardir. Bu foydali, chunki u foydalanuvchini shablon ob'ektini amalga oshirishga bog'lamaydi. Xo'sh, ushbu ro'yxatdagi eng oxirgisi "Singleton" naqshidir. Uning maqsadi oddiy - butun dastur uchun ob'ektning bitta nusxasini taqdim etish. Ushbu naqsh qiziqarli, chunki u ko'pincha ko'p qirrali muammolarni ko'rsatadi. Batafsilroq ma'lumot olish uchun ushbu maqolalarni ko'rib chiqing:
Strukturaviy naqshlar
Ob'ektlarning yaratilishi bilan aniqroq bo'ldi. Endi strukturaviy naqshlarni ko'rib chiqish vaqti keldi. Ularning maqsadi oson qo'llab-quvvatlanadigan sinf ierarxiyasini va ularning munosabatlarini qurishdir. Birinchi va taniqli naqshlardan biri bu " Deputat " (proksi). Proksi-server haqiqiy ob'ekt bilan bir xil interfeysga ega, shuning uchun mijozning proksi-server orqali yoki to'g'ridan-to'g'ri ishlashi hech qanday farq qilmaydi. Eng oddiy misol 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"));
}
}HashMapinterfeysni amalga oshiradigan Map. HashMapKeyinchalik , mijoz qismi uchun asl proksi-serverni yaratamiz , u putva usullarini chaqiradi getva qo'ng'iroq paytida o'z mantiqimizni qo'shadi. Ko'rib turganimizdek, naqshdagi o'zaro ta'sir interfeyslar orqali sodir bo'ladi. Ammo ba'zida uning o'rnini bosadigan narsa etarli emas. Va keyin " Dekorator " naqshidan foydalanish mumkin. Dekorator, shuningdek, o'rash yoki o'rash deyiladi. Proksi va dekorativ juda o'xshash, ammo misolga qarasangiz, farqni ko'rasiz:
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. U bilan ishlashda biz aslida massiv bilan ishlaymiz. Shuning uchun elementlarni qo'shish ishlamaydi, chunki ... Asl massivni o'zgartirib bo'lmaydi. Va bu holda biz olamiz UnsupportedOperationException. Sinf tuzilishini rivojlantirishning navbatdagi qiziqarli yondashuvi kompozitsion naqshdir . Qizig'i shundaki, bitta interfeysdan foydalangan holda ma'lum elementlar to'plami ma'lum bir daraxtga o'xshash ierarxiyada joylashtirilgan. Asosiy elementdagi usulni chaqirish orqali biz barcha zarur bo'lgan yordamchi elementlarda ushbu usulga qo'ng'iroq qilamiz. Ushbu naqshning asosiy namunasi UI (java.awt yoki JSF bo'lsin):
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());
}
}java.awt:
Xulq-atvor namunalari
Shunday qilib, biz ob'ektlarni qanday yaratish mumkinligini va sinflar o'rtasidagi aloqalarni qanday tashkil qilish mumkinligini aniqladik. Qolgan eng qiziqarli narsa - ob'ektlarning xatti-harakatlarini o'zgartirishda moslashuvchanlikni ta'minlash. Bunda bizga xulq-atvor namunalari yordam beradi. Eng tez-tez tilga olingan naqshlardan biri bu " Strategiya " naqshidir. Bu erda " Birinchi bosh. Dizayn naqshlari " kitobidagi naqshlarni o'rganish boshlanadi. "Strategiya" naqshidan foydalanib, biz ob'ekt ichida harakatni qanday bajarishimizni saqlashimiz mumkin, ya'ni. ichidagi ob'ekt kodni bajarish paytida o'zgartirilishi mumkin bo'lgan strategiyani saqlaydi. Bu taqqoslash vositasidan foydalanganda biz tez-tez ishlatadigan namunadir: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. TreeSetU elementlarning tartibini saqlash xatti-harakatiga ega , ya'ni. ularni saralaydi (chunki u SortedSet). Ushbu xatti-harakatlarning standart strategiyasi mavjud, biz uni JavaDoc da ko'ramiz: "tabiiy tartibda" saralash (satrlar uchun bu leksikografik tartib). Bu parametrsiz konstruktordan foydalansangiz sodir bo'ladi. Ammo strategiyani o'zgartirmoqchi bo'lsak, o'tishimiz mumkin Comparator. Ushbu misolda biz o'z to'plamimizni sifatida yaratishimiz mumkin new TreeSet(comparator), keyin elementlarni saqlash tartibi (saqlash strategiyasi) taqqoslagichda ko'rsatilganiga o'zgaradi. Qizig'i shundaki, " Davlat " deb nomlangan deyarli bir xil naqsh mavjud . “Davlat” naqshida aytilishicha, agar biz asosiy ob'ektda ushbu ob'ektning holatiga bog'liq bo'lgan ba'zi xatti-harakatlarga ega bo'lsak, u holda biz holatning o'zini ob'ekt sifatida tasvirlashimiz va holat ob'ektini o'zgartirishimiz mumkin. Va asosiy ob'ektdan qo'ng'iroqlarni davlatga topshiring. Java tilining asoslarini o'rganishda bizga ma'lum bo'lgan yana bir naqsh " Buyruq " naqshidir. Ushbu dizayn namunasi turli xil buyruqlar turli sinflar sifatida taqdim etilishi mumkinligini ko'rsatadi. Ushbu naqsh Strategiya naqshiga juda o'xshaydi. Ammo Strategiya namunasida biz muayyan harakat qanday bajarilishini qayta belgilagan edik (masalan, TreeSet. "Buyruq" naqshida biz qanday harakat bajarilishini qayta belgilaymiz. Biz iplardan foydalanganda har kuni naqsh buyrug'i biz bilan birga bo'ladi:
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();
}
}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.getHandlersRo'yxatga oluvchi qayta ishlash uchun xabar olganida, har bir bunday xabar ushbu logger uchun ishlov beruvchilar zanjiri (dan) orqali o'tadi . Biz har kuni ko'radigan yana bir naqsh bu " Iterator ". ListUning mohiyati ob'ektlar to'plamini (ya'ni, ma'lumotlar tuzilmasini ifodalovchi sinf. Masalan, ) va ushbu to'plamning o'tishini ajratishdir .
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
}
}
}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!");
}
}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. Taymer ichida vazifa navbati TaskQueue, ip bor TimerThread. Biz, ushbu sinfning mijozlari sifatida, ular bilan o'zaro aloqada emasmiz, balki Timeruning usullariga chaqiruvimizga javoban, vositachi bo'lgan boshqa ob'ektlarning usullariga kiradigan ob'ekt bilan o'zaro aloqadamiz. Tashqi tomondan, u "Fasad" ga juda o'xshash bo'lishi mumkin. Ammo farq shundaki, Fasad ishlatilganda, komponentlar jabhaning mavjudligini bilishmaydi va bir-biri bilan gaplashadilar. Va "Mediator" dan foydalanilganda, komponentlar vositachini bilishadi va foydalanadilar, lekin bir-biri bilan bevosita aloqa qilmaydi. “ Shablon usuli ” naqshini ko'rib chiqishga arziydi Naqsh uning nomidan aniq. Xulosa shuki, kod shunday yozilganki, koddan foydalanuvchilarga (ishlab chiquvchilarga) qandaydir algoritm shablonlari taqdim etiladi, uning qadamlarini qayta belgilashga ruxsat beriladi. Bu kod foydalanuvchilariga butun algoritmni yozish emas, balki faqat ushbu algoritmning u yoki bu bosqichini qanday qilib to'g'ri bajarish haqida o'ylash imkonini beradi. Misol uchun, Java-da AbstractListiteratorning xatti-harakatlarini belgilaydigan mavhum sinf mavjud List. Biroq, iteratorning o'zi quyidagi kabi barg usullaridan foydalanadi: get, set, remove. Ushbu usullarning xatti-harakati avlodlarning ishlab chiquvchisi tomonidan belgilanadi AbstractList. Shunday qilib, iterator AbstractList- bu varaq ustida takrorlash algoritmi uchun shablondir. Muayyan ilovalarni ishlab chiquvchilar esa, AbstractListaniq qadamlarning xatti-harakatlarini belgilash orqali ushbu iteratsiyaning xatti-harakatlarini o'zgartiradilar. Biz tahlil qiladigan naqshlarning oxirgisi " Snapshot " (Momento) naqshidir. Uning mohiyati ob'ektning ma'lum bir holatini ushbu holatni tiklash qobiliyati bilan saqlab qolishdir. JDK dan eng taniqli misol ob'ektni ketma-ketlashtirishdir, ya'ni. java.io.Serializable. Keling, bir misolni ko'rib chiqaylik:
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
}
}
}
Xulosa
Ko'rib chiqqanimizdek, juda ko'p turli xil naqshlar mavjud. Ularning har biri o'z muammosini hal qiladi. Va bu naqshlarni bilish tizimingizni moslashuvchan, barqaror va o'zgarishlarga chidamli bo'lishi uchun qanday yozishni o'z vaqtida tushunishga yordam beradi. Va nihoyat, chuqurroq sho'ng'in uchun ba'zi havolalar:- Naqshlar uchun eng ajoyib manba: refactoring.guru
- Video pleylist " Obyektga yo'naltirilgan dasturlashda dizayn naqshlari "
- Dizayn naqshlari bo'yicha mashqlar
- Shakl sinovi
- Udemy-da namuna kurslari
- Coursera bo'yicha naqshlar kursi
GO TO FULL VERSION