Java设计模式（工厂模式＞抽象工厂模式和原型模式）

最新推荐文章于 2024-09-11 00:42:35 发布
最新推荐文章于 2024-09-11 00:42:35 发布
阅读量224 收藏
点赞数
分类专栏： java 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46212244/article/details/116204600
版权

Java设计模式Ⅱ

1.工厂模式

1.1 简单工厂模式

（1）基本介绍

a.简单工厂模式是属于创建模式，是工厂模式的一种，简单工厂模式
	是由一个工厂对象创建出哪一种产品类的实例。简单工厂模式是工
	厂模式家族里最简单使用的模式

b.定义了一个创建对象的类，有这个类封装实例化对象的行为

c.在软件开发中。当我们会用到大量的创建某类，或者某批对
	象时，就会使用到工厂模式

(2)代码展示

1.先定义一个抽象类，将不同的点设置为抽象方法

package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;

public abstract class Car {

    private String name;

    // 因为车的品牌不一样，所以设置为抽象方法
    public abstract void log();

    public void tyre(){
        System.out.println(name + "的轮胎");
    }

    public void frame(){
        System.out.println(name + "的车架");
    }

    public void engine(){
        System.out.println(name + "的引擎");
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.继承该抽象方法去重写其抽象方法（可以多创建一些车品牌）

package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;

public class AudiCar extends Car{
    @Override
    public void log() {
        System.out.println("奥迪");
    }
}

3.制作什么品牌的车自己输入

package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;

import java.util.Scanner;

public class MakeCar {

    private CarFactory factory;
    private Car car;

    public MakeCar(CarFactory factory){
        this.factory = factory;
    }

    public void makeCar(){
        String log = "";

        do {
            log = getLog();
            car = this.factory.createCar(log);

            if (car != null){
                car.log();
                car.tyre();
                car.frame();
                car.engine();
            } else {
                System.out.println("输入有误！没有该品牌的车型！！！");
                break;
            }
        } while (true);
    }

    public String getLog() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要制作的品牌:");
        String log = scanner.next();
        return log;
    }
}

4.创建工厂类

package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;

public class CarFactory {

    public Car createCar(String log){
        Car car = null;

        if ("宝马".equals(log)){
            car = new BmwCar();
            car.setName("宝马");
        }else  if ("奔驰".equals(log)){
            car = new BenzCar();
            car.setName("奔驰");
        }else if ("奥迪".equals(log)){
            car = new AudiCar();
            car.setName("奥迪");
        }

        return car;
    }
}

5.测试类

package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;

public class Test {
    public static void main(String[] args) {
        CarFactory factory = new CarFactory();
        MakeCar makeCar = new MakeCar(factory);
        makeCar.makeCar();
    }
}

1.2 工厂方法模式

（1）基本介绍

a.工厂方法模式：定义一个创建对象的抽象方法，由子类决定要
	实例化的类，工厂方法模式将对象的实例化推迟到子类。

（2）代码展示
1.跟简单工厂模式一样

package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;

public abstract class Car {

    private String name;

    public abstract void getCar();

    public void tyre(){
        System.out.println(name + "的轮胎");
    }

    public void frame(){
        System.out.println(name + "的车架");
    }

