「设计模式面试」这几个问题你能回答几个？(对象模式工厂实例方法)

  工厂模式的作用是帮助我们创建对象，我们不用自己来创建，根据需要创建的对象的复杂度我们可以把工厂模式分为简单工厂，工厂方法和抽象工厂。

image.png

  简单工厂模式又称为静态工厂方法，他可以根据不同的参数而返回不同的实例，简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

JDK中的简单工厂应用：DataFormat

image.png

自己写一个简单工厂的案例

image.png

/ 简单工厂 /public class SimpleFactory { public static void main(String[] args) { // 根据对应的类型返回相关产品 CarFactory.createCar("奥迪").run(); CarFactory.createCar("Byd").run(); }}// 定义公共的接口interface Car{ void run();}class Audi implements Car{ @Override public void run() { System.out.println("奥迪在跑..."); }}class Byd implements Car{ @Override public void run() { System.out.println("Byd在跑..."); }}// 创建对应的简单工厂类class CarFactory{ public static Car createCar(String type){ if("奥迪".equals(type)){ return new Audi(); }else if("Byd".equals(type)){ return new Byd(); }else{ throw new RuntimeException("该产品不能生产"); } }}

我们可以发现简单工厂对于新增产品是无能为力的！
不修改原有代码根本就没办法扩展!!!

  针对于简单工厂的短板，引出了工厂方法模式，定义一个用户创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到了其子类中。

image.png

代码实现：

/ 工厂方法模式 /public class FactoryMethod { public static void main(String[] args) { new AudiCarFactory().createCar().run(); new BydCarFactory().createCar().run(); } public static interface Car{ public void run(); } public static class Byd implements Car{ @Override public void run() { System.out.println("比亚迪..."); } } public static class Audi implements Car{ @Override public void run() { System.out.println("奥迪..."); } } public static interface CarFactory{ public Car createCar(); } // 扩展的工厂 public static class AudiCarFactory implements CarFactory{ @Override public Car createCar() { return new Audi(); } } public static class BydCarFactory implements CarFactory{ @Override public Car createCar() { return new Byd(); } }}

简单工厂和工厂方法模式的对比

  上面的两种方式实现的工厂都是生产同一大类的产品，如果要实现生产不同类型的产品这时我们就可以用抽象工厂模式来实现。

image.png

代码实现：

/ 抽象工厂：多个产品族 /public class AbstractFactory { public static void main(String[] args) { Car car = new LuxuryEngineCarFacory().createCar(); Engine engine = new LuxuryEngineCarFacory().createEngine(); car.run(); engine.run(); } // 抽象工厂 public static interface AbstarctComponentFactory{ Car createCar(); Engine createEngine(); } public static class LuxuryEngineCarFacory implements AbstarctComponentFactory{ @Override public Engine createEngine() { return new LuxuryEngineFactory().createEngine(); } @Override public Car createCar() { return new BydCarFactory().createCar(); } } public static class LowEngineCarFacory implements AbstarctComponentFactory{ @Override public Car createCar() { return new AudiCarFactory().createCar(); } @Override public Engine createEngine() { return new LowEngineFactory().createEngine(); } } // 汽车产品族 public static interface Car{ public void run(); } public static class Byd implements Car { @Override public void run() { System.out.println("比亚迪..."); } } public static class Audi implements Car { @Override public void run() { System.out.println("奥迪..."); } } public static interface CarFactory{ public Car createCar(); } // 扩展的工厂 public static class AudiCarFactory implements CarFactory { @Override public Car createCar() { return new Audi(); } } public static class BydCarFactory implements CarFactory{ @Override public Car createCar() { return new Byd(); } } // 发动机产品族 public static interface Engine{ public void run(); } public static class LuxuryEngine implements Engine{ @Override public void run() { System.out.println("豪华版发动机..."); } } public static class LowEngine implements Engine{ @Override public void run() { System.out.println("低配版发动机..."); } } public static interface EngineFactory{ public Engine createEngine(); } public static class LuxuryEngineFactory implements EngineFactory{ @Override public Engine createEngine() { return new LuxuryEngine(); } } public static class LowEngineFactory implements EngineFactory{ @Override public Engine createEngine() { return new LowEngine(); } }}

三者的对比：

  实际开发中，我们所需要的对象构建时非常复杂，且有很多步骤需要处理时，这时建造者模式就很适合。
比如MyBatis中的SqlSessionFactory对象的创建，我们不光要创建SqlSessionFactory本身的对象，还有完成MyBatis的全局配置文件和映射文件的加载解析操作，之后把解析出来的信息绑定在SqlSessionFactory对象中，

image.png

直接参考MyBatis的代码即可

image.png

所以建造者模式的作用就是帮助我们解决了复杂对象的创建

  在java中我们知道通过new关键字创建的对象是非常繁琐的(类加载判断，内存分配，初始化等)，在我们需要大量对象的情况下，原型模式就是我们可以考虑实现的方式。
  原型模式我们也称为克隆模式，即一个某个对象为原型克隆出来一个一模一样的对象，该对象的属性和原型对象一模一样。
而且对于原型对象没有任何影响。
原型模式的克隆方式有两种：浅克隆和深度克隆.

  被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
Object类提供的方法clone=只是拷贝本对象= ， =其对象内部的数组、引用对象等都不拷贝= ，还是指向原生对象的内部元素地址.

  被克隆的对象必须Cloneable,Serializable这两个接口;

package com.bobo.prototype;import java.io.Serializable;import java.util.Date;public class User implements Cloneable, Serializable { private String name; private Date birth; private int age; / 实现克隆的方法 @return @throws CloneNotSupportedException / @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date getBirth() { return birth; } public void setBirth(Date birth) { this.birth = birth; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public static void main(String[] args) throws Exception { // 创建一个普通对象 Date date = new Date(666666); User user = new User(); user.setName("波波烤鸭"); user.setAge(18); user.setBirth(date); System.out.println("原型对象的属性：" + user); // 克隆对象 User cloneUser = (User) user.clone(); System.out.println("克隆的对象的属性：" + cloneUser); // 修改原型对象的属性 date.setTime(12345677); // 修改克隆对象的属性 cloneUser.setName("波哥"); System.out.println("原型对象的属性：" + user); System.out.println("克隆的对象的属性：" + cloneUser); } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", birth=" + birth + ", age=" + age + '}'; }}

输出结果

image.png

浅克隆的问题:虽然产生了两个完全不同的对象，但是被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。

7.2 深度克隆

  被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深复制把要复制的对象所引用的对象都复制了一遍。
实现的效果是:

image.png

深度克隆(deep clone)有两种实现方式，第一种是在浅克隆的基础上实现，第二种是通过序列化和反序列化实现，我们分别来介绍

方式一：在浅克隆的基础上实现

/ 实现克隆的方法 @return @throws CloneNotSupportedException / @Override protected Object clone() throws CloneNotSupportedException { User user = (User) super.clone(); // 实现深度克隆 user.birth = (Date) this.birth.clone(); return user; }

image.png

方式二：序列化和反序列化

名称 说明 序列化 把对象转换为字节序列的过程。
反序列化 把字节序列恢复为对象的过程。

public static void main(String[] args) throws CloneNotSupportedException, Exception { Date date = new Date(1231231231231l); User user = new User(); user.setName("波波烤鸭"); user.setAge(18); user.setBirth(date); System.out.println("-----原型对象的属性------"); System.out.println(user); //使用序列化和反序列化实现深复制 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(user); byte[] bytes = bos.toByteArray(); ByteArrayInputStream bis = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bis); //克隆好的对象！
User user1 = (User) ois.readObject(); // 修改原型对象的值 date.setTime(221321321321321l); System.out.println(user.getBirth()); System.out.println("------克隆对象的属性-------"); System.out.println(user1);}