java中的设计模式 - 六个创建模式(完整代码)

最新推荐文章于 2024-08-10 06:00:00 发布

zzqtty

最新推荐文章于 2024-08-10 06:00:00 发布

阅读量282

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/zzqtty/article/details/113885639

版权

设计模式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.简单工厂模式

定义：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态 (static)方法，因此简单工厂模式又被称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。

汽车为例，只需要告诉工厂你要什么汽车，汽车工厂会自动创建汽车。

汽车工厂代码：
package com.example.demo.simpleFactory;

public class BenChiCar implements Car {
    @Override
    public void run() {
        System.out.println("i an run benChi .....");
    }
}


package com.example.demo.simpleFactory;

public interface Car {

    public void run();

}


package com.example.demo.simpleFactory;

public class SimpleFactory {

    public static Car buildCar(Class<? extends Car> c) throws IllegalAccessException, InstantiationException {
        Car car = c.newInstance();
        return car;
    }

}



package com.example.demo.simpleFactory;

public class Test {

    public static void main(String args[]) throws InstantiationException, IllegalAccessException {

        SimpleFactory factory = new SimpleFactory();
        Car car = factory.buildCar(TslCar.class);
        car.run();

        Car car1 = factory.buildCar(BenChiCar.class);
        car1.run();

    }
}



package com.example.demo.simpleFactory;

public class TslCar implements Car {
    @Override
    public void run() {
        System.out.println("i am run TSL car ......");
    }
}
运行结果

i am run TSL car ......
i an run benChi .....

这里的SimpleFactory中的bulid 为非static也可以运行。

2.工厂方法模式

在简单工厂模式中只提供一个工厂类，该工厂类处于对产品类进行实例化的中心位置，它需要知道每

一个产品对象的创建细节，并决定何时实例化哪一个产品类。简单工厂模式最大的缺点是当有新产品

要加入到系统中时，必须修改工厂类，需要在其中加入必要的业务逻辑，这违背了 “ 开闭原则 ” 。此

外，在简单工厂模式中，所有的产品都由同一个工厂创建，工厂类职责较重，业务逻辑较为复杂，具

体产品与工厂类之间的耦合度高，严重影响了系统的灵活性和扩展性，而工厂方法模式则可以很好地

解决这一问题。

在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提

供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构。工厂方法模式定义如下：

工厂方法模式 (Factory Method Pattern) ：定义一个用于创建对象的接口，让子类决定将哪一个

类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式

(Factory Pattern) ，又可称作虚拟构造器模式 (Virtual Constructor Pattern) 或多态工厂

模式 (Polymorphic Factory Pattern) 。工厂方法模式是一种类创建型模式。

汽车工程模式：
package com.example.demo.factory;

public class BenChiCar implements Car {
    @Override
    public void run() {
        System.out.println("i an run benChi .....");
    }
}


package com.example.demo.factory;

public class BenChiCarFactory implements Factory{

    @Override
    public Car BuildCar() {
        return new BenChiCar();
    }
}



package com.example.demo.factory;

public interface Car {

    public void run();

}



package com.example.demo.factory;

public interface Factory {

    public Car BuildCar();
}



package com.example.demo.factory;

public class Test {

    public static void main(String args[]){
        Factory benChiFactory = new BenChiCarFactory();

        Car car = benChiFactory.BuildCar();

        car.run();
    }
}



package com.example.demo.factory;

public class TslCar implements Car {
    @Override
    public void run() {
        System.out.println("i am run TSL car ......");
    }
}




package com.example.demo.factory;

public class TslCarFactory implements Factory {

    @Override
    public Car BuildCar() {
        return new TslCar();
    }
}

3.抽象工厂模式

有时候，为了进一步简化客户端的使用，还可以对客户端隐藏工厂方法，此时，在工厂类中将直接调

用产品类的业务方法，客户端无须调用工厂方法创建产品，直接通过工厂即可使用所创建的对象中的

业务方法。

抽象汽车工程代码实现：

package com.example.demo.abstractfactory;


public abstract class AbstractFactory {

    public void  getCar(){
        Car car = this.buildCar();
        car.run();
    }

