面向东西编程（OOP）是一种编程范式，它经由过程利用东西跟类来构造代码。计划形式是面向东西编程中处理罕见成绩的处理打算，它们可能帮助开辟者写出更可保护、可扩大年夜跟可复用的代码。在OOP中，有24种经典的计划形式，每种形式都针对特定的成绩供给了一种处理打算。以下是对这24种计划形式的具体介绍。
单例形式确保一个类只有一个实例，并供给一个全局拜访点。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
工厂方法形式定义一个用于创建东西的接口，让子类决定实例化哪一个类。
public interface Factory {
Product create();
}
public class ConcreteFactory implements Factory {
public Product create() {
return new ConcreteProduct();
}
}
public class Product {
// Product code and methods
}
抽象工厂形式供给一个接口，用于创建相干或依附东西的家属。
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
制作者形式将一个复杂东西的构建与它的表示分别，使得同样的构建过程可能创建差其余表示。
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();
}
}
原型形式经由过程复制现有的实例来创建新的实例。
public class Prototype implements Cloneable {
public Prototype clone() {
try {
return (Prototype) super.clone();
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
适配器形式容许将一个类的接口转换成客户期望的另一个接口。
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();
}
}
桥接形式将抽象部分与实现部分分别，使它们都可能独破地变更。
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();
}
}
组合形式容许你将东西组剖析树形构造来表示部分-团体的档次构造。
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();
}
}
}
装潢者形式静态地给一个东西增加一些额定的职责，而不改变其接口。
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
}
}
表面形式供给了一个同一的接口，用来拜访子体系中的一群接口。
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();
}
}
享元形式经由过程共享尽可能多的类似东西来增加内存的利用。
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;
}
}
代办形式为其他东西供给一种代办以把持对这个东西的拜访。
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
}
}
职责链形式使多个东西都无机会处理恳求，从而避免了恳求发送者跟接收者之间的耦合关联。
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
}
}
命令形式将恳求封装为一个东西，从而容许用户利用差其余恳求、行列或日记恳求，以及支撑可打消的操纵。
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
}
}
阐冥器形式为言语创建一个阐冥器，该阐冥器利用语法分析器来分析言语，并阐明言语中的句子。
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);
}
}
迭代器形式供给了一种方法次序拜访一个聚合东西中各个元素，而又不裸露该东西的外部表示。
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;
}
}
中介者形式定义一个东西来封装一组东西之间的交互，使东西之间不须要显式地相互引用，从而降落它们之间的耦合。
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);
}
}
}
备忘录形式捕获一个东西的外部状况，并在该东西之外保存这个状况，以便可能在之后恢复它。
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();
}
}
察看者形式定义东西之间的一对多依附关联，当一个东西改变状况时，全部依附于它的东西都会掉掉落告诉并主动更新。
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);
}
}
}
状况形式容许一个东西在其外部状况改变时改变它的行动。
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);
}
}
战略形式定义一系列算法，把它们一个个封装起来，并使它们可相互调换。
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();
}
}
模板方法形式定义一个操纵中的算法的骨架，而将一些步调耽误到子类中。
public abstract class AbstractClass {
public final void templateMethod() {
primitiveOperation1();
abstractMethod();
primitiveOperation2();
}
protected abstract void abstractMethod();
protected void primitiveOperation1() {
// Implementation
}
protected void primitiveOperation2() {
// Implementation
}
}
拜访者形式表示一个感化于某东西构造中的各元素的操纵，它使你可能在不改变各元素类的前提下定义感化于这些元素的新操纵。
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);
}
}
模板形式表示一个感化于某东西构造中的各元素的操纵，它使你可能在不改变各元素类的前提下定义感化于这些元素的新操纵。
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种经典计划形式的具体介绍。每种形式都有其特定的用处跟上风，开辟者可能根据现实须要抉择合适的计划形式来进步代码的品质跟可保护性。