最佳答案
面向東西編程（OOP）是一種編程範式，它經由過程利用東西跟類來構造代碼。計劃形式是面向東西編程中處理罕見成績的處理打算，它們可能幫助開辟者寫出更可保護、可擴大年夜跟可復用的代碼。在OOP中，有24種經典的計劃形式，每種形式都針對特定的成績供給了一種處理打算。以下是對這24種計劃形式的具體介紹。
1. 單例形式（Singleton）
單例形式確保一個類只有一個實例，並供給一個全局拜訪點。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2. 工廠方法形式（Factory Method）
工廠方法形式定義一個用於創建東西的介面，讓子類決定實例化哪一個類。
public interface Factory {
Product create();
}
public class ConcreteFactory implements Factory {
public Product create() {
return new ConcreteProduct();
}
}
public class Product {
// Product code and methods
}
3. 抽象工廠形式（Abstract Factory）
抽象工廠形式供給一個介面，用於創建相幹或依附東西的家屬。
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
4. 制作者形式（Builder）
制作者形式將一個複雜東西的構建與它的表示分別，使得同樣的構建過程可能創建差其余表示。
public class Builder {
public void buildPartA() {}
public void buildPartB() {}
}
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public void construct() {
builder.buildPartA();
builder.buildPartB();
}
}
5. 原型形式（Prototype）
原型形式經由過程複製現有的實例來創建新的實例。
public class Prototype implements Cloneable {
public Prototype clone() {
try {
return (Prototype) super.clone();
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
6. 適配器形式（Adapter）
適配器形式容許將一個類的介面轉換成客戶期望的另一個介面。
public class Target {
public void request() {
System.out.println("Target: specific request.");
}
}
public class Adapter extends Target implements Adaptee {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void specificRequest() {
adaptee.request();
}
}
7. 橋接形式（Bridge）
橋接形式將抽象部分與實現部分分別，使它們都可能獨破地變更。
public abstract class Abstraction {
protected Implementation implementation;
public void setImplementation(Implementation implementation) {
this.implementation = implementation;
}
public abstract void operation();
}
public class RefinedAbstraction extends Abstraction {
public void operation() {
implementation operationImpl();
}
}
8. 組合形式（Composite）
組合形式容許你將東西組剖析樹形構造來表示部分-團體的檔次構造。
public abstract class Component {
public abstract void operation();
}
public class Leaf extends Component {
public void operation() {
System.out.println("Leaf operation");
}
}
public class Composite extends Component {
private List<Component> children = new ArrayList<>();
public void add(Component child) {
children.add(child);
}
public void operation() {
for (Component child : children) {
child.operation();
}
}
}
9. 裝潢者形式（Decorator）
裝潢者形式靜態地給一個東西增加一些額定的職責，而不改變其介面。
public class Component {
public void operation() {
// Component operation
}
}
public class Decorator extends Component {
private Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
// Additional responsibilities
}
}
10. 表面形式（Facade）
表面形式供給了一個統一的介面，用來拜訪子體系中的一群介面。
public class SubsystemA {
public void operationA() {
// Subsystem A operation
}
}
public class SubsystemB {
public void operationB() {
// Subsystem B operation
}
}
public class Facade {
private SubsystemA subsystemA;
private SubsystemB subsystemB;
public Facade() {
subsystemA = new SubsystemA();
subsystemB = new SubsystemB();
}
public void operation() {
subsystemA.operationA();
subsystemB.operationB();
}
}
11. 享元形式（Flyweight）
享元形式經由過程共享儘可能多的類似東西來增加內存的利用。
public class Flyweight {
public void operation(String extrinsicState) {
// Operation using extrinsic state
}
}
public class FlyweightFactory {
private Map<String, Flyweight> flyweights = new HashMap<>();
public Flyweight getFlyweight(String key) {
Flyweight result = flyweights.get(key);
if (result == null) {
result = new ConcreteFlyweight(key);
flyweights.put(key, result);
}
return result;
}
}
12. 代辦形式（Proxy）
代辦形式為其他東西供給一種代辦以把持對這個東西的拜訪。
public interface Subject {
void request();
}
public class RealSubject implements Subject {
public void request() {
// Real operation
}
}
public class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void request() {
// Pre-processing
realSubject.request();
// Post-processing
}
}
13. 職責鏈形式（Chain of Responsibility）
職責鏈形式使多個東西都無機會處理懇求，從而避免了懇求發送者跟接收者之間的耦合關係。
public interface Handler {
void handle(Request request);
}
public class ConcreteHandlerA implements Handler {
public void handle(Request request) {
// Handle request
}
}
public class ConcreteHandlerB implements Handler {
public void handle(Request request) {
// Handle request
}
}
14. 命令形式（Command）
命令形式將懇求封裝為一個東西，從而容許用戶利用差其余懇求、行列或日記懇求，以及支撐可打消的操縱。
public interface Command {
void execute();
}
public class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action();
}
}
public class Receiver {
public void action() {
// Receiver action
}
}
15. 闡冥器形式（Interpreter）
闡冥器形式為言語創建一個闡冥器，該闡冥器利用語法分析器來分析言語，並闡明言語中的句子。
public interface Expression {
boolean interpret(String context);
}
public class TerminalExpression implements Expression {
private String data;
public TerminalExpression(String data) {
this.data = data;
}
public boolean interpret(String context) {
return context.contains(data);
}
}
16. 迭代器形式（Iterator）
迭代器形式供給了一種方法次序拜訪一個聚合東西中各個元素，而又不裸露該東西的外部表示。
public interface Iterator {
boolean hasNext();
Object next();
}
public class ConcreteIterator implements Iterator {
private List<Object> list;
private int position;
public ConcreteIterator(List<Object> list) {
this.list = list;
this.position = 0;
}
public boolean hasNext() {
return position < list.size();
}
public Object next() {
Object obj = list.get(position);
position++;
return obj;
}
}
17. 中介者形式（Mediator）
中介者形式定義一個東西來封裝一組東西之間的交互，使東西之間不須要顯式地相互引用，從而降落它們之間的耦合。
public interface Mediator {
void send(String message, Colleague colleague);
}
public class ConcreteMediator implements Mediator {
private Colleague colleagueA;
private Colleague colleagueB;
public void send(String message, Colleague colleague) {
if (colleague == colleagueA) {
colleagueB.receive(message);
} else {
colleagueA.receive(message);
}
}
}
18. 備忘錄形式（Memento）
備忘錄形式捕獲一個東西的外部狀況，並在該東西之外保存這個狀況，以便可能在之後恢復它。
public class Memento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
}
public class Originator {
private String state;
public void setState(String state) {
this.state = state;
}
public Memento saveStateToMemento() {
return new Memento(state);
}
public void getStateFromMemento(Memento memento) {
state = memento.getState();
}
}
19. 察看者形式（Observer）
察看者形式定義東西之間的一對多依附關係，當一個東西改變狀況時，全部依附於它的東西都會掉掉落告訴並主動更新。
public interface Observer {
void update(String message);
}
public class ConcreteObserver implements Observer {
public void update(String message) {
// Update observer
}
}
public class Subject {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
20. 狀況形式（State）
狀況形式容許一個東西在其外部狀況改變時改變它的行動。
public interface State {
void handle(Context context);
}
public class ConcreteStateA implements State {
public void handle(Context context) {
// Handle context in state A
}
}
public class Context {
private State state;
public void setState(State state) {
this.state = state;
}
public void request() {
state.handle(this);
}
}
21. 戰略形式（Strategy）
戰略形式定義一系列演算法，把它們一個個封裝起來，並使它們可相互調換。
public interface Strategy {
void execute();
}
public class ConcreteStrategyA implements Strategy {
public void execute() {
// Execute strategy A
}
}
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
22. 模板方法形式（Template Method）
模板方法形式定義一個操縱中的演算法的骨架，而將一些步調耽誤到子類中。
public abstract class AbstractClass {
public final void templateMethod() {
primitiveOperation1();
abstractMethod();
primitiveOperation2();
}
protected abstract void abstractMethod();
protected void primitiveOperation1() {
// Implementation
}
protected void primitiveOperation2() {
// Implementation
}
}
23. 拜訪者形式（Visitor）
拜訪者形式表示一個感化於某東西構造中的各元素的操縱，它使你可能在不改變各元素類的前提下定義感化於這些元素的新操縱。
public interface Visitor {
void visit(ConcreteElementA elementA);
void visit(ConcreteElementB elementB);
}
public class ConcreteVisitor implements Visitor {
public void visit(ConcreteElementA elementA) {
// Visit element A
}
public void visit(ConcreteElementB elementB) {
// Visit element B
}
}
public abstract class Element {
public abstract void accept(Visitor visitor);
}
public class ConcreteElementA extends Element {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
public class ConcreteElementB extends Element {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
24. 模板形式（Visitor）
模板形式表示一個感化於某東西構造中的各元素的操縱，它使你可能在不改變各元素類的前提下定義感化於這些元素的新操縱。
public interface Visitor {
void visit(ConcreteElementA elementA);
void visit(ConcreteElementB elementB);
}
public class ConcreteVisitor implements Visitor {
public void visit(ConcreteElementA elementA) {
// Visit element A
}
public void visit(ConcreteElementB elementB) {
// Visit element B
}
}
public abstract class Element {
public abstract void accept(Visitor visitor);
}
public class ConcreteElementA extends Element {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
public class ConcreteElementB extends Element {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
以上就是面向東西編程中的24種經典計劃形式的具體介紹。每種形式都有其特定的用處跟上風，開辟者可能根據現實須要抉擇合適的計劃形式來進步代碼的品質跟可保護性。