Java面试-设计模式面试题（上）

设计模式面试题（上）

什么是设计模式？

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。

每一个设计模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，我们就能一次又一次地使用该方案而不必做重复劳动。

设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式四个基本要素？

• 模式名称（pattern name）

• 问题（problem）

• 解决方案（solution）

• 效果（consequences）

详细解释：原文链接

设计模式六大原则？

• 单一原则
• 里氏替换原则
• 依赖倒置原则
• 接口隔离原则
• 迪米特原则
• 开闭原则

详细解释：原文链接

设计模式分类有哪些？

设计模式根据其目的可分为创建型（Creational）， 结构型（Structural）和行为型（Behavioral)）三种。同时，设计模式根据范围可分为类模式和对象模式两种。

创建型

结构型

行为型

详细内容：原文链接

什么是单例设计模式？

单例模式，是一种常用的 软件设计模式。许多时候整个系统只需要拥有一个全的局对象，这样有利于我们协调系统整体的行为，而单例模式的核心结构中只包含一个被称为单例的特殊类。

通过单例模式可以保证系统中，应用该模式的类只有一个实例，即一个类只有一个对象实例，同时，单例模式也可以分为 饿汉式 和 懒汉式。

饿汉式

概念

饿汉式也叫立即加载的形式。饿汉式就是使用类的时候已经将对象创建完毕（不管以后会不会使用到该实例化对象，先创建了再说。很着急的样子，故又被称为“饿汉模式”）。

代码实现

package net.haicoder.single.hungary;
public class HungrySingle {
    private HungrySingle() {
    }
    private static final HungrySingle hungrySingle = new HungrySingle();
    /**
     * 在类创建的同时，就已经将实例创建好了，不需要再创建了
     * 缺点：无论该对象有没有被引用，都会存在，浪费空间
     * 优点：线程安全
     */
    public static HungrySingle getHungrySingle() {
        return hungrySingle;
    }
    public void printHungary() {
         System.out.println("嗨客网(www.haicoder.net)");
         System.out.println("单例模式 hungary");         
    }
}

package net.haicoder.single.hungary;
public class TestHungaryMain {
    public static void main(String[] args) {
        HungrySingle hungrySingle = HungrySingle.getHungrySingle();
        hungrySingle.printHungary();
    }
}

详细内容：原文链接

懒汉式

概念

懒汉式也叫延迟加载的形式。懒汉式就是调用 get() 方法时实例才被创建（先不急着实例化出对象，等要用的时候才给你创建出来。不着急，故又称为“懒汉模式”）。

代码实现

//懒汉模式，就是在调用的时候，才会产生对象
package net.haicoder.single.hungary;
public class LazySingle {
    private static LazySingle single;
    private LazySingle() {
    }
    /**
     * 懒汉式单例，需要的时候再new
     * 缺点：线程不安全，第一次获取对象的时候，需要较多的时间
     *
     * @return 返回需要的对象
     */
    public static LazySingle getSingle() {
        if (single == null) {
            single = new LazySingle();
        }
        return single;
    }
    public void printLazy() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("单例模式 lazy");        
    }
}

但是上面的方式是线程不安全的，如果想让其线程安全，那么就会想到 synchronized 同步，将上面代码稍微修改：

package single.lazy;
public class LazySingle {
    private static LazySingle single;
    private LazySingle() {
    }
    /**
     * 懒汉式单例，需要的时候再new
     * 线程安全的，因为是在static上面加同步，所以这个是在类维度上面。如果调用非常频繁，那么这边会发生锁等待，影响效率
     *
     * @return
     */
    public static synchronized LazySingle getSingle() {
        if (single == null) {
            single = new LazySingle();
        }
        return single;
    }
    public void printLazy() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("单例模式 lazy");        
    }
}

还可以使用双重校验锁，代码实现如下：

