


Obtenez une compréhension approfondie de 7 modèles de conception Java couramment utilisés
Comprendre les modèles de conception Java : introduction à 7 modèles de conception couramment utilisés, des exemples de code spécifiques sont requis
Les modèles de conception Java sont une solution universelle aux problèmes de conception de logiciels. Ils fournissent un ensemble d'idées de conception et de code de conduite largement acceptés. Les modèles de conception nous aident à mieux organiser et planifier la structure du code, rendant le code plus maintenable, lisible et évolutif. Dans cet article, nous présenterons 7 modèles de conception couramment utilisés en Java et fournirons des exemples de code correspondants.
- Modèle Singleton :
Le modèle singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global. Ceci est utile dans les scénarios où les ressources doivent être partagées ou où le nombre d'objets est limité. Voici un exemple de code du modèle singleton :
public class Singleton { private static Singleton instance; private Singleton() { // 私有构造函数,防止外部实例化 } public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }
- Modèle d'usine :
Le modèle d'usine crée des objets via une classe d'usine, encapsulant le processus de création d'objet. Cela peut masquer les détails d'implémentation spécifiques de l'objet, rendant le code client plus concis et extensible. Voici un exemple de code du modèle d'usine :
public interface Shape { void draw(); } public class Circle implements Shape { @Override public void draw() { System.out.println("Circle::draw()"); } } public class Rectangle implements Shape { @Override public void draw() { System.out.println("Rectangle::draw()"); } } public class ShapeFactory { public Shape getShape(String shapeType) { if (shapeType == null) { return null; } if (shapeType.equalsIgnoreCase("CIRCLE")) { return new Circle(); } else if (shapeType.equalsIgnoreCase("RECTANGLE")) { return new Rectangle(); } return null; } }
- Modèle Observer :
Le modèle Observer définit une relation de dépendance un-à-plusieurs lorsque l'état d'un objet change, il dépend de ses autres objets qui seront mis à jour. automatiquement. Ceci est utile dans le développement événementiel, de publication-abonnement et d'interface graphique. Voici un exemple de code du modèle Observer :
import java.util.ArrayList; import java.util.List; public class Subject { private List<Observer> observers = new ArrayList<>(); private int state; public int getState() { return state; } public void setState(int state) { this.state = state; notifyAllObservers(); } public void attach(Observer observer) { observers.add(observer); } public void notifyAllObservers() { for (Observer observer : observers) { observer.update(); } } } public abstract class Observer { protected Subject subject; public abstract void update(); } public class BinaryObserver extends Observer { public BinaryObserver(Subject subject) { this.subject = subject; this.subject.attach(this); } public void update() { System.out.println("Binary String: " + Integer.toBinaryString(subject.getState())); } } public class OctalObserver extends Observer { public OctalObserver(Subject subject) { this.subject = subject; this.subject.attach(this); } public void update() { System.out.println("Octal String: " + Integer.toOctalString(subject.getState())); } } public class HexObserver extends Observer { public HexObserver(Subject subject) { this.subject = subject; this.subject.attach(this); } public void update() { System.out.println("Hex String: " + Integer.toHexString(subject.getState())); } } public class ObserverPatternDemo { public static void main(String[] args) { Subject subject = new Subject(); new BinaryObserver(subject); new OctalObserver(subject); new HexObserver(subject); System.out.println("First state change: 15"); subject.setState(15); System.out.println("Second state change: 10"); subject.setState(10); } }
- Builder Pattern (Builder Pattern) :
Le modèle Builder permet d'utiliser le même processus de construction pour créer différentes représentations en séparant le processus de construction de l'objet. Cela améliore la flexibilité et la lisibilité du code et évite le problème d'un trop grand nombre de paramètres de construction. Voici un exemple de code du modèle Builder :
public class Computer { private String cpu; private String memory; private String disk; // 省略其他属性和方法 } public interface ComputerBuilder { ComputerBuilder setCpu(String cpu); ComputerBuilder setMemory(String memory); ComputerBuilder setDisk(String disk); Computer build(); } public class BasicComputerBuilder implements ComputerBuilder { private Computer computer; public BasicComputerBuilder() { computer = new Computer(); } public ComputerBuilder setCpu(String cpu) { computer.setCpu(cpu); return this; } public ComputerBuilder setMemory(String memory) { computer.setMemory(memory); return this; } public ComputerBuilder setDisk(String disk) { computer.setDisk(disk); return this; } public Computer build() { return computer; } } public class Director { private ComputerBuilder computerBuilder; public Director(ComputerBuilder computerBuilder) { this.computerBuilder = computerBuilder; } public Computer construct() { return computerBuilder .setCpu("i5") .setMemory("8GB") .setDisk("1TB") .build(); } } public class BuilderPatternDemo { public static void main(String[] args) { ComputerBuilder computerBuilder = new BasicComputerBuilder(); Director director = new Director(computerBuilder); Computer computer = director.construct(); System.out.println(computer.toString()); } }
- Modèle de prototype :
Le modèle de prototype crée de nouveaux objets en copiant des objets existants au lieu de les recréer. Cela peut améliorer l'efficacité de la création d'objets, en particulier lorsque le processus d'initialisation de l'objet est complexe. Voici un exemple de code du modèle de prototype :
public abstract class Shape implements Cloneable { private String id; protected String type; abstract void draw(); public String getId() { return id; } public void setId(String id) { this.id = id; } public Object clone() { Object clone = null; try { clone = super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return clone; } } public class Circle extends Shape { public Circle() { type = "Circle"; } public void draw() { System.out.println("Inside Circle::draw() method."); } } public class Rectangle extends Shape { public Rectangle() { type = "Rectangle"; } public void draw() { System.out.println("Inside Rectangle::draw() method."); } } public class ShapeCache { private static Map<String, Shape> shapeMap = new HashMap<>(); public static Shape getShape(String shapeId) { Shape cachedShape = shapeMap.get(shapeId); return (Shape) cachedShape.clone(); } public static void loadCache() { Circle circle = new Circle(); circle.setId("1"); shapeMap.put(circle.getId(), circle); Rectangle rectangle = new Rectangle(); rectangle.setId("2"); shapeMap.put(rectangle.getId(), rectangle); } } public class PrototypePatternDemo { public static void main(String[] args) { ShapeCache.loadCache(); Shape clonedShape1 = ShapeCache.getShape("1"); System.out.println("Shape: " + clonedShape1.getType()); Shape clonedShape2 = ShapeCache.getShape("2"); System.out.println("Shape: " + clonedShape2.getType()); } }
- Modèle d'adaptateur :
Le modèle d'adaptateur convertit l'interface d'une classe en une autre interface attendue par le client. Cela permet à des interfaces incompatibles de fonctionner ensemble sans modifier le code existant. Voici un exemple de code du modèle d'adaptateur :
public interface MediaPlayer { void play(String audioType, String fileName); } public interface AdvancedMediaPlayer { void playVlc(String fileName); void playMp4(String fileName); } public class VlcPlayer implements AdvancedMediaPlayer { public void playVlc(String fileName) { System.out.println("Playing vlc file. Name: " + fileName); } public void playMp4(String fileName) { // 空实现 } } public class Mp4Player implements AdvancedMediaPlayer { public void playVlc(String fileName) { // 空实现 } public void playMp4(String fileName) { System.out.println("Playing mp4 file. Name: " + fileName); } } public class MediaAdapter implements MediaPlayer { AdvancedMediaPlayer advancedMediaPlayer; public MediaAdapter(String audioType) { if (audioType.equalsIgnoreCase("vlc")) { advancedMediaPlayer = new VlcPlayer(); } else if (audioType.equalsIgnoreCase("mp4")) { advancedMediaPlayer = new Mp4Player(); } } public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase("vlc")) { advancedMediaPlayer.playVlc(fileName); } else if (audioType.equalsIgnoreCase("mp4")) { advancedMediaPlayer.playMp4(fileName); } } } public class AudioPlayer implements MediaPlayer { MediaAdapter mediaAdapter; public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase("mp3")) { System.out.println("Playing mp3 file. Name: " + fileName); } else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) { mediaAdapter = new MediaAdapter(audioType); mediaAdapter.play(audioType, fileName); } else { System.out.println("Invalid media. " + audioType + " format not supported"); } } } public class AdapterPatternDemo { public static void main(String[] args) { AudioPlayer audioPlayer = new AudioPlayer(); audioPlayer.play("mp3", "beyond_the_horizon.mp3"); audioPlayer.play("mp4", "alone.mp4"); audioPlayer.play("vlc", "far_far_away.vlc"); audioPlayer.play("avi", "mind_me.avi"); } }
- Modèle de stratégie :
Le modèle de stratégie définit une série d'algorithmes et encapsule chaque algorithme afin qu'ils puissent être remplacés les uns par les autres. Cela facilite le changement d'algorithme ou l'extension de nouveaux algorithmes sans affecter d'autres parties du code. Ce qui suit est un exemple de code du modèle de stratégie :
public interface Strategy { int doOperation(int num1, int num2); } public class OperationAdd implements Strategy { public int doOperation(int num1, int num2) { return num1 + num2; } } public class OperationSubtract implements Strategy { public int doOperation(int num1, int num2) { return num1 - num2; } } public class OperationMultiply implements Strategy { public int doOperation(int num1, int num2) { return num1 * num2; } } public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public int executeStrategy(int num1, int num2) { return strategy.doOperation(num1, num2); } } public class StrategyPatternDemo { public static void main(String[] args) { Context context = new Context(new OperationAdd()); System.out.println("10 + 5 = " + context.executeStrategy(10, 5)); context = new Context(new OperationSubtract()); System.out.println("10 - 5 = " + context.executeStrategy(10, 5)); context = new Context(new OperationMultiply()); System.out.println("10 * 5 = " + context.executeStrategy(10, 5)); } }
Grâce à l'exemple de code ci-dessus, nous avons une brève introduction aux 7 modèles de conception couramment utilisés en Java. Chaque modèle de conception comporte différents scénarios et applications, et ils peuvent entrer en jeu dans différents projets. J'espère que cet article pourra vous aider à comprendre et à appliquer des modèles de conception, ainsi qu'à améliorer la qualité de votre code et l'efficacité de votre développement.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Guide de la racine carrée en Java. Nous discutons ici du fonctionnement de Square Root en Java avec un exemple et son implémentation de code respectivement.

Guide du nombre parfait en Java. Nous discutons ici de la définition, comment vérifier le nombre parfait en Java ?, des exemples d'implémentation de code.

Guide du générateur de nombres aléatoires en Java. Nous discutons ici des fonctions en Java avec des exemples et de deux générateurs différents avec d'autres exemples.

Guide de Weka en Java. Nous discutons ici de l'introduction, de la façon d'utiliser Weka Java, du type de plate-forme et des avantages avec des exemples.

Guide du numéro Armstrong en Java. Nous discutons ici d'une introduction au numéro d'Armstrong en Java ainsi que d'une partie du code.

Guide du nombre de Smith en Java. Nous discutons ici de la définition, comment vérifier le numéro Smith en Java ? exemple avec implémentation de code.

Dans cet article, nous avons conservé les questions d'entretien Java Spring les plus posées avec leurs réponses détaillées. Pour que vous puissiez réussir l'interview.

Java 8 présente l'API Stream, fournissant un moyen puissant et expressif de traiter les collections de données. Cependant, une question courante lors de l'utilisation du flux est: comment se casser ou revenir d'une opération FOREAK? Les boucles traditionnelles permettent une interruption ou un retour précoce, mais la méthode Foreach de Stream ne prend pas directement en charge cette méthode. Cet article expliquera les raisons et explorera des méthodes alternatives pour la mise en œuvre de terminaison prématurée dans les systèmes de traitement de flux. Lire plus approfondie: Améliorations de l'API Java Stream Comprendre le flux Forach La méthode foreach est une opération terminale qui effectue une opération sur chaque élément du flux. Son intention de conception est
