您现在的位置是：首页 >技术交流 >设计模式及代码网站首页技术交流

1、工厂方法模式（Factory Method Pattern）：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。应用场景：当一个类不知道它所必须创建的对象的类时；一个类希望由它的子类来指定它所创建的对象时。
抽象工厂模式（Abstract Factory Pattern）：提供一个接口，用于创建有关联或者依赖的对象簇，而不需要明确指定具体类。应用场景：当有多个相互依赖的对象簇需要创建时；系统需要独立于它的产品的创建、组合和表示时。

2、单例模式（Singleton Pattern）：

确保一个类只有一个实例，并提供一个访问它的全局访问点。应用场景：当一个类只需要一个实例时；一个唯一的实例需要被访问的时候。

3、原型模式（Prototype Pattern）：

用原型实例指定创建对象的种类，并通过复制这个原型来创建新的对象。应用场景：当对象的创建比较复杂或者需要一定的时间开销时；一个系统应该独立于它的产品创建、组合和表示时。

4、建造者模式（Builder Pattern）：

将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。应用场景：当创建复杂对象的算法应该独立于该对象的组成部分以及其装配方式时；需要更好的复用性和可读性。

5、适配器模式（Adapter Pattern）：

将一个类的接口转换成客户希望的另外一个接口。应用场景：当需要使用一个已有的类而它的接口不符合我们的要求时；想要用一个已有的类，但是它不是我们需要的接口时。

1、工厂方法模式

    
    实现：创建一个工厂接口，具体工厂实现接口并返回对应产品的实例
    代码：

public interface Product {
}

public class ConcreteProduct implements Product {
}

public interface Factory {
Product createProduct();
}

public class ConcreteFactory implements Factory {
public Product createProduct() {
return new ConcreteProduct();
}
}

2、抽象工厂模式

    
    实现：创建一个抽象工厂接口，具体工厂实现接口并返回对应产品族的实例
    代码：

public interface Button {
void display();
}

public class WinButton implements Button {
public void display() {
System.out.println("WinButton");
}
}

public class MacButton implements Button {
public void display() {
System.out.println("MacButton");
}
}

public interface GUIFactory {
Button createButton();
}

public class WinFactory implements GUIFactory {
public Button createButton() {
return new WinButton();
}
}

public class MacFactory implements GUIFactory {
public Button createButton() {
return new MacButton();
}
}

3、单例模式

    
    实现：使用静态方法getInstance()获取唯一的实例
    代码：

public class Singleton {
private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

4、原型模式（创新模式）

// 原型接口
public interface Prototype {
public原型模式是通过复制（Clone）一个已有的对象来创建新的对象，而不是通过实例化一个类来创建新对象。原型模式是创建型模式之一，它提供了一种快捷创建对象的方法。

在Java中，原型模式通过实现java.lang.Cloneable接口和重写Object类中的clone()方法来实现。如果一个类想要实现原型模式，需要满足以下两个条件：

1. 实现Cloneable接口，以告知Java虚拟机这个类可以被克隆。
2. 重写Object类中的clone()方法，在其中调用super.clone()方法获取原型对象的副本，然后将其返回。

下面是一个简单的示例：

class Prototype implements Cloneable {
@Override
public Prototype clone() throws CloneNotSupportedException {
return (Prototype) super.clone();
}
}

class ConcretePrototype extends Prototype {
private String field;

public String getField() {
    return field;
}

public void setField(String field) {
    this.field = field;
}

}

public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
ConcretePrototype prototype = new ConcretePrototype();
prototype.setField("123");

    ConcretePrototype clonedPrototype = prototype.clone();
    System.out.println(clonedPrototype.getField()); // "123"
}

}

/**在上面的代码中，我们创建了一个ConcretePrototype类，它继承了Prototype类，并且实现了clone()方法。在client中，我们创建了一个ConcretePrototype对象，然后克隆它并打印出它的field属性值。由于我们实现了原型模式，在克隆时field属性的值也被一同复制了。*/

5、建造者模式

    
    实现：创建一个Builder接口，指定构造顺序，Builder实现类实现Builder接口，将构建结果返回
    代码：

public class Product {
private String partA;
private String partB;
private String partC;

public void setPartA(String partA) {
this.partA = partA;
}

public void setPartB(String partB) {
this.partB = partB;
}

public void setPartC(String partC) {
this.partC = partC;
}
}

public interface Builder {
void buildPartA();
void buildPartB();
void buildPartC();
Product getResult();
}

public class ConcreteBuilder implements Builder {
private Product product = new Product();