设计模式-创建型模式

115 阅读 0 评论 76 点赞

我是靠谱客的博主迅速枫叶，这篇文章主要介绍设计模式-创建型模式，现在分享给大家，希望可以做个参考。

1、创建型模式的含义

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

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

3、①abstract factory(抽象工厂)

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

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

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

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

代码：

复制代码

1
2
3
public abstract class Fruit {
    abstract void show();
}

复制代码

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

复制代码

1
2
3
4
5
6
public class ChineseFruit extends Fruit{

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

复制代码

1
2
3
public abstract class Meat {
    abstract void show();
}

复制代码

1
2
3
4
5
public class ChineseMeat extends Meat{
    void show() {
        System.out.println("ChineseMeat");
    }
}

复制代码

1
2
3
4
5
public class AmericanMeat extends Meat {
    void show() {
        System.out.println("AmericanMeat");
    }
}

复制代码

1
2
3
4
public interface ProduceFactory {
    Meat productMeat();
    Fruit productFruit();
}

复制代码

1
2
3
4
5
6
7
8
9
public class AmericanFactory implements ProduceFactory{
    public Meat productMeat() {
        return new AmericanMeat();
    }

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

复制代码

1
2
3
4
5
6
7
8
9
public class ChineseFactory implements ProduceFactory {
    public Meat productMeat() {
        return new ChineseMeat();
    }

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

复制代码

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args){
        ProduceFactory produceFactory = new ChineseFactory();
        produceFactory.productFruit().show();
        produceFactory.productMeat().show();
    }
}

结果 I am from china
ChineseMeat

②builder（生成器模式）

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

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

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

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

代码：

//车

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
public class Car {
    protected String color;
    protected Integer length;

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

复制代码

1
//生成器接口

复制代码

1
2
3
4
5
6
7
public abstract class CarBuilder {
    protected Car car;
    public abstract void buildCar();
    public abstract void buildColor();
    public abstract void buildLength();
    public abstract Car getCar();
}

复制代码

1
//具体生成器

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
    }
}

复制代码

1
2
3
4
5
6
7
8
9
10
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);
    }
}

结果：Car{color='red', length=18}

③factory method（工厂方法）

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

代码：

//抽象类车

复制代码

1
2
3
public abstract class Car {
    public abstract void run();
}

复制代码

1
//具体中国车

复制代码

1
2
3
4
5
public class ChinaCar extends Car{
    public void run() {
        System.out.println("run on China");
    }
}

复制代码

1
//美国车

复制代码

1
2
3
4
5
6
7
8
9
复制代码public class AmericaCar extends Car{
    public void run() {
        System.out.println("run on America");
    }
}public class AmericaCar extends Car{
    public void run() {
        System.out.println("run on America");
    }
}
复制代码//工厂//工厂

复制代码

1
2
3
public abstract class CarFactory {
    abstract Car productCar();
}

复制代码

1
//美国工厂

复制代码

1
2
3
4
5
public class AmericaFactory extends CarFactory{
    Car productCar() {
        return new AmericaCar();
    }
}

复制代码

1
//中国工厂

复制代码

1
2
3
4
5
public class ChinaFactory extends CarFactory{
    Car productCar() {
        return new ChinaCar();
    }
}

复制代码

1
//生产车

复制代码

1
2
3
4
5
6
7
8
public class Client {
    public static void main(String[] args){
        CarFactory carFactory = new AmericaFactory();
        carFactory.productCar().run();
        carFactory = new ChinaFactory();
        carFactory.productCar().run();
    }
}

复制代码

1
//结果

复制代码

1
2
run on America
run on China

对比：工厂方法模式和抽象工厂模式

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个

抽象工厂注重不同系列产品的创建。

④prototype（原型）

目的：用原型实例制定创建对象的种类，并且通过拷贝这些原型创建新的对象。

适用性：主要用于克隆。

代码：略

⑤singleton(单例)

目的：用于创建全局只有一个实例的对象。

例如工厂模式中的工厂，我只需要一个工厂。

单例模式又分为饥饿模式与懒汉模式。

饥饿模式，当类加载时就被创建。

代码：

public class Singleten{

private static Factory factory = new Factory();

private Singlten(){

}

public static Factory getFactory(){

return factory;

}

懒汉模式：

public class Singleten{

private static Factory factory ;

private Singlten(){

}

public static Factory getFactory(){

if(factory == null){

factory = new Factory();

}

return factory;

}

注意：在多线程环境下需要加锁

public class Singleten{

private static volatile Factory factory ;

private Singlten(){

}

public static Factory getFactory(){

if(factory == null){

syncronized(Singleten.class){

if(factory == null){

factory = new Factory();

}

return factory;

}

最后

以上就是迅速枫叶最近收集整理的关于设计模式-创建型模式的全部内容，更多相关设计模式-创建型模式内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：设计模式
浏览次数：115 次浏览
发布日期：2023-11-17 19:45:02
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_o_14_f3_14__23_gy.html

设计模式-创建型模式

最后

评论列表共有 0 条评论

发表评论取消回复

设计模式-创建型模式

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复