Java高级 - 15.设计模式 - 《Java 面试 & 基础》

一、概念
二、设计模式的六大原则
三、设计模式

一、概念

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

一般指的设计模式都是狭义的设计模式，业界公认的（发表过论文，形成的著作），《设计模式》有Gof 4人组，经过大量的总结，得出的一些通用的软件设计方法。总结起来有23种。

经验：所谓设计模式，都是翻来覆去使用封装继承多态。

二、设计模式的六大原则

1、开闭原则（Open Close Principle）
开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
3、依赖倒转原则（Dependence Inversion Principle）
这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
5、迪米特法则，又称最少知道原则（Demeter Principle）
最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

补充
UML ( 同一建模语言 ) ，辅助软件设计，程序界的代码设计图。

三、设计模式

3.1 工厂模式

简单工厂模式，属于一种创建型设计模式，创建对象使用。通常是创建一个类体系(类家族)中的对象。个别类创建也不用设计模式了。

package Factory;
public class factory {
    public static void main(String[] args) {
        xifu x = xifuFactory.creatXifu("xijiao");//等于 xifuFactory.XX
        x.run();
    }
}
//工厂模式
abstract class xifu{
    abstract void run();
}
class xijiao extends xifu{
    @Override
    void run() {
        System.out.println("洗脚的。。。");
    }
}
class anmo extends xifu{
    @Override
    void run() {
        System.out.println("按摩的。。。");
    }
}
class dabaojian extends xifu{
    @Override
    void run() {
        System.out.println("大保健。。。");
    }
}
//定义一个工厂类 用于创建对象
class xifuFactory{
    public static final String XX="xijiao";
    public static final String XX1="anmo";
    public static final String XX2="dabaojian";
    public static xifu creatXifu(String xx){
        if (xx.equals(XX)) return new xijiao();
        if (xx.equals(XX1)) return  new anmo();
        if (xx.equals(XX2)) return new dabaojian();
        return null;
    }
}

3.2 单例模式

一般用在资源文件加载
确保一个类的实例只有一个，任何时间任何位置，获得的该类实例总是同一个。
思路就是，先私有化构造器，再准备一个该类的实例，最后提供一个方法获得这个实例。

class Cat {
    //声明一个实例（懒汉模式）
    private volatlie static Cat  instance = null;
    //私有化构造器
    private Cat(){}
    //返回实例的方法
    public static  synchronized  Cat getInstance(){
        if( instance == null ){
            instance = new Cat();
        }
        return instance;
    }
}
//饿汉  天生线程安全 的
class Dog {
    //声明一个本的唯一实例（饿汉模式）
    private static  Dog instance =  new Dog()  ;
    //1。私有化构造器
    private Dog(){}
    //2. 提供一个返回实例的方法
    public static Dog getInstance(){
        return instance;
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = Dog.getInstance();
        Dog dog2 = Dog.getInstance();
        System.out.println(dog==dog2);
        System.out.println("--------------------------");
        Cat c = Cat.getInstance();
        Cat d = Cat.getInstance();
        System.out.println( c.hashCode());
        System.out.println( d.hashCode());
    }
}

3.3 观察者模式

这种模式，建立了一种事件机制，当前一个对象的状态发生改变，可以自动通知到，关注它的对象。比如多个用户订阅天气服务(主题)，天气变化后都会收到通知。


import java.util.ArrayList;
import java.util.List;
//主题(天气)
 class Weather {
    //天气信息
    private String info;
    //维护一个订阅者列表
    private List<Observer> list = new ArrayList<>();
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
        //主题发生变化，通知他们更新数据
        for (Observer observer : list) {
             observer.update();
        }
    }
    //注册观察者的方法
    public void add( Observer obj ){
        list.add(obj);
    }
}
/**
 * 观察者接口
 */
public interface Observer {
    //同步更新数据的方法
    public void update();
}
//具体观察者
class LDHObsever implements Observer{
    private Weather target;
    public LDHObsever(Weather target) {
        this.target = target;
        //把自己注册到观察者列表中
        target.add(this);
    }
    @Override
    public void update() {
        System.out.println("刘德华收到:最新天气数据："+target.getInfo());
    }
}
//具体观察者
class WBQObsever implements Observer{
    private Weather target;
    public WBQObsever(Weather target) {
        this.target = target;
        //把自己注册到观察者列表中
        target.add(this);
    }
    @Override
    public void update() {
        System.out.println("王宝强收到：最新天气数据："+target.getInfo());
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        //主题
        Weather weather = new Weather();
        WBQObsever obj1 = new WBQObsever(weather);
        LDHObsever obj2 = new LDHObsever(weather);
        weather.setInfo("阵雨");
        Thread.sleep(1000);
        weather.setInfo("小雨");
        Thread.sleep(1000);
        weather.setInfo("晴");
    }
}

