JAVA基础（设计模式）-创建型模式0.设计模式概念1.设计模式7大原则 2.简单工厂模式和工厂方法模式3.抽象工厂模式 4.建造者模式5.原型模式

137 阅读 0 评论 91 点赞

我是靠谱客的博主无辜悟空，最近开发中收集的这篇文章主要介绍JAVA基础（设计模式）-创建型模式0.设计模式概念1.设计模式7大原则 2.简单工厂模式和工厂方法模式3.抽象工厂模式 4.建造者模式5.原型模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

0.设计模式概念

1.设计模式7大原则

2.简单工厂模式和工厂方法模式

2.1.工厂模式的概念和意义

2.2 简单工厂模式代码实现：

2.3.工厂方法模式代码实现：

2.4.代码结构与总结

3.抽象工厂模式

3.1概念

3.2.代码和结构

4.建造者模式

4.1.概念

4.2.传统建造者模式代码

4.3.建造者模式改进版（用户自定义）

5.原型模式

5.1.基本概念

5.2.浅克隆模式代码

5.3.深克隆模式代码

0.设计模式概念

1.设计模式7大原则

2.简单工厂模式和工厂方法模式

创建性模式：帮助我们去创建对象，不用new；

2.1.工厂模式的概念和意义

2.2 简单工厂模式代码实现：

//抽象产品类
public interface Car {
    void  name();
}

//具体产品类
public class DZCar implements Car{
    @Override
    public void name() {
        System.out.println("欢迎购买大众车！");
    }
}

//具体产品类
public class BWCar implements Car{
    @Override
    public void name() {
        System.out.println("欢迎购买宝马车！");
    }
}

//工厂类
//优点：解耦，不用直接创建对象。
//问题：添加产品必须改变工厂类，不符合开闭原则
public class CarFactory {
    static  Car getCar(String name){
        String  BW="宝马";
        String  DZ="大众";
        if(name==BW){
            return  new BWCar();
        }
        else if(name==DZ){
            return  new DZCar();
        }
        else {
            return null;
        }

    }
}

//测试类
public class main {
    public static void main(String[] args) {
        //传统方法创建对象
      /* Car car1=new BWCar();
        Car car2=new DZCar(); */

        //使用简单工厂模式创建对象
        Car car1=CarFactory.getCar("宝马");
        Car car2=CarFactory.getCar("大众");
        car1.name();
        car2.name();
    }

}

2.3.工厂方法模式代码实现：

//抽象产品类
public interface Car {
    void  name();
}

//具体产品类
public class DZCar implements Car{
    @Override
    public void name() {
        System.out.println("欢迎购买大众车！");
    }
}

//具体产品类
public class BWCar implements Car{
    @Override
    public void name() {
        System.out.println("欢迎购买宝马车！");
    }
}

//工厂方法模式
//注意：静态方法不能被重写
//优点：可以动态的添加产品，不修改原来的工厂，符合开闭原则
//问题：新增一个产品就要新增一个具体工厂类，会造成类太多，不利于管理，因此需要合理使用工厂模式
public interface AbstractFactory {
    Car getCar();
}

//具体工厂类
public class BWCarFactory implements AbstractFactory {

    @Override
    public  Car getCar() {
        return new BWCar();
    }
}

//具体工厂类
public class DZCarFactory implements AbstractFactory {

    @Override
    public  Car getCar() {
        return new DZCar();
    }
}

//测试类
public class main {
    public static void main(String[] args) {
        //传统方法创建对象
      /* Car car1=new BWCar();
        Car car2=new DZCar(); */

        //使用工厂方法模式创建对象
        Car car1= new DZCarFactory().getCar();
        Car car2= new BWCarFactory().getCar();
        car1.name();
        car2.name();
    }

}

2.4.代码结构与总结

3.抽象工厂模式

3.1概念

3.2.代码和结构

//抽象产品类
public interface Car {
    void  name();
}