package single.lazy;
public class LazySingle {
    private static LazySingle single;
    private LazySingle() {
    }
    /**
     * 懒汉式单例，需要的时候再new
     *
     * @return
     */
    public static LazySingle getSingle() {
        if (single == null) {
            //这个时候，如果两个线程在这边竞争锁，A线程获得锁之后，会new一个对象，B线程后拿到锁之后就不会再new了，所以需要双重检查
            synchronized (LazySingle.class) {
                if (single == null) {
                    single = new LazySingle();
                }
            }
        }
        return single;
    }
    public void printLazy() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("单例模式 lazy");        
    }
}

详细内容：原文链接

什么是工厂设计模式？

平时创建对象的时候是通过 new 类来直接创建对象，而工厂模式是通过使用一个共同的接口根据不同的条件来产生具体想要创建的对象。

工厂模式分类

分类	描述
简单工厂	简单工厂模式，严格意义上讲不算设计模式，而是一种编程习惯，根据传递的参数来判断返回一个具体的对象。
工厂方法	工厂方法模式用于定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体的子类工厂类当中。这个要求满足创建与使用相分离的特点。
抽象工厂	抽象工厂模式用于为访问类提供一个创建一组相关或互相依赖对象的接口，并且访问类无须指定所要产品的具体类就能够得到同族的不同等级的产品的模式结构。

简单工厂模式

图解

代码实现

package net.haicoder.factory.simple;
/**
 * 定义一个抽象产品类
 */
public abstract class AbstractProduct {
    /**
     * 生产产品
     */
    protected abstract void produce();
}

package net.haicoder.factory.simple;
public class BusProduct extends AbstractProduct {
    protected void produce() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("Hello world , I am a Bus");
    }
}

package net.haicoder.factory.simple;
/**
 * 小汽车产品
 */
public class CarProduct extends AbstractProduct {
    protected void produce() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("Hello world , I am a new Car");
    }
}

package net.haicoder.factory.simple;
public class SimpleFactory {
    /**
     * 简单工厂，生产出具体对象
     *
     * @param productName
     * @return
     */
    public AbstractProduct getProduct(String productName) {
        if ("bus".equals(productName)) {
            return new BusProduct();
        } else if ("car".equals(productName)) {
            return new CarProduct();
        }
        return null;
    }
}

package net.haicoder.factory.simple;
public class TestMain {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        AbstractProduct product = simpleFactory.getProduct("car");
        product.produce();
    }
}

详细内容：原文链接

工厂方法模式

图解

代码实现

package net.haicoder.factory.facrotyMethod;
public abstract class AbstractProduct {
    protected abstract void produceProduct();
}

package net.haicoder.factory.facrotyMethod;
public class BusProduct extends AbstractProduct {
    protected void produceProduct() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("Hello , I am a new Bus");
    }
}

package net.haicoder.factory.facrotyMethod;
public class CarProduct extends AbstractProduct {
    protected void produceProduct() {
        System.out.println("嗨客网(www.haicoder.net)");
        System.out.println("I am a new Car");
    }
}

package net.haicoder.factory.facrotyMethod;
public abstract class FactoryMethod {
    public abstract AbstractProduct getProduct();
}

package net.haicoder.factory.facrotyMethod;
public class BusFactory extends FactoryMethod {
    public AbstractProduct getProduct() {
        return new BusProduct();
    }
}

package net.haicoder.factory.facrotyMethod;
public class CarFactory extends FactoryMethod {
    public AbstractProduct getProduct() {
        return new CarProduct();
    }
}

package net.haicoder.factory.facrotyMethod;
public class TestMain {
    public static void main(String[] args) {
        FactoryMethod carFactory = new CarFactory();
        carFactory.getProduct().produceProduct();
        FactoryMethod busFactory = new BusFactory();
        busFactory.getProduct().produceProduct();
    }
}

详细内容：原文链接

抽象工厂模式

图解

代码实现

package net.haicoder.factory.absFactory.color;
public abstract class AbstractColor {
    abstract AbstractColor getColor();
}

