Java笔记1.4--设计模式

单例模式：

/**\
 * 最简单的单例模式，无法预防多线程时候的错误
 */
public class SingleModel {
    private static SingleModel reader = null;
    private SingleModel(){}
    public static SingleModel getInstance(){
        if (reader == null)
            return new SingleModel();
        return reader;
    }
}

/**\
 * 用Synchronized标记代码块，防止多线程错误
 * 有一个缺点是如果多个线程同时请求的话，因为每次只能有一个线程执行synchronized 所以其他的都要等待，一个一个去访问
 * 实际情况是没必要一个一个区访问，只要确定有了，那么直接返回已经创建的就好了
 */

class SingleModelSyn{
    private static SingleModelSyn reader = null;
    private SingleModelSyn(){}
    public static SingleModelSyn getInstance(){
        synchronized (SingleModelSyn.class){
            if (reader == null)
                return new SingleModelSyn();
        }
        return reader;
    }
}
/**\
 * 用Synchronized标记代码块，防止多线程错误
 * 上一个的改进版本，双重检查。这样的好处就是如果已经存在这个对象了，大家都不用去等待syn执行了，因为存在的前提下不会进入syn，同时保证了不会创建两个
 */

class SingleModelSynDou{
    private static SingleModelSynDou reader = null;
    private SingleModelSynDou(){}
    public static SingleModelSynDou getInstance(){
        if (reader == null){
            synchronized (SingleModelSynDou.class){
                if (reader == null)
                    return new SingleModelSynDou();
            }
        }
        return reader;
    }
}

代理模式：

代码上降低业务使用和业务提供者的耦合程度。

实际中，出于数据安全考虑用代理模式。

（尽量结合项目讨论，数据安全管理等）

使用原则：

1.设计模式的根本原因为的是提升项目的可维护性。

2.还应该考虑其背后蕴含的思想，比如开闭原则等。

3.设计模式不仅能给出具体的解决方案，还能提供优化系统架构的思路。所以用的时候更多的是用到解耦合，面向接口编程。

4.项目中使用设计模式，为的是解决问题，所以我们更关心其背后的原则思想。

//方法接口类
public interface CarFactoryImp {
    public void sellCar();
}

//汽车厂商实现类
public class ImpModel implements CarFactoryImp {
    public void sellCar(){
        System.out.println("seel Car");
    }
}

/**
 * 汽车代理商
 */
public class CarProxy implements CarFactoryImp {
    private CarFactoryImp target;
    public void sellCar(){
        if (target == null)
            target = new ImpModel();
        target.sellCar();
    }
    public static void main(String[] args){
        CarFactoryImp imp = new CarProxy();
        imp.sellCar();
    }
}

项目中设计模式使用原则：

1.依赖倒转原则。模块间（类之间）的依赖关系（比如互相调用）是通过接口和抽象类发生，实现类之间不发生或者尽量少发生依赖关系。

2.接口或抽象类不依赖与实现类，相反实现类应该依赖接口或者抽象类。因为接口的方法没有方法体，比较稳定，修改方便。

单一职责：每个类或者模块的功能要单一，否则拆分。比如，添加订单的方法里有1.连接数据库，2.往数据库里放记录，3.关闭数据库，4.写日志。这样变更任意一个功能都会影响其他。这时候应该把对数据库的操作写在DAO层写日志也单独一个类调用。

里氏原则：

1.子类可以继承父类的抽象方法，但是不能覆盖父类的非抽象方法。

2.子类扩展功能可以增加自己的方法。

通过合成复用原则优化继承的使用场景：

优先使用组合和聚合，只有父子类之间存在逻辑上的从属关系时，才考虑使用继承。

聚合表示整体和部分的弱关系，（比如电脑和鼠标，没有了鼠标电脑还能用），组合表示强关联关系（一个人和他的四肢）。

说辞：在项目xx模块，用到了观察者模式，具体在观察者类里，不在其中放其他的业务代码，符合单一职责模式，事实上，后期需求变更，但是这块基本不动。

在项目中，定义类的时候遵循合成服用原则，只有从属关系的类才使用继承，否则使用聚合和组合，这样降低耦合度。

在详细设计阶段，我们会更具合成复用原则定义父子类之间的关系，使用xx原则，达到xx效果。。。讨论了编码规范，包含xx设计原则。。。

Java笔记1.4--设计模式

猜你喜欢