//抽象产品类
public interface Bike {
    void  name();
}

//具体产品类
public class BWBike implements Bike {
    @Override
    public void name() {
        System.out.println("欢迎购买宝马自行车！");
    }
}

//具体产品类
public class DZBike implements Bike {
    @Override
    public void name() {
        System.out.println("欢迎购买大众自行车！");
    }
}

//具体产品类
public class DZCar implements Car {
    @Override
    public void name() {
        System.out.println("欢迎购买大众汽车！");
    }
}

//具体产品类
public class BWCar implements Car {
    @Override
    public void name() {
        System.out.println("欢迎购买宝马汽车！");
    }
}

//抽象工厂
//产品族，同一家公司生产的所有产品称为一个产品族，例如：宝马公司生产的自行车和汽车，因为都是宝马公司生产的，就是一个产品族
//产品等级，不同公司生产的同一种产品称为一个产品等级，例如：宝马公司生产的自行车和大众公司生产的自行车，因为都是自行车，就是一个产品等级
//注意：静态方法不能被重写
//优点：可以动态的添加产品族，不修改原来的工厂，符合开闭原则
//问题：系统抽象，难以理解，在一个产品族中添加一个新产品，需要修改代码，不符合开闭原则
public interface AbstractFactory {
    Car getCarName();
    Bike getBikeName();
}

//具体工厂类
public class BWFactory implements AbstractFactory {

    @Override
    public Car getCarName() {
        return new BWCar();
    }

    @Override
    public Bike getBikeName() {
        return new BWBike();
    }
}

//具体工厂类
public class DZFactory implements AbstractFactory {


    @Override
    public Car getCarName() {
        return new DZCar();
    }

    @Override
    public Bike getBikeName() {
        return new DZBike();
    }
}

//测试类
public class main {
    public static void main(String[] args) {
        //传统方法创建对象
      /* Car car1=new BWCar();
        Car car2=new DZCar(); */

        //使用抽象工厂模式创建对象
        Car car1= new DZFactory().getCarName();
        Car car2= new BWFactory().getCarName();
        Bike bike1=new DZFactory().getBikeName();
        Bike bike2=new  BWFactory().getBikeName();
        car1.name();
        car2.name();
        bike1.name();
        bike2.name();
    }

}

4.建造者模式

4.1.概念

4.2.传统建造者模式代码

//抽象建造者
public abstract class Builder {
          abstract  void   A();
          abstract  void   B();
          abstract  void   C();
          abstract   void   D();

          abstract   Product   getProduct();

}

//具体建造者：在构造器里面创建product对象，再进行具体的对象操作，最后返回真实的product
public class Worker extends  Builder{

    private  Product product;


    public Worker() {
         product = new Product();
    }

    @Override
    void A() {
        product.setFirst("执行A操作");
        System.out.println("执行A操作");
    }

    @Override
    void B() {
        product.setSecond("执行B操作");
        System.out.println("执行B操作");
    }

    @Override
    void C() {
        product.setThird("执行C操作");
        System.out.println("执行C操作");
    }

    @Override
    void D() {
        product.setFourth("执行D操作");
        System.out.println("执行D操作");
    }

    @Override
    Product getProduct() {
        return product;
    }
}

//产品类
public class Product {

    private  String  first;
    private  String  second;
    private    String third;
    private   String  fourth;

    public void setFirst(String first) {
        this.first = first;
    }

    public void setSecond(String second) {
        this.second = second;
    }

    public void setThird(String third) {
        this.third = third;
    }

    public void setFourth(String fourth) {
        this.fourth = fourth;
    }

    public String getFirst() {
        return first;
    }

    public String getSecond() {
        return second;
    }

    public String getThird() {
        return third;
    }

    public String getFourth() {
        return fourth;
    }

    @Override
    public String toString() {
        return "Product{" +
                "first='" + first + ''' +
                ", second='" + second + ''' +
                ", third='" + third + ''' +
                ", fourth='" + fourth + ''' +
                '}';
    }
}