    public void engine(){
        System.out.println(name + "的引擎");
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.跟简单工厂模式一样，可增加

package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;

public class ChinaBenzCar extends Car{
    @Override
    public void getCar() {
        setName("中国的奔驰汽车");
        System.out.println("中国的奔驰汽车 准备制作");
    }
}

3.跟简单工厂模式一样，可增加

package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;

public class USABenzCar extends Car{
    @Override
    public void getCar() {
        setName("美国的奔驰汽车");
        System.out.println("美国的奔驰汽车 准备制作");
    }
}

4.制作

package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;

import java.util.Scanner;

public abstract class MakeCar {

    // 定义一个抽象方法，让各个工厂子类自己去实现
    abstract Car createCar(String log);

    // 构造器
    public MakeCar(){
        Car car = null;
        String log;  // 制作的车品牌
        do {
            log = getLog();
            car = createCar(log);
            if (car != null){
                car.getCar();
                car.tyre();
                car.frame();
                car.engine();
            }else {
                System.out.println("你输入的品牌不对");
                break;
            }


        } while (true);
    }


    public String getLog(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要制作的品牌汽车:");
        String log = scanner.next();
        return log;
    }
}

5.测试

package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;

public class Test {
    public static void main(String[] args) {
        // 创建中国的车
//        new ChinaMakeCar();
        // 创建美国的汽车

        new USAMakeCar();

    }
}

2.抽象工厂模式

（1）基本介绍

a.抽象工厂模式：定义了一个interface用于创建相关或有依赖关系
	的对象簇，而无需知名具体的类。

b.抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合

c.抽象工厂模式就是对简单工厂模式的改进

d.将工厂抽象成两层，absfactory（抽象工厂）和具体实现的工厂
	子类，程序员可以根据创建对象类型使用对应的工厂子类，这
	样将单个的简单工厂类变成了工厂簇。更利于代码的维护和扩展。

（2）代码展示
1.还是Car类

package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;

public abstract class Car {

    private String name;

    public abstract void getCar();

    public void tyre(){
        System.out.println(name + "的轮胎");
    }

    public void frame(){
        System.out.println(name + "的车架");
    }

    public void engine(){
        System.out.println(name + "的引擎");
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.中国奔驰类(可增加)

package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;

public class ChinaBenzCar extends Car{
    @Override
    public void getCar() {
        setName("China");
        System.out.println("中国的奔驰汽车》》开始制作");
    }
}

3.mg的类

package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;

public class USABenzCar extends Car{
    @Override
    public void getCar() {
        setName("USA");
        System.out.println("美国的奔驰汽车》》开始制作");
    }
}

4.创建一个抽象工厂

package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;

public interface AbsFactory {

    public Car createCar(String log);
}

5.制作

package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;

import java.util.Scanner;

public class MakeCar {

    AbsFactory absFactory;

    public MakeCar(AbsFactory absFactory){
        setAbsFactory(absFactory);
    }

    private void setAbsFactory(AbsFactory absFactory){
        Car car = null;
        String log = "";
        this.absFactory = absFactory;

        do {
            log = getLog();
            car = absFactory.createCar(log);
            if (car != null){
                car.getCar();
                car.tyre();
                car.frame();
                car.engine();
            }else {
                System.out.println("输入有误:");
                break;
            }
        }while (true);
    }

    public String getLog(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入:");
        String log = scanner.next();
        return log;
    }
}

6.测试

package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;

public class Test {
    public static void main(String[] args) {
        new MakeCar(new ChinaMakeCar());
    }
}

3.总结

（1）工厂模式的意义

a.将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展的维护性

(2) 根据的是设计模式的依赖抽象原则

a.创建对象实例时，不要直接new类，而是把这个new类的动作放
	在一个工厂的方法中，并返回，有的书上说，变量不要直接持
	有具体类的引用

b.不要让类继承具体类，而是继承抽象类或者是实现接口

c.不要覆盖基类中已经实现的方法

PS:JDK在Calendar类中的getInstance，使用了简单工厂模式

4.原型模式

4.1 原型模式

(1) 基本介绍

①原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过
	拷贝这些原型，创建新的对象

②原型模式是一种创建型设计模式，允许一个对象可以再创建另外一
	个可定制的对象，无需知道如何创建的细节

③工作原理：通过将一个原型对象传给那个要发动创建的对象，这个
	要发动的对象通过请求原型对象拷贝它们自己来实现创建，即
	对象。Clone()

④在Spring中原型模式bean的创建就用到了原型模式

4.2 浅拷贝

(1) 浅拷贝的介绍

①对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值
	传递，也就是将该属性值赋值一份新的对象

②对于数据是引用数据类型的成员变量。那么浅拷贝会进行引用传
	递。也就是将该成员变量的引用值赋值给新的对象，因为实际上
	两个对象的成员变量都指向同一个实例，在这中情况下，在一个
	对象中修改该成员变量的值，会影响到另一个对象的成员变量的值

③浅拷贝是使用默认的clone()方法来实现拷贝的.

（2）代码展示
1.重写clone()是关键

package com.pattern.设计模式.原型模式.浅拷贝;

public class Car implements Cloneable{

    private String name;
    private Integer id;
    private String colour;

    public Car() {
    }

    public Car(String name, Integer id, String colour) {
        this.name = name;
        this.id = id;
        this.colour = colour;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", colour='" + colour + '\'' +
                '}';
    }

// 重写clone()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {

        Car car = null;
        car = (Car) super.clone();
        return car;
    }
}

2.测试类

package com.pattern.设计模式.原型模式.浅拷贝;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("宝马", 12138, "红色");
        System.out.println(car);
        Car car1 = (Car) car.clone();
        Car car2 = (Car) car.clone();
        Car car3 = (Car) car.clone();
        Car car4 = (Car) car.clone();

        System.out.println(car1);
        System.out.println(car == car1);
        List<Car> list = new ArrayList<>();
        list.add(car1);
        list.add(car2);
        list.add(car3);
        list.add(car4);
        System.out.println(list);

    }
}

4.3 深拷贝

(1) 深拷贝的介绍

①赋值对象的所有基本数据类型的成员变量值

②为所有引用数据类型的成员变量申请储存空间，并复制每个引用
	数据类型成员变量所引用的对象，直到该对象可达的所有对象，
	也就是说，对象深拷贝要对整个对象进行拷贝

③深拷贝实现方法1：重写clone()方法

④深拷贝实现方法2：通过对象序列化

（2）代码展示
1.Tyre类

package com.pattern.设计模式.原型模式.深拷贝;

import java.io.Serializable;

public class Tyre implements Serializable, Cloneable {

