テンプレート
求人で最も一般的な要件の 1 つは「パターンの知識」です。まず第一に、「デザインパターンとは何ですか?」という単純な質問に答えることが重要です。パターンは英語から「テンプレート」と訳されます。つまり、これは私たちが何かを行う際の特定のパターンです。プログラミングでも同様です。一般的な問題を解決するための確立されたベスト プラクティスとアプローチがいくつかあります。すべてのプログラマーはアーキテクトです。少数のクラス、あるいは 1 つのクラスしか作成しない場合でも、変化する要件の下でコードがどれだけ長く存続できるか、他の人が使用するのにどれだけ便利かは、あなた次第です。ここでテンプレートの知識が役に立ちます。なぜなら... これにより、コードを書き直さずにコードを記述する最適な方法をすぐに理解できるようになります。ご存知のとおり、プログラマーは怠け者で、何度もやり直すよりも、すぐにうまく書くほうが簡単です) パターンもアルゴリズムに似ているように見えるかもしれません。しかし、彼らには違いがあります。アルゴリズムは、必要なアクションを記述する特定のステップで構成されます。パターンはアプローチを説明するだけであり、実装手順は説明しません。模様が違うので… さまざまな問題を解決します。通常、次のカテゴリが区別されます。-
原動力
これらのパターンは、オブジェクト作成を柔軟にするという問題を解決します。
-
構造的
これらのパターンは、オブジェクト間の接続を効果的に構築するという問題を解決します。
-
行動的
これらのパターンは、オブジェクト間の効果的な相互作用の問題を解決します。
創作パターン
オブジェクトのライフサイクルの始まり、つまりオブジェクトの作成から始めましょう。生成テンプレートはオブジェクトをより便利に作成するのに役立ち、このプロセスに柔軟性をもたらします。最も有名なものの 1 つは「ビルダー」です。このパターンを使用すると、複雑なオブジェクトを段階的に作成できます。Java での最も有名な例は次のとおりです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。しかし、場合によっては、1 つのファクトリーメソッドだけでは十分ではありません。場合によっては、異なるオブジェクトを作成して互いに適合させることが必要になることがあります。これには別のテンプレート「 Abstract Factory 」が役立ちます。そして、さまざまな工場を 1 か所に作成する必要があります。同時に、実装の詳細は重要ではないという利点もあります。特定の工場を入手するかどうかは関係ありません。重要なことは、適切な実装を作成することです。超例:
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. つまり、プロトタイプに基づいてオブジェクトを作成するのは、オブジェクト自体の責任です。これは、ユーザーをテンプレート オブジェクトの実装に結び付けないため便利です。さて、このリストの最後にあるのは「Singleton」パターンです。その目的は単純で、アプリケーション全体にオブジェクトの単一インスタンスを提供することです。このパターンは、マルチスレッドの問題を示すことが多いため、興味深いものです。さらに詳しく知りたい場合は、次の記事をご覧ください。
構造パターン
オブジェクトを作成することで、それがより明確になりました。今こそ、構造パターンを検討する時期です。彼らの目標は、サポートしやすいクラス階層とその関係を構築することです。最初のよく知られたパターンの 1 つは「代理」(代理人) です。プロキシには実際のオブジェクトと同じインターフェイスがあるため、クライアントがプロキシ経由で動作するか直接動作するかに違いはありません。最も単純な例は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、呼び出し中に独自のロジックを追加します。ご覧のとおり、パターン内の相互作用はインターフェイスを通じて発生します。しかし、代替品では不十分な場合もあります。そして、「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。クラス構造を開発するための次の興味深いアプローチは、複合パターンです。興味深いのは、1 つのインターフェイスを使用する特定の要素セットが特定のツリー状の階層に配置されているという点です。親要素のメソッドを呼び出すと、必要なすべての子要素でこのメソッドが呼び出されます。このパターンの主な例は 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());
}
}java.awt。
行動パターン
そこで、オブジェクトを作成する方法と、クラス間の接続を組織する方法を考え出しました。残された最も興味深いことは、オブジェクトの動作を変更する際の柔軟性を提供することです。そして行動パターンがこれに役立ちます。最も頻繁に言及されるパターンの 1 つは「戦略」パターンです。ここから、「 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要素の順序を維持する動作があります。(SortedSet であるため) それらを並べ替えます。この動作には、JavaDoc に示されているデフォルトの戦略があります。それは、「自然な順序」でソートすることです (文字列の場合、これは辞書順です)。これは、パラメーターなしのコンストラクターを使用する場合に発生します。しかし、戦略を変更したい場合は、 を渡すことができますComparator。この例では、セットを として作成するnew TreeSet(comparator)と、要素を格納する順序 (格納戦略) がコンパレータで指定された順序に変更されます。興味深いことに、「 State 」と呼ばれるほぼ同じパターンがあります。「State」パターンは、このオブジェクトの状態に依存する何らかの動作がメイン オブジェクトにある場合、状態自体をオブジェクトとして記述し、状態オブジェクトを変更できることを示しています。そして、メインオブジェクトからの呼び出しを状態に委任します。Java 言語の基本を学習することで知られるもう 1 つのパターンは、「Command」パターンです。この設計パターンは、異なるコマンドを異なるクラスとして表すことができることを示唆しています。このパターンは、Strategy パターンと非常によく似ています。しかし、Strategy パターンでは、特定のアクションがどのように実行されるかを再定義していました (たとえば、 での並べ替えTreeSet)。「コマンド」パターンでは、どのようなアクションが実行されるかを再定義します。pattern コマンドは、スレッドを使用するときに毎日使用します。
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ロガーが処理するメッセージを受信すると、そのような各メッセージは、そのロガーの ( からの) ハンドラーのチェーンを通過します。私たちが毎日目にするもう 1 つのパターンは「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
}
}
}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。タイマーの内部にはタスク キューとTaskQueueスレッドがありますTimerThread。このクラスのクライアントとしての私たちは、オブジェクトと対話するのではなく、Timerオブジェクトと対話します。オブジェクトは、そのメソッドへの呼び出しに応答して、仲介者である他のオブジェクトのメソッドにアクセスします。外見的には「ファサード」に非常に似ているように見えるかもしれません。ただし、違いは、ファサードが使用される場合、コンポーネントはファサードの存在を認識せず、相互に通信することです。「メディエーター」が使用される場合、コンポーネントは仲介者を認識して使用しますが、相互に直接連絡することはありません。「テンプレートメソッド」パターンはその名前からも明らかなので、検討する価値があります。肝心なのは、コードのユーザー (開発者) に何らかのアルゴリズム テンプレートが提供され、そのステップが再定義できるようにコードが記述されているということです。これにより、コード ユーザーはアルゴリズム全体を記述することなく、このアルゴリズムの 1 つまたは別のステップを正しく実行する方法だけを考えることができます。たとえば、Java には、AbstractList反復子の動作を によって定義する抽象クラスがありますList。ただし、イテレータ自体は、get、set、などのリーフ メソッドを使用しますremove。これらのメソッドの動作は、子孫の開発者によって決定されますAbstractList。したがって、 - の反復子は、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 のパターン コース
GO TO FULL VERSION