设计模式-创建型模式

1、创建型模式的含义

创建型模式抽象了实例化的过程。它们帮助系统如何创建、组合和表示对象。说白了是一种基本对象创建的设计模式。

2、创建型模式有好多种：①abstract factory(抽象工厂)②builder(生成器)③factory method（工厂方法）④prototype（原型）⑤singleton(单例)

3、①abstract factory(抽象工厂)

目的：是提供一系列相关或相互依赖的对象的接口。

适用性：一个系统要独立创建、组合和表示对象。

一个系统要由多个产品系列来表示。

结构：顶层为抽象工厂，提供创建多个对象的接口，采用不同系列的具体工厂去实现抽象工厂，生成对象。

代码：

public abstract class Fruit {
    abstract void show();
}

public class AmericanFruit extends Fruit{
    void show() {
        System.out.println("I am from American");
    }
}

public class ChineseFruit extends Fruit{

    void show() {
        System.out.println(" I am from china");
    }
}

public abstract class Meat {
    abstract void show();
}

public class ChineseMeat extends Meat{
    void show() {
        System.out.println("ChineseMeat");
    }
}

public class AmericanMeat extends Meat {
    void show() {
        System.out.println("AmericanMeat");
    }
}

public interface ProduceFactory {
    Meat productMeat();
    Fruit productFruit();
}

public class AmericanFactory implements ProduceFactory{
    public Meat productMeat() {
        return new AmericanMeat();
    }

    public Fruit productFruit() {
        return new AmericanFruit();
    }
}

public class ChineseFactory implements ProduceFactory {
    public Meat productMeat() {
        return new ChineseMeat();
    }

    public Fruit productFruit() {
        return new ChineseFruit();
    }
}

public class Client {
    public static void main(String[] args){
        ProduceFactory produceFactory = new ChineseFactory();
        produceFactory.productFruit().show();
        produceFactory.productMeat().show();
    }
}

②builder（生成器模式）

目的：将复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

适用性：当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时。

当构造过程必须允许被构造的对象有不同的表示时。

场景:当我们需要构建一个复杂的东西时，当用普通的工厂模式去构建，我们需要将构建出的器件再进行装配，采用builder模式，我们可以内部实现装配，最后生成具体的成品。

代码：

//车

public class Car {
    protected String color;
    protected Integer length;

    @Override
    public String toString() {
        return "Car{" +
                "color='" + color + ''' +
                ", length=" + length +
                '}';
    }
}

//生成器接口

public abstract class CarBuilder {
    protected Car car;
    public abstract void buildCar();
    public abstract void buildColor();
    public abstract void buildLength();
    public abstract Car getCar();
}

//具体生成器

public class ChineseBuilder extends CarBuilder{
    public void buildCar() {
        this.car = new Car();
    }

    public void buildColor() {
        this.car.color = "red";
    }

    public void buildLength() {
        this.car.length = 18;
    }

    public Car getCar() {
        return this.car;
    }
}

public class Client {
    public static void main(String[] args){
        CarBuilder carBuilder = new ChineseBuilder();
        carBuilder.buildCar();
        carBuilder.buildColor();
        carBuilder.buildLength();
        Car car = carBuilder.getCar();
        System.out.println(car);
    }
}

③factory method（工厂方法）

目的：定义用于创建对象的接口，让子类实现如何创建。

代码：

//抽象类车

public abstract class Car {
    public abstract void run();
}	

//具体中国车

public class ChinaCar extends Car{
    public void run() {
        System.out.println("run on China");
    }
}

//美国车

public class AmericaCar extends Car{
    public void run() {
        System.out.println("run on America");
    }
}
//工厂

public abstract class CarFactory {
    abstract Car productCar();
}

//美国工厂

public class AmericaFactory extends CarFactory{
    Car productCar() {
        return new AmericaCar();
    }
}

//中国工厂

public class ChinaFactory extends CarFactory{
    Car productCar() {
        return new ChinaCar();
    }
}

//生产车

public class Client {
    public static void main(String[] args){
        CarFactory carFactory = new AmericaFactory();
        carFactory.productCar().run();
        carFactory = new ChinaFactory();
        carFactory.productCar().run();
    }
}

//结果

run on America
run on China

最后

以上就是迅速枫叶为你收集整理的设计模式-创建型模式的全部内容，希望文章能够帮你解决设计模式-创建型模式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。