package net.haicoder.factory.absFactory.color;
public class BlueColor extends AbstractColor {
    public BlueColor() {
        System.out.println("I am Blue");
    }
    AbstractColor getColor() {
        return new BlueColor();
    }
}

package net.haicoder.factory.absFactory.color;
public class RedColor extends AbstractColor {
    public RedColor() {
        System.out.println("I am red");
    }
    AbstractColor getColor() {
        return new RedColor();
    }
}

package net.haicoder.factory.absFactory.product;
/**
 * 定义一个抽象的产品
 */
public abstract class AbstractProduct {
    abstract AbstractProduct getProduct();
}

package net.haicoder.factory.absFactory.product;
public class BusProduct extends AbstractProduct {
    public BusProduct() {
        System.out.println("生产一个公共汽车");
    }
    AbstractProduct getProduct() {
        return new BusProduct();
    }
}

package net.haicoder.factory.absFactory.product;
public class CarProduct extends AbstractProduct {
    public CarProduct() {
        System.out.println("生产一个小汽车");
    }
    AbstractProduct getProduct() {
        return new CarProduct();
    }
}

package net.haicoder.factory.absFactory;
import net.haicoder.factory.absFactory.color.AbstractColor;
import net.haicoder.factory.absFactory.product.AbstractProduct;
/**
 * 定义一个工厂类，生产指定颜色的指定产品
 */
public interface AbstractFactory {
    AbstractProduct createProduct();
    AbstractColor createColor();
}

package net.haicoder.factory.absFactory;
import net.haicoder.factory.absFactory.color.AbstractColor;
import net.haicoder.factory.absFactory.color.BlueColor;
import net.haicoder.factory.absFactory.product.AbstractProduct;
import net.haicoder.factory.absFactory.product.BusProduct;
public class BlueBusFactory implements AbstractFactory {
    public AbstractProduct createProduct() {
        return new BusProduct();
    }
    public AbstractColor createColor() {
        return new BlueColor();
    }
}

package net.haicoder.factory.absFactory;
import net.haicoder.factory.absFactory.color.AbstractColor;
import net.haicoder.factory.absFactory.color.RedColor;
import net.haicoder.factory.absFactory.product.AbstractProduct;
import net.haicoder.factory.absFactory.product.CarProduct;
/**
 * 具体的红色的汽车工厂
 */
public class RedCarFactory implements AbstractFactory {
    public AbstractProduct createProduct() {
        return new CarProduct();
    }
    public AbstractColor createColor() {
        return new RedColor();
    }
}

package net.haicoder.factory.absFactory;
public class TestMain {
    public static void main(String[] args) {
        System.out.println("嗨客网(www.haicoder.net)");
        AbstractFactory abstractFactory = new RedCarFactory();
        abstractFactory.createColor();
        abstractFactory.createProduct();
    }
}

详细内容：原文链接

建造者设计模式

图解

代码实现

package net.haicoder.builder;
//构建者
public abstract class Builder {
    //机票
    abstract void buildPlaneTicket();
    //酒店
    abstract void buildHotel();
    //门票
    abstract void buildTicket();
    //保险
    abstract void buildInsurance();
    //获取产品
    abstract TravelProduct getTravelProduct();
}

package net.haicoder.builder;
/**
 * 创建一个旅游产品
 */
public class TravelProduct {
    //机票
    private String planeTicket;
    //酒店
    private String hotel;
    //门票
    private String ticket;
    //保险
    private String insurance;
    public String getPlaneTicket() {
        return planeTicket;
    }
    public void setPlaneTicket(String planeTicket) {
        this.planeTicket = planeTicket;
    }
    public String getHotel() {
        return hotel;
    }
    public void setHotel(String hotel) {
        this.hotel = hotel;
    }
    public String getTicket() {
        return ticket;
    }
    public void setTicket(String ticket) {
        this.ticket = ticket;
    }
    public String getInsurance() {
        return insurance;
    }
    public void setInsurance(String insurance) {
        this.insurance = insurance;
    }
    @Override
    public String toString() {
          return "TravelProduct{" +
                "planeTicket='" + planeTicket + '\'' + '\n' +
                ", hotel='" + hotel + '\'' + '\n' +
                ", ticket='" + ticket + '\'' + '\n' +
                ", insurance='" + insurance + '\'' +
                '}';
    }
}