3.4 建造者模式

使用更简洁的方式创建对象，或者按照步骤依次初始化对象的模式。

/**
 * 电脑
 */
public class Computer {
    private String cpu;
    private String ram;
    private String power;
    private String disk;
    private String gpu;
    private Computer() {
    }
    private Computer(String cpu, String ram, String power, String disk, String gpu) {
        this.cpu = cpu;
        this.ram = ram;
        this.power = power;
        this.disk = disk;
        this.gpu = gpu;
    }
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    public String getPower() {
        return power;
    }
    public void setPower(String power) {
        this.power = power;
    }
    public String getDisk() {
        return disk;
    }
    public void setDisk(String disk) {
        this.disk = disk;
    }
    public String getGpu() {
        return gpu;
    }
    public void setGpu(String gpu) {
        this.gpu = gpu;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", power='" + power + '\'' +
                ", disk='" + disk + '\'' +
                ", gpu='" + gpu + '\'' +
                '}';
    }
    //内部类，构造对象的属性
   static class Builder{
        private String cpu;
        private String ram;
        private String power;
        private String disk;
        private String gpu;
        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }
        public Builder setRam(String ram) {
            this.ram = ram;
            return this;
        }
        public Builder setPower(String power) {
            this.power = power;
            return this;
        }
        public Builder setDisk(String disk) {
            this.disk = disk;
            return this;
        }
        public Builder setGpu(String gpu) {
            this.gpu = gpu;
            return this;
        }
        //构造方法
        public  Computer  build(){
              Computer computer = new Computer( this.cpu,this.ram,this.power,this.disk,this.gpu );
              return computer;
        }
    }
}
class Test {
    public static void main(String[] args) {
        //缺点，参数多，顺序不好把握     ctl+p 提示参数
        //Computer computer = new Computer( "AMD36000","皇家戟3333","长城500","三星T9999","RTX3060");
        //驱缺点，语句多
        /*Computer  obj = new Computer();
        obj.setCpu("IntelI90000K");
        obj.setDisk("西部数据X888");
        obj.setRam("七彩虹8GB");
        obj.setPower("长城4000");*/
        //优点，链式调用
        Computer computer = new Computer.Builder().
                setCpu("AMD").
                setRam("三星").
                setGpu("RTX1080ti").
                setDisk("西部数据").
                setPower("长城888").
                build();
        System.out.println(computer);
    }
}

3.5 装饰模式

对现有类装饰( 增加能力 )

/*
接口类
*/
public interface IGirl {
    void cook();
}
/**
 * 女生:简单的girl
 */
class SimpleGirl implements IGirl {
    public void cook(){
        System.out.println("做饭");
    }
}
/**
 * 装饰类，把目标对象添加跳舞功能
 */
 class SingGirl implements IGirl {
    //引入一个Girl
    private IGirl girl;
    public SingGirl(IGirl girl) {
        this.girl = girl;
    }
    @Override
    public void cook() {
        System.out.println("唱歌.....");
        girl.cook();
    }
}
/**
 * 装饰类，把目标对象添加跳舞功能
 */
 class DanceGirl implements IGirl {
    //引入一个Girl
    private IGirl girl;
    public DanceGirl(IGirl girl) {
        this.girl = girl;
    }
    @Override
    public void cook() {
        System.out.println("跳舞.....");
        girl.cook();
    }
}
public class Test {
    public static void main(String[] args) {
        DanceGirl girl = new DanceGirl( new SingGirl( new SimpleGirl() ));
        girl.cook();
    }
}

3.6 代理模式

这种模式，解决的是，直接使用某些对象不方便时，或者通过更多增强功能的时候，使用它。

//被代理父类
/**
 * 售票大厅（抽象类）
 */
public abstract  class  SalesCenter {
    public abstract void salesTickets();
}

被代理类

//被代理的类
public class TrainSalesCenter extends SalesCenter{
    @Override
    public void salesTickets() {
        System.out.println("销售火车票.....");
    }
}
//被代理的类
public class BusSalesCenter extends SalesCenter{
    @Override
    public void salesTickets() {
        System.out.println("销售汽车票.....");//业务代码
    }
}

代理类

//代理类，代理售票行为
public class ProxySalesCenter extends SalesCenter {
    //引入被代理对象
    private SalesCenter salesCenter;
    //设置代理对象
    public void setSalesCenter(SalesCenter salesCenter) {
        this.salesCenter = salesCenter;
    }
    @Override
    public void salesTickets() {
          //增强功能
         System.out.println("销售彩票.....");
         //调用被代理对象的方法
         salesCenter.salesTickets();
         //增强功能
         System.out.println("销售香烟....");
    }
}