//指挥者类：负责指挥建造者，安排建造的顺序。
public class Director {
    Product getProduct(Builder builder){
        builder.A();
        builder.B();
        builder.C();
        builder.D();

        return  builder.getProduct();
    }
}

//测试类
public class main {
    public static void main(String[] args) {
        Product product=new Director().getProduct(new Worker());
        System.out.println(product);
    }

}

4.3.建造者模式改进版（用户自定义）

//抽象建造者
public abstract class Builder {
          abstract  Builder   A(String msg);
          abstract  Builder   B(String msg);
          abstract  Builder   C(String msg);
          abstract   Builder   D(String msg);

          abstract Product getProduct();

}

//具体建造者：在构造器里面创建product对象，再进行具体的对象操作，返回这个类this,得到产品；
public class Worker extends Builder {

    private Product product;


    public Worker() {
         product = new Product();
    }

    @Override
    Builder A(String msg) {
        product.setFirst(msg);
        System.out.println("替换了"+msg);
        return  this;
    }

    @Override
    Builder B(String msg) {
        product.setSecond(msg);
        System.out.println("替换了"+msg);
        return  this;
    }

    @Override
    Builder C(String msg) {
        product.setThird(msg);
        System.out.println("替换了"+msg);
        return  this;
    }

    @Override
    Builder D(String msg) {
        product.setFourth(msg);
        System.out.println("替换了"+msg);
        return  this;
    }

    @Override
    Product getProduct() {
        return product;
    }
}

//产品类
public class Product {

    private  String  first="可乐";
    private  String  second="鸡翅";
    private    String third="汉堡";
    private   String  fourth="炸鸡";

    public void setFirst(String first) {
        this.first = first;
    }

    public void setSecond(String second) {
        this.second = second;
    }

    public void setThird(String third) {
        this.third = third;
    }

    public void setFourth(String fourth) {
        this.fourth = fourth;
    }

    public String getFirst() {
        return first;
    }

    public String getSecond() {
        return second;
    }

    public String getThird() {
        return third;
    }

    public String getFourth() {
        return fourth;
    }

    @Override
    public String toString() {
        return "Product{" +
                "first='" + first + ''' +
                ", second='" + second + ''' +
                ", third='" + third + ''' +
                ", fourth='" + fourth + ''' +
                '}';
    }
}

//测试类
//用户自己决定需要的产品，直接调用worker；
public class main {
    public static void main(String[] args) {
        Worker worker=new Worker();
        Product product=worker.A("雪碧").getProduct();
        System.out.println(product);
    }

}

5.原型模式

5.1.基本概念

5.2.浅克隆模式代码

//产品类
//浅克隆模式：复制的是指向对象的地址，当对象指向的地址发生改变，复制类也会跟着改变
//需要实现Cloneable接口，重写clone方法
public class Video implements  Cloneable {
    private   String name;
    private Date  createDate;


    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Video(String name, Date createDate) {
        this.name = name;
        this.createDate = createDate;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "Video{" +
                "name='" + name + ''' +
                ", createDate=" + createDate +
                '}';
    }
}

//测试类
public class main {

    public static void main(String[] args) {
        //创建一个对象
        Date date =new Date();
        String  name="HHH";
        Video video1=new Video(name,date);
        //注意：String的值是不能被改变的：如 name="ddd"是不合法的;
        //传统的创建另一个相同对象
        //Video video2=new Video(name,date);

        //利用原型模式创建一个相同对象,需要抛出异常和强制类型转换
        Video video2= null;
        try {
            video2 = (Video)video1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        System.out.println(video1);
        System.out.println(video1.hashCode());
        System.out.println(video2);
        System.out.println(video2.hashCode());

        //存在的问题，当原型改变后，复制的对象也会跟着改变，这是不符合要求的
        date.setDate(444444444);

        System.out.println(video1);
        System.out.println(video1.hashCode());
        System.out.println(video2);
        System.out.println(video2.hashCode());

    }
}

5.3.深克隆模式代码

//产品类
//深克隆模式：复制的是所有的内容，当对象指向的地址发生改变，复制类不会改变
//需要实现Cloneable接口，重写clone方法，修改这个方法
public class Video implements  Cloneable {
    private   String name;
    private Date  createDate;


    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object clone = super.clone();
        Video video=(Video)  clone;
        video.createDate= (Date) this.createDate.clone();
        return video;
    }

    public Video(String name, Date createDate) {
        this.name = name;
        this.createDate = createDate;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "Video{" +
                "name='" + name + ''' +
                ", createDate=" + createDate +
                '}';
    }
}

