templat
Salah satu keperluan yang paling biasa dalam kekosongan ialah "Pengetahuan tentang corak." Pertama sekali, anda patut menjawab soalan mudah - "Apakah itu Corak Reka Bentuk?" Corak diterjemahkan daripada bahasa Inggeris sebagai "template". Iaitu, ini adalah corak tertentu mengikut mana kita melakukan sesuatu. Perkara yang sama berlaku dalam pengaturcaraan. Terdapat beberapa amalan terbaik dan pendekatan yang ditetapkan untuk menyelesaikan masalah biasa. Setiap pengaturcara adalah seorang arkitek. Walaupun anda membuat hanya beberapa kelas atau bahkan satu, ia bergantung kepada anda berapa lama kod itu boleh bertahan di bawah keperluan yang berubah-ubah, betapa mudahnya ia digunakan oleh orang lain. Dan di sinilah pengetahuan tentang templat akan membantu, kerana... Ini akan membolehkan anda memahami dengan cepat cara terbaik untuk menulis kod tanpa menulisnya semula. Seperti yang anda ketahui, pengaturcara adalah orang yang malas dan lebih mudah untuk menulis sesuatu dengan segera daripada membuat semula beberapa kali) Corak juga mungkin kelihatan serupa dengan algoritma. Tetapi mereka mempunyai perbezaan. Algoritma terdiri daripada langkah-langkah khusus yang menerangkan tindakan yang diperlukan. Corak hanya menerangkan pendekatan, tetapi tidak menerangkan langkah pelaksanaan. Coraknya berbeza, kerana... menyelesaikan masalah yang berbeza. Biasanya kategori berikut dibezakan:-
Generatif
Corak ini menyelesaikan masalah menjadikan penciptaan objek fleksibel
-
berstruktur
Corak ini menyelesaikan masalah membina hubungan antara objek dengan berkesan
-
Tingkah laku
Corak ini menyelesaikan masalah interaksi berkesan antara objek
Corak ciptaan
Mari kita mulakan dari permulaan kitaran hidup objek - dengan penciptaan objek. Templat generatif membantu mencipta objek dengan lebih mudah dan memberikan fleksibiliti dalam proses ini. Salah satu yang paling terkenal ialah " Builder ". Corak ini membolehkan anda membuat objek kompleks langkah demi langkah. Di Jawa, contoh yang paling terkenal ialahStringBuilder:
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. Kelas itu sendiri Calendaradalah abstrak, dan untuk menciptanya kaedah digunakan 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, dan kelas dicipta GregorianCalendar. Jika kita melihat pembina, kita dapat melihat bahawa pelaksanaan yang berbeza dicipta bergantung pada syarat Calendar. Tetapi kadang-kadang satu kaedah kilang tidak mencukupi. Kadangkala anda perlu mencipta objek yang berbeza supaya ia sesuai bersama. Templat lain akan membantu kami dengan ini - " Kilang abstrak ". Dan kemudian kita perlu membuat kilang yang berbeza di satu tempat. Pada masa yang sama, kelebihannya ialah butiran pelaksanaan tidak penting bagi kami, i.e. tidak kira kilang tertentu yang kita dapat. Perkara utama ialah ia mewujudkan pelaksanaan yang betul. Contoh hebat:
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. Iaitu, mencipta objek berdasarkan prototaip adalah tanggungjawab objek itu sendiri. Ini berguna kerana ia tidak mengikat pengguna dengan pelaksanaan objek templat. Nah, yang terakhir dalam senarai ini ialah corak "Singleton". Tujuannya mudah - untuk menyediakan satu contoh objek untuk keseluruhan aplikasi. Corak ini menarik kerana ia sering menunjukkan masalah multithreading. Untuk pandangan yang lebih mendalam, lihat artikel ini:
Corak struktur
Dengan penciptaan objek ia menjadi lebih jelas. Sekarang adalah masa untuk melihat corak struktur. Matlamat mereka adalah untuk membina hierarki kelas yang mudah disokong dan perhubungan mereka. Salah satu corak yang pertama dan terkenal ialah " Timbalan " (Proksi). Proksi mempunyai antara muka yang sama dengan objek sebenar, jadi tiada bezanya untuk klien bekerja melalui proksi atau secara langsung. Contoh paling mudah ialah 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"));
}
}HashMapmelaksanakan antara muka Map. Kami seterusnya mencipta proksi yang menggantikan yang asal HashMapuntuk bahagian klien, yang memanggil putdan kaedah get, menambah logik kami sendiri semasa panggilan. Seperti yang kita lihat, interaksi dalam corak berlaku melalui antara muka. Tetapi kadangkala pengganti tidak mencukupi. Dan kemudian corak " Penghias " boleh digunakan. Penghias juga dipanggil pembalut atau pembalut. Proksi dan penghias sangat serupa, tetapi jika anda melihat contoh, anda akan melihat perbezaannya:
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. Apabila bekerja dengannya, kami sebenarnya bekerja dengan tatasusunan. Oleh itu, menambah elemen tidak akan berfungsi, kerana... Tatasusunan asal tidak boleh diubah. Dan dalam kes ini kita akan mendapat UnsupportedOperationException. Pendekatan menarik seterusnya untuk membangunkan struktur kelas ialah corak Komposit . Adalah menarik kerana satu set elemen tertentu menggunakan satu antara muka disusun dalam hierarki seperti pokok tertentu. Dengan memanggil kaedah pada elemen induk, kami mendapat panggilan ke kaedah ini pada semua elemen anak yang diperlukan. Contoh utama corak ini ialah UI (sama ada java.awt atau 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());
}
}java.awt:
Corak tingkah laku
Jadi, kami mengetahui cara objek boleh dibuat dan cara hubungan antara kelas boleh diatur. Perkara yang paling menarik yang tinggal adalah untuk memberikan fleksibiliti dalam mengubah tingkah laku objek. Dan corak tingkah laku akan membantu kita dengan ini. Salah satu corak yang paling kerap disebut ialah corak " Strategi ". Di sinilah kajian corak dalam buku " Head First. Design Patterns " bermula. Menggunakan corak "Strategi", kita boleh menyimpan di dalam objek bagaimana kita akan melakukan tindakan itu, i.e. objek di dalam menyimpan strategi yang boleh diubah semasa pelaksanaan kod. Ini adalah corak yang sering kami gunakan apabila menggunakan pembanding: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. Ia mempunyai tingkah laku TreeSetmengekalkan susunan unsur, i.e. mengisih mereka (kerana ia adalah SortedSet). Tingkah laku ini mempunyai strategi lalai, yang kita lihat dalam JavaDoc: menyusun dalam "tertib semula jadi" (untuk rentetan, ini ialah susunan leksikografi). Ini berlaku jika anda menggunakan pembina tanpa parameter. Tetapi jika kita mahu menukar strategi, kita boleh lulus Comparator. Dalam contoh ini, kita boleh mencipta set kita sebagai new TreeSet(comparator), dan kemudian susunan elemen penyimpanan (strategi penyimpanan) akan berubah kepada yang ditentukan dalam pembanding. Menariknya, terdapat corak yang hampir sama yang dipanggil " State ". Corak "Negeri" mengatakan bahawa jika kita mempunyai beberapa tingkah laku dalam objek utama yang bergantung pada keadaan objek ini, maka kita boleh menggambarkan keadaan itu sendiri sebagai objek dan menukar objek keadaan. Dan mewakilkan panggilan daripada objek utama kepada negeri. Satu lagi corak yang kita ketahui daripada mempelajari asas-asas bahasa Jawa ialah corak " Perintah ". Corak reka bentuk ini menunjukkan bahawa arahan yang berbeza boleh diwakili sebagai kelas yang berbeza. Corak ini sangat serupa dengan corak Strategi. Tetapi dalam corak Strategi, kami mentakrifkan semula cara tindakan tertentu akan dilakukan (contohnya, mengisih dalam TreeSet). Dalam corak "Perintah", kami mentakrifkan semula tindakan yang akan dilakukan. Perintah corak ada bersama kami setiap hari apabila kami menggunakan benang:
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.getHandlers) untuk pembalak itu. Corak lain yang kita lihat setiap hari ialah " Iterator ". Intipatinya adalah untuk memisahkan koleksi objek (iaitu kelas yang mewakili struktur data. Contohnya, List) dan traversal koleksi ini.
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'a. Di dalam pemasa terdapat baris gilir tugas TaskQueue, terdapat benang TimerThread. Kami, sebagai pelanggan kelas ini, tidak berinteraksi dengan mereka, tetapi berinteraksi dengan Timerobjek, yang, sebagai tindak balas kepada panggilan kami kepada kaedahnya, mengakses kaedah objek lain yang mana ia adalah perantara. Secara luaran ia mungkin kelihatan sangat serupa dengan "Fasad". Tetapi perbezaannya ialah apabila Fasad digunakan, komponen tidak tahu bahawa fasad itu wujud dan bercakap antara satu sama lain. Dan apabila "Pengantara" digunakan, komponen mengetahui dan menggunakan perantara, tetapi tidak menghubungi satu sama lain secara langsung. Perlu mempertimbangkan corak " Kaedah Templat ". Corak itu jelas daripada namanya. Intinya ialah kod itu ditulis sedemikian rupa sehingga pengguna kod (pembangun) disediakan dengan beberapa templat algoritma, langkah-langkahnya dibenarkan untuk ditakrifkan semula. Ini membenarkan pengguna kod untuk tidak menulis keseluruhan algoritma, tetapi hanya memikirkan cara melaksanakan satu atau satu lagi langkah algoritma ini dengan betul. Sebagai contoh, Java mempunyai kelas abstrak AbstractListyang mentakrifkan tingkah laku iterator dengan List. Walau bagaimanapun, iterator itu sendiri menggunakan kaedah daun seperti: get, set, remove. Tingkah laku kaedah ini ditentukan oleh pembangun keturunan AbstractList. Oleh itu, iterator dalam AbstractList- ialah templat untuk algoritma untuk lelaran pada helaian. Dan pembangun pelaksanaan khusus AbstractListmengubah gelagat lelaran ini dengan mentakrifkan gelagat langkah tertentu. Corak terakhir yang kami analisis ialah corak " Syot Kilat " (Momento). Intipatinya adalah untuk mengekalkan keadaan tertentu objek dengan keupayaan untuk memulihkan keadaan ini. Contoh yang paling dikenali daripada JDK ialah pensirilan objek, i.e. java.io.Serializable. Mari lihat contoh:
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
}
}
}
Kesimpulan
Seperti yang kita lihat daripada ulasan, terdapat pelbagai jenis corak. Setiap daripada mereka menyelesaikan masalah sendiri. Dan mengetahui corak ini boleh membantu anda memahami tepat pada masanya cara menulis sistem anda supaya ia fleksibel, boleh diselenggara dan tahan terhadap perubahan. Dan akhirnya, beberapa pautan untuk menyelam lebih mendalam:- Sumber yang paling menakjubkan untuk corak: refactoring.guru
- Senarai main video " Corak Reka Bentuk dalam Pengaturcaraan Berorientasikan Objek "
- Latihan Corak Rekaan
- Ujian corak
- Kursus corak pada Udemy
- Kursus corak di Coursera
GO TO FULL VERSION