    private static final Long serialVersionUID = 1L;

    private String name;

    public Tyre() {
    }

    public Tyre(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Tyre{" +
                "name='" + name + '\'' +
                '}';
    }

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

2.Car类

package com.pattern.设计模式.原型模式.深拷贝;

import java.io.*;

public class Car implements Serializable, Cloneable {

    private static final Long serialVersionUID = 1L;
    private String log;
    private Tyre tyre;

    public Car() {
    }

    public Car(String log, Tyre tyre) {
        this.log = log;
        this.tyre = tyre;
    }

    public String getLog() {
        return log;
    }

    public void setLog(String log) {
        this.log = log;
    }

    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

    @Override
    public String toString() {
        return "Car{" +
                "log='" + log + '\'' +
                ", tyre=" + tyre +
                '}';
    }

    // 方式1 深拷贝 重写clone()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 基本数据类型直接clone
        Object d = null;
        d = super.clone();
        // 对引用数据类型单独拿出来clone
        Car car = (Car) d;
        car.tyre = (Tyre) tyre.clone();
        return car;
    }

    // 方式2 深拷贝 通过对象的序列化实现
    public Object getClone() throws IOException, ClassNotFoundException {
        // 创建流对象
        ByteArrayOutputStream byteArrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;

        // 序列化
        byteArrayOutputStream = new ByteArrayOutputStream();
        objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(this); // 当前对象以对象流的方式输出

        // 反序列化
        byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        objectInputStream = new ObjectInputStream(byteArrayInputStream);
        Car car = (Car) objectInputStream.readObject();
        return car;

    }

}

3.测试类

package com.pattern.设计模式.原型模式.深拷贝;

import java.io.IOException;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
        Car car = new Car();
        car.setLog("奔驰");
        car.setTyre(new Tyre("轮胎"));

        // 方式1 深拷贝
//        Car car1 = (Car) car.clone();
//        System.out.println(car);
//        System.out.println(car1);
//        System.out.println(car.hashCode());
//        System.out.println(car1.hashCode());