//测试类
public class main {

    public static void main(String[] args) {
        //创建一个对象
        Date date =new Date();
        String  name="HHH";
        Video video1=new Video(name,date);
        //注意：String的值是不能被改变的：如 name="ddd"是不合法的;
        //传统的创建另一个相同对象
        //Video video2=new Video(name,date);

        //利用原型模式创建一个相同对象,需要抛出异常和强制类型转换
        Video video2= null;
        try {
            video2 = (Video)video1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        System.out.println(video1);
        System.out.println(video1.hashCode());
        System.out.println(video2);
        System.out.println(video2.hashCode());

        //解决问题，当原型改变后，复制的对象不会跟着改变，符合要求
        date.setDate(444444444);

        System.out.println(video1);
        System.out.println(video1.hashCode());
        System.out.println(video2);
        System.out.println(video2.hashCode());

    }
}

最后

以上就是无辜悟空为你收集整理的JAVA基础（设计模式）-创建型模式0.设计模式概念1.设计模式7大原则 2.简单工厂模式和工厂方法模式3.抽象工厂模式 4.建造者模式5.原型模式的全部内容，希望文章能够帮你解决JAVA基础（设计模式）-创建型模式0.设计模式概念1.设计模式7大原则 2.简单工厂模式和工厂方法模式3.抽象工厂模式 4.建造者模式5.原型模式所遇到的程序开发问题。

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

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

本文分类：java
浏览次数：137 次浏览
发布日期：2023-11-17 20:00:03
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_o_14_f3_14__23_kx.html

JAVA基础（设计模式）-创建型模式0.设计模式概念1.设计模式7大原则 2.简单工厂模式和工厂方法模式3.抽象工厂模式 4.建造者模式5.原型模式

概述

0.设计模式概念

1.设计模式7大原则

2.简单工厂模式和工厂方法模式

2.1.工厂模式的概念和意义

2.2 简单工厂模式代码实现：

2.3.工厂方法模式代码实现：

2.4.代码结构与总结

3.抽象工厂模式

3.1概念

3.2.代码和结构

4.建造者模式

4.1.概念

4.2.传统建造者模式代码

4.3.建造者模式改进版（用户自定义）

5.原型模式

5.1.基本概念

5.2.浅克隆模式代码

5.3.深克隆模式代码

最后

评论列表共有 0 条评论

发表评论取消回复

JAVA基础（设计模式）-创建型模式0.设计模式概念1.设计模式7大原则 2.简单工厂模式和工厂方法模式3.抽象工厂模式 4.建造者模式5.原型模式

概述

0.设计模式概念

1.设计模式7大原则

2.简单工厂模式和工厂方法模式

2.1.工厂模式的概念和意义

2.2 简单工厂模式代码实现：

2.3.工厂方法模式代码实现：

2.4.代码结构与总结

3.抽象工厂模式

3.1概念

3.2.代码和结构

4.建造者模式

4.1.概念

4.2.传统建造者模式代码

4.3.建造者模式改进版（用户自定义）

5.原型模式

5.1.基本概念

5.2.浅克隆模式代码

5.3.深克隆模式代码

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复