    public abstract Car buildCar();
}



package com.example.demo.abstractfactory;

public class BenChiCar implements Car {
    @Override
    public void run() {
        System.out.println("i an run benChi .....");
    }
}



package com.example.demo.abstractfactory;

public class BenChiCarFactory extends AbstractFactory {

    public Car buildCar() {
        BenChiCar benChiCar = new BenChiCar();
        return benChiCar;
    }
}



package com.example.demo.abstractfactory;

public interface Car {

    public  void run();

}



package com.example.demo.abstractfactory;


public class Test {

    public static void main(String args[]){
        AbstractFactory benChiFactory = new BenChiCarFactory();
        benChiFactory.getCar();

    }
}



package com.example.demo.abstractfactory;

public class TslCar implements Car {
    @Override
    public void run() {
        System.out.println("i am run TSL car ......");
    }
}



package com.example.demo.abstractfactory;

public class TslCarFactory extends AbstractFactory {

    @Override
    public TslCar buildCar() {
        return new TslCar() ;
    }
}

4.单例模式

单例模式 (Singleton Pattern) ：确保某一个类只有一个实例，而且自行实例化并向整个系统提供

这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

汽车单例代码：

package com.example.demo.singleton;

public class MyCar2 {

    //懒汉模式
    private static MyCar2 myCar2;

    private MyCar2(){}

    private static synchronized MyCar2 getInstance(){
        if(null == myCar2){
            return new MyCar2();
        }else {
            return myCar2;
        }
    }
}


package com.example.demo.singleton;

public class MyCar {

    //饿汉模式
    private static MyCar myCar = new MyCar();

    //构造器私有化
    private MyCar(){}

    public static MyCar getInstance(){
        return myCar;
    }

    public void  run(){
        System.out.println(myCar.toString());
    }
}

5.原型模式

原型模式 (Prototype Pattern) ：使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建

新的对象。原型模式是一种对象创建型模式

克隆对象代码实现：
package com.example.demo.singleton;

public class MyCar implements Cloneable{

    //饿汉模式
    private static MyCar myCar = new MyCar();

    //构造器私有化
    private MyCar(){}

    public static MyCar getInstance(){
        return myCar;
    }

    public void  run() throws CloneNotSupportedException {
        Object clone = super.clone();
        System.out.println(myCar.toString());
        System.out.println(clone.toString());
    }
}
结果：

com.example.demo.singleton.MyCar@7cca494b
com.example.demo.singleton.MyCar@7ba4f24f

克隆出来的对象不是同一个对象

6.建造者模式

建造者模式 (Builder Pattern) ：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可

以创建不同的表示。建造者模式是一种对象创建型模式。

汽车建造者代码实现:

package com.example.demo.builder;

public interface Builder {

    public void buildModel();

    public void buildCircle();

    public BydCar getCar();

}



package com.example.demo.builder;

public class BydCar {

    //汽车模具
    private String modelCar;

    //汽车轮子
    private String circle;

    public String getModelCar() {
        return modelCar;
    }

    public void setModelCar(String modelCar) {
        this.modelCar = modelCar;
    }

    public String getCircle() {
        return circle;
    }

    public void setCircle(String circle) {
        this.circle = circle;
    }
}




package com.example.demo.builder;

public class CarBuilder implements Builder {
    public BydCar bydCar;

    public CarBuilder(BydCar bydCar) {
        this.bydCar = bydCar;
    }

    @Override
    public void buildModel() {
        bydCar.setModelCar("model build success");
    }

    @Override
    public void buildCircle() {

        bydCar.setCircle("circle build success");
    }

    @Override
    public BydCar getCar() {
        return bydCar;
    }
}




package com.example.demo.builder;

public class Director {


    public BydCar create(Builder builder){
        builder.buildModel();
        builder.buildCircle();
        return builder.getCar();
    }

}




package com.example.demo.builder;

public class Test {

    public static void main(String args[]){
        Director director = new Director();

        Builder builder = new CarBuilder(new BydCar());

        BydCar bydCar = director.create(builder);

        System.out.println(bydCar.getCircle());
    }
}