package net.haicoder.builder;
/**
 * 度假具体建造者
 */
public class OnVacationConcreteBuilder extends Builder {
    private TravelProduct travelProduct;
    public OnVacationConcreteBuilder() {
        travelProduct = new TravelProduct();
    }
    void buildPlaneTicket() {
        travelProduct.setPlaneTicket("度假机票");
    }
    void buildHotel() {
        travelProduct.setHotel("度假酒店");
    }
    void buildTicket() {
        travelProduct.setTicket("度假门票");
    }
    void buildInsurance() {
        travelProduct.setInsurance("度假保险");
    }
    TravelProduct getTravelProduct() {
        return travelProduct;
    }
}

package net.haicoder.builder;
/**
 * 自由行具体构建者
 */
public class IndependentTravelConcreteBuilder extends Builder {
    private TravelProduct travelProduct;
    public IndependentTravelConcreteBuilder() {
        this.travelProduct = new TravelProduct();
    }
    void buildPlaneTicket() {
        travelProduct.setPlaneTicket("自由行机票");
    }
    void buildHotel() {
        travelProduct.setInsurance("自由行保险");
    }
    void buildTicket() {
        travelProduct.setHotel("自由行酒店");
    }
    void buildInsurance() {
        travelProduct.setInsurance("自由行保险");
    }
    TravelProduct getTravelProduct() {
        return travelProduct;
    }
}

package net.haicoder.builder;
//组装产品信息，按照一定的顺序
public class Assembler {
    public TravelProduct create(Builder builder) {
        builder.buildPlaneTicket();
        builder.buildHotel();
        builder.buildTicket();
        builder.buildInsurance();
        return builder.getTravelProduct();
    }
}

package net.haicoder.builder;
/**
 * 自由行具体构建者
 */
public class IndependentTravelConcreteBuilder extends Builder {
    private TravelProduct travelProduct;
    public IndependentTravelConcreteBuilder() {
        this.travelProduct = new TravelProduct();
    }
    void buildPlaneTicket() {
        travelProduct.setPlaneTicket("自由行机票");
    }
    void buildHotel() {
        travelProduct.setInsurance("自由行保险");
    }
    void buildTicket() {
        travelProduct.setHotel("自由行酒店");
    }
    void buildInsurance() {
        travelProduct.setInsurance("自由行保险");
    }
    TravelProduct getTravelProduct() {
        return travelProduct;
    }
}

package net.haicoder.builder;
public class TestMain {
    public static void main(String[] args) {
        Assembler assembler = new Assembler();
        TravelProduct travelProduct = assembler.create(new OnVacationConcreteBuilder());
        System.out.println(travelProduct.toString());
    }
}

详细内容：原文链接

原型模式设计

概念

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的心对象。

允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节，工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

代码实现

package net.haicoder.prototype;
public class Tourist implements Cloneable {
    private String name;
    private Integer age;
    private String idCard;
    public Object clone() {
        Tourist tourist = null;
        try {
            tourist = (Tourist) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return tourist;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getIdCard() {
        return idCard;
    }
    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }
    @Override
    public String toString() {
        return "Tourist{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", idCard='" + idCard + '\'' +
                '}';
    }
}

package net.haicoder.prototype;
public class TestMain {
    public static void main(String[] args) {
        Tourist tourist = new Tourist();
        tourist.setAge(10);
        tourist.setName("嗨客网");
        tourist.setIdCard("身份证id");
        Tourist copyTourist = (Tourist) tourist.clone();
        System.out.println("嗨客网(www.haicoder.net)");
        copyTourist.setName("我是copy的");
        System.out.println(copyTourist.toString());
    }
}

详细内容：原文链接