java的几种设计模式

ゞ浴缸里的玫瑰 2024-03-24 17:52 83阅读 0赞

Java中常见的设计模式有以下几种：1. 单例模式：确保一个类只有一个实例，并提供全局访问点。例如，数据库连接池、线程池等。

\`\`\`java  
public class Singleton \{  
private static Singleton instance = null;  
private Singleton() \{\}  
public static synchronized Singleton getInstance() \{  
if (instance == null) \{  
instance = new Singleton();  
\}  
return instance;  
\}  
\}  
\`\`\`

2. 工厂模式：将对象的创建过程封装起来，隐藏具体实现，提供一个公共的接口。例如，创建窗口控件时，通过工厂方法创建不同的控件，如Button、Label等。

\`\`\`java  
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 static Shape getShape(String type) \{  
if (type.equalsIgnoreCase("circle")) \{  
return new Circle();  
\} else if (type.equalsIgnoreCase("rectangle")) \{  
return new Rectangle();  
\}  
return null;  
\}  
\}  
\`\`\`

3. 观察者模式：定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，其他依赖它的对象会收到通知并自动更新。例如，新闻订阅、消息推送等。

\`\`\`java  
public interface Observer \{  
void update(String message);  
\}  
public interface Subject \{  
void attach(Observer observer);  
void detach(Observer observer);  
void notify(String message);  
\}  
public class ConcreteSubject implements Subject \{  
private List<Observer> observers = new ArrayList<>();  
@Override  
public void attach(Observer observer) \{  
observers.add(observer);  
\}  
@Override  
public void detach(Observer observer) \{  
observers.remove(observer);  
\}  
@Override  
public void notify(String message) \{  
for (Observer observer : observers) \{  
observer.update(message);  
\}  
\}  
\}  
public class ConcreteObserver implements Observer \{  
private String name;  
public ConcreteObserver(String name

) \{  
this.name = name;  
\}  
@Override  
public void update(String message) \{  
System.out.println(name + " received message: " + message);  
\}  
\}  
// 使用观察者模式  
public static void main(String\[\] args) \{  
Subject subject = new ConcreteSubject();  
Observer observer1 = new ConcreteObserver("Observer1");  
Observer observer2 = new ConcreteObserver("Observer2");  
subject.attach(observer1);  
subject.attach(observer2);  
subject.notify("Hello World!");  
subject.detach(observer2);  
subject.notify("Goodbye!");  
\}  
\`\`\`4. 模板方法模式：定义一个算法的骨架，具体实现由子类决定。例如，银行开户流程中的各个步骤。

\`\`\`java  
public abstract class AbstractClass \{  
public final void templateMethod() \{  
primitiveOperation1();  
primitiveOperation2();  
concreteOperation();  
hook();  
\}  
protected abstract void primitiveOperation1();  
protected abstract void primitiveOperation2();  
protected void concreteOperation() \{  
// 具体操作  
\}  
protected void hook() \{\}  
\}  
public class ConcreteClass extends AbstractClass \{  
@Override  
protected void primitiveOperation1() \{  
// 实现  
\}  
@Override  
protected void primitiveOperation2() \{  
// 实现  
\}  
@Override  
protected void hook() \{  
// 钩子方法，可根据需要重写或不重写  
\}  
\}  
\`\`\`

5. 策略模式：定义一系列算法，将它们封装起来，并使它们可以相互替换。例如，排序算法中的不同策略（冒泡排序、快速排序等）。

\`\`\`java  
public interface Strategy \{  
void sort(int\[\] arr);  
\}  
public class BubbleSort implements Strategy \{  
@Override  
public void sort(int\[\] arr) \{  
// 实现冒泡排序  
\}  
\}  
public class QuickSort implements Strategy \{  
@Override  
public void sort(int\[\] arr) \{  
// 实现快速排序  
\}  
\}  
public class Context \{  
private Strategy strategy;  
public Context(Strategy strategy) \{  
this.strategy = strategy;  
\}  
public void setStrategy(Strategy strategy) \{

this.strategy = strategy;  
\}  
public void sort(int\[\] arr) \{  
strategy.sort(arr);  
\}  
\}  
// 使用策略模式  
public static void main(String\[\] args) \{  
int\[\] arr = \{3, 5, 1, 4, 2\};  
Context context = new Context(new BubbleSort());  
context.sort(arr);  
context.setStrategy(new QuickSort());  
context.sort(arr);  
\}  
\`\`\`

6. 责任链模式：将请求的发送者和接收者解耦，将多个对象连成一条链，请求沿着链传递，直到有一个对象处理请求。例如，Web应用中的过滤器链。\`\`\`java  
public abstract class Handler \{  
private Handler successor;  
public void setSuccessor(Handler successor) \{  
this.successor = successor;  
\}  
public final void handleRequest(Request request) \{  
if (canHandle(request)) \{  
handle(request);  
\} else if (successor != null) \{  
successor.handleRequest(request);  
\}  
\}  
protected abstract boolean canHandle(Request request);  
protected abstract void handle(Request request);  
\}  
public class Request \{  
private String type;  
private String content;  
public Request(String type, String content) \{  
this.type = type;  
this.content = content;  
\}  
// getter、setter  
\}  
public class ConcreteHandler1 extends Handler \{  
@Override  
protected boolean canHandle(Request request) \{  
return "type1".equals(request.getType());  
\}  
@Override  
protected void handle(Request request) \{  
// 处理请求  
\}  
\}  
public class ConcreteHandler2 extends Handler \{  
@Override  
protected boolean canHandle(Request request) \{  
return "type2".equals(request.getType());  
\}  
@Override  
protected void handle(Request request) \{  
// 处理请求  
\}  
\}  
// 使用责任链模式  
public static void main(String\[\] args) \{  
Handler handler1 = new ConcreteHandler1();  
Handler handler2 = new ConcreteHandler2();  
handler1.setSuccessor(handler2);  
Request request1 = new Request("type1", "content1");  
Request request2 = new Request("type2", "content2");  
handler1.handleRequest(request1);  
handler1.handleRequest(request2);  
\}  
\`\`\`

7. 适配器模式：将一个接口转换成客户希望的另一个接口。例如，将不同电压的电器通过适配器转换为统一电压的电器。

\`\`\`java  
public interface Target \{  
void request();  
\}  
public class Adaptee \{  
public void specificRequest() \{  
// 特殊请求  
\}  
\}  
public class Adapter implements Target \{  
private Adap

tee adaptee;  
public Adapter(Adaptee adaptee) \{  
this.adaptee = adaptee;  
\}  
@Override  
public void request() \{  
adaptee.specificRequest();  
\}  
\}  
// 使用适配器模式  
public static void main(String\[\] args) \{  
Adaptee adaptee = new Adaptee();  
Target target = new Adapter(adaptee);  
target.request();  
\}  
\`\`\`8. 组合模式：将对象组合成树形结构，以表示“部分-整体”的层次结构。例如，树形菜单。

\`\`\`java  
public abstract class Component \{  
protected String name;  
public Component(String name) \{  
this.name = name;  
\}  
public abstract void add(Component component);  
public abstract void remove(Component component);  
public abstract void display(int depth);  
\}  
public class Leaf extends Component \{  
public Leaf(String name) \{  
super(name);  
\}  
@Override  
public void add(Component component) \{  
// 叶子节点无法添加子节点  
\}  
@Override  
public void remove(Component component) \{  
// 叶子节点无法删除子节点  
\}  
@Override  
public void display(int depth) \{  
System.out.println(String.join("", Collections.nCopies(depth, "-")) + name);  
\}  
\}  
public class Composite extends Component \{  
private List<Component> children = new ArrayList<>();  
public Composite(String name) \{  
super(name);  
\}  
@Override  
public void add(Component component) \{  
children.add(component);  
\}  
@Override  
public void remove(Component component) \{  
children.remove(component);  
\}  
@Override  
public void display(int depth) \{  
System.out.println(String.join("", Collections.nCopies(depth, "-")) + name);  
for (Component child : children) \{  
child.display(depth + 2);  
\}  
\}  
\}  
// 使用组合模式  
public static void main(String\[\] args) \{  
Component root = new Composite("root");  
Component node1 = new Composite("node1");  
Component node2 = new Composite("node2");  
Component leaf1 = new Leaf("leaf1");  
Component leaf2 = new Leaf("leaf2");  
root.add(node1);  
root.add(node2);  
node1.add(leaf1);  
node2.add(leaf2);  
root.display

(0);  
\}  
\`\`\`9. 建造者模式：将一个复杂对象的构建与它的表示分离，使同样的构建过程可以创建不同的表示。例如，创建一份包含不同组件的电脑。

\`\`\`java  
public class Computer \{  
private String cpu;  
private String memory;  
private String hardDisk;  
// 省略getter、setter  
\}  
public interface Builder \{  
void setCpu(String cpu);  
void setMemory(String memory);  
void setHardDisk(String hardDisk);  
Computer build();  
\}  
public class ConcreteBuilder implements Builder \{  
private Computer computer = new Computer();  
@Override  
public void setCpu(String cpu) \{  
computer.setCpu(cpu);  
\}  
@Override  
public void setMemory(String memory) \{  
computer.setMemory(memory);  
\}  
@Override  
public void setHardDisk(String hardDisk) \{  
computer.setHardDisk(hardDisk);  
\}  
@Override  
public Computer build() \{  
return computer;  
\}  
\}  
public class Director \{  
public Computer construct(Builder builder) \{  
builder.setCpu("i7");  
builder.setMemory("8GB");  
builder.setHardDisk("256GB");  
return builder.build();  
\}  
\}  
// 使用建造者模式  
public static void main(String\[\] args) \{  
Director director = new Director();  
Builder builder = new ConcreteBuilder();  
Computer computer = director.construct(builder);  
\}  
\`\`\`

10. 原型模式：通过复制现有对象来创建新对象，而不是通过实例化来创建。例如，复制一个已有的电子档案，修改其中的内容。\`\`\`java  
public abstract class Prototype implements Cloneable \{  
public abstract Prototype clone();  
\}  
public class ConcretePrototype1 extends Prototype \{  
private String field1;  
private String field2;  
public ConcretePrototype1(String field1, String field2) \{  
this.field1 = field1;  
this.field2 = field2;  
\}  
@Override  
public Prototype clone() \{  
return new ConcretePrototype1(field1, field2);  
\}  
\}  
public class ConcretePrototype2 extends Prototype \{  
private List<String> list;  
public ConcretePrototype2(List<String> list) \{  
this.list = list;  
\}  
@Override  
public Prototype clone() \{  
List<String> newList = new ArrayList<>(list);  
return new ConcretePrototype2(newList);  
\}  
\}  
// 使用原型模式  
public static void main(String\[\] args) \{  
Prototype prototype1 = new ConcretePrototype1("field1", "field2");  
Prototype prototype2 = new ConcretePrototype2(Arrays.asList("item1", "item2"));  
Prototype clone1 = prototype1.clone();  
Prototype clone2 = prototype2.clone();  
\}  
\`\`\`

11. 迭代器模式：提供一种方法，使得可以顺序访问一个聚合对象中的各个元素，而又不暴露其内部实现。例如，遍历一个列表中的元素。\`\`\`java  
public interface Iterator<T> \{  
boolean hasNext();  
T next();  
\}  
public interface Aggregate<T> \{  
Iterator<T> iterator();  
\}  
public class ConcreteAggregate<T> implements Aggregate<T> \{  
private List<T> list = new ArrayList<>();  
public void add(T item) \{  
list.add(item);  
\}  
@Override  
public Iterator<T> iterator() \{  
return new ConcreteIterator<>(list);  
\}  
\}  
public class ConcreteIterator<T> implements Iterator<T> \{  
private List<T> list;  
private int index = 0;  
public ConcreteIterator(List<T> list) \{  
this.list = list;  
\}  
@Override  
public boolean hasNext() \{  
return index < list.size();  
\}  
@Override  
public T next() \{  
if (!hasNext()) \{  
throw new NoSuchElementException();  
\}  
return list.get(index++);  
\}  
\}  
// 使用迭代器模式  
public static void main(String\[\] args) \{  
Aggregate<String> aggregate = new ConcreteAggregate<>();  
aggregate.add("item1");  
aggregate.add("item2");  
Iterator<String> iterator = aggregate.iterator();  
while (iterator.hasNext()) \{  
System.out.println(iterator.next());  
\}  
\}  
\`\`\`

12. 外观模式：为子系统中的一组接口提供一个统一接口，使得这一子系统更容易使用。例如，简化文件读写操作。\`\`\`java  
public class FileReader \{  
public String read(String filePath) \{  
// 读取文件内容  
return "";  
\}  
\}  
public class FileWriter \{  
public void write(String filePath, String content) \{  
// 写入文件内容  
\}  
\}  
public class FileFacade \{  
private FileReader reader;  
private FileWriter writer;  
public FileFacade() \{  
reader = new FileReader();  
writer = new FileWriter();  
\}  
public String read(String filePath) \{  
return reader.read(filePath);  
\}  
public void write(String filePath, String content) \{  
writer.write(filePath, content);  
\}  
\}  
// 使用外观模式  
public static void main(String\[\] args) \{  
FileFacade facade = new FileFacade();  
String content = facade.read("test.txt");  
facade.write("new.txt", content);  
\}  
\`\`\`

13. 装饰器模式：动态地给一个对象添加一些额外的职责，而不需要修改原来的类。例如，为一个窗口控件添加滚动条、边框等装饰物。\`\`\`java  
public interface Component \{  
void display();  
\}  
public class ConcreteComponent implements Component \{  
@Override  
public void display() \{  
System.out.println("ConcreteComponent display()");  
\}  
\}  
public abstract class Decorator implements Component \{  
protected Component component;  
public Decorator(Component component) \{  
this.component = component;  
\}  
@Override  
public void display() \{  
component.display();  
\}  
\}  
public class ScrollBarDecorator extends Decorator \{  
public ScrollBarDecorator(Component component) \{  
super(component);  
\}  
@Override  
public void display() \{  
super.display();  
addScrollBar();  
\}  
private void addScrollBar() \{  
System.out.println("Add ScrollBar");  
\}  
\}  
// 使用装饰器模式  
public static void main(String\[\] args) \{  
Component component = new ConcreteComponent();  
Component decorator = new ScrollBarDecorator(component);  
decorator.display();  
\}  
\`\`\`

14. 代理模式：为其他对象提供一种代理以控制对这个对象的访问。例如，为一个远程对象提供本地代理，以隐藏网络细节。\`\`\`java  
public interface Subject \{  
void request();  
\}  
public class RealSubject implements Subject \{  
@Override  
public void request() \{  
System.out.println("RealSubject request()");  
\}  
\}  
public class Proxy implements Subject \{  
private RealSubject realSubject;  
public Proxy(RealSubject realSubject) \{  
this.realSubject = realSubject;  
\}  
@Override  
public void request() \{  
preRequest();  
realSubject.request();  
postRequest();  
\}  
private void preRequest() \{  
System.out.println("PreRequest");  
\}  
private void postRequest() \{  
System.out.println("PostRequest");  
\}  
\}  
// 使用代理模式  
public static void main(String\[\] args) \{  
RealSubject realSubject = new RealSubject();  
Proxy proxy = new Proxy(realSubject);  
proxy.request();  
\}  
\`\`\`