        // 方式2 深拷贝
        Car car2 = (Car) car.getClone();
        System.out.println(car);
        System.out.println(car2);
        System.out.println(car.hashCode());
        System.out.println(car2.hashCode());
    }
}

5.建造者模式

建造者模式 等等

shallow丶十三
关注
专栏目录
工厂模式与原型模式
weixin_40055163的博客
10-28 578
工厂模式与原型模式 1.1简单工厂模式 什么是创建型？ 创建型模式，就是创建对象的模式，抽象了实例化的过程。它帮助一个系统独立于如何创建、组合和表示它的那些对象。关注的是对象的创建，创建型模式将创建对象的过程进行了抽象，也可以理解为将创建对象的过程进行了封装，作为客户程序仅仅需要去使用对象，而不再关心创建对象过程中的逻辑。 是·针对用户，只需要关注结果,其实就是不关注产品的生产细节。 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。 简单工厂模式是工
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
1. **创建型模式**：包括单例（Singleton）、工厂方法（Factory Method）、抽象工厂（Abstract Factory）、建造者（Builder）和原型（Prototype）。这些模式关注对象的创建过程，使得代码更加灵活，易于管理和扩展。...
抽象工厂模式和原型模式之间的区别是什么？
siyuanwai的博客
08-04 372
抽象工厂模式： 通常由工厂方法模式来实现。但一个工厂中往往含有多个工厂方法生成一系列的产品。这个模式强调的是客户代码一次保证只使用一个系列的产品。当要切换为另一个系列的产品， 换一个工厂类即可。 原型模式： 工厂方法的最大缺点就是，对应一个继承体系的产品类， 要有一个同样复杂的工厂类的继承体系。我们可以把工厂类中的工厂方法放到产品类自身之中吗？如果这样的话，就可以将两个继承体系为一个。这也就是原型模式的思想，原型模式中的工厂方法为clone，它会返回一个拷贝（ 可以是浅拷贝，也可以是深拷贝，由设计者决定）。
设计模式-抽象工厂模式(Abstract Factory)
最新发布
zhao_kang_cheng的专栏
09-11 886
是一种创建型设计模式， 它能创建一系列相关的对象， 而无需指定其具体类。譬如 你正在开发一款家具组装系统。代码中包括一些产品：椅子（chair）,沙发（sofa）和 咖啡桌（Coffee­Table） 然后基于这些产品形成一些列组合套餐 装饰风艺术(Art Deco)、维多利亚（Victorian）和现代（Mdern）。你需要设法单独生成每件家具对象， 这样才能确保其风格一致。如果顾客收到的家具风格不一样， 他们可不会开心。此外， 你也不希望在添加新产品或新风格时修改已有代码。
设计模式理解：工厂模式，抽象工厂，原型方法
superSmart_Dong的博客
03-06 348
工厂模式、抽象工厂、原型方法都是对象创建型模式。工厂模式的目的是利用抽象类去动态地创建对象；抽象工厂模式是利用抽象类动态地创建一系列的对象；而原型方法是通过克隆(深拷贝)地形式创建出对象 ，再去操作新创建的对象，而不去修改原型内容。 工厂方法，将要创建的对象内容该由外部参数决定，而内部程序不需要考虑具体初始化哪个实体对象。例如如果要扩展Oracle的连接实体类，只需要再扩展DBFactory即可。当然，如果把createConnection设置成虚函数，那么就可以对IconnectionFa...
Java设计模式圣经连载（03）－抽象工厂模式
weixin_33849942的博客
12-06 138
1.3 抽象工厂（Abstract Factory）模式    抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。    每个模式都是针对一定问题的解决方案。抽象工厂模式面对的问题是多产品等级结构的系统设计。    在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。    产品族：是指位于不同产...
抽象工厂模式
weixin_34284188的博客
07-05 818
[注：原文地址：http://www.sudu.cn/info/html/edu/20070421/319122.html] 当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个...
基于Java实现的23种设计模式Demo，抽象工厂模式、建造模式、工厂方法模式、原型模式、单例模式、外观模式、适配器模式等
12-29
Java设计模式共有23种，分别为：抽象工厂模式、建造模式、工厂方法模式、原型模式、单例模式、外观模式、适配器模式、桥接模式、组合模式、装饰模式、享元模式、代理模式、命令模式、解释器模式、访问者模式、迭代子...
Java 经典设计模式讲解以及项目实战
06-14
Java 经典设计模式讲解以及项目实战 设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述...
重学java的设计模式
05-09
其中包括工厂模式、抽象工厂模式、单例模式、建造者模式和原型模式。这些模式能够帮助我们隐藏对象创建的细节，使客户端代码不必关心对象如何被实例化，从而降低了系统的耦合度。 1. 工厂模式：提供一个接口用于...
java软件设计模式期末总结
05-21
Java软件设计模式是软件开发中的重要概念，它们是经过时间考验的最佳实践，旨在解决常见的设计问题，提高代码的可读性、可维护性和可扩展性。以下是对标题和描述中涉及的一些关键知识点的详细说明： 1. **单一职责...
3. 抽象工厂
weixin_53475254的博客
11-10 847
文章目录3. 抽象工厂模式(使用频率：★★★★★)1. 概念2. 抽象工厂模式结构抽象工厂模式包含以下4个角色：3. 抽象工厂代码实现4. 例子5. 拓展产品6. 优缺点7. 模式适用环境 3. 抽象工厂模式(使用频率：★★★★★) 工厂方法模式 每个具体工厂只有一个或者一组重载的工厂方法，只能生产一种产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销 抽象工厂模式 一个工厂可以生产一系列产品（一族产品），极大减少了工厂类的数量 1. 概念 产品等级结构：产品等级结构即产品的继承结构
设计模式——工厂模式
热门推荐
XHY的博客
10-12 2万+
1. 工厂模式定义 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 2. 作用 通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系 3. 类图 这里的工厂与产品为一对一的关系，属于简单工厂 .
Java设计模式详解：工厂模式、抽象工厂模式
"深入浅出设计模式（JAVA）是一本详细介绍Java设计模式的书籍，涵盖了多种设计模式，如工厂模式、单例模式、建造模式等23种经典的GOF设计模式。书中通过实例讲解如何在实际编程中应用这些模式，以提高代码的灵活性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值