设计模式学习

最新推荐文章于 2024-11-15 19:45:43 发布

正在努力的软工小白

最新推荐文章于 2024-11-15 19:45:43 发布

阅读量83

点赞数

文章标签：学习设计模式

本文链接：https://blog.csdn.net/qq_44623021/article/details/133626508

版权

设计模式

原型设计模式：深拷贝浅拷贝 spring框架中哪里用到了原型模式 beans.xml

单一职责原则

接口隔离原则

依赖倒转原则

里氏替换原则

开闭原则

迪米特法则

合成复用原则

单一职责原则：singleresponsibility

降低类的复杂度，一个类只负责一项职责。

提高类的可读性，可维护性

降低变更引起的风险

通常情况下我们应当循单一职责原则，只有逻辑足够简单，开可以在代码级违反单一职责原则；只有方法数量足够少，可以再方法级别上保持单一职责原则

接口隔离原则segregation

客户端不应该依赖他不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

依赖倒转原则inversion

底层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好

变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化

继承时遵循里氏替换原则

抽象不应该依赖细节，细节应该依赖抽象

依赖倒转原则的中心思想是面向接口编程

使用接口或抽象类的目的是指定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

里氏替换原则：

继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决。

开闭原则

迪米特法则

1.一个对象应该对其他对象保持最少的了解

2.类与类关系越密切，耦合度越大

3.迪米特法则又叫最少知道原则，即一个类对自己以来的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供public方法，不对外泄露任何信息

4.只与直接朋友通信

5.直接朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式有很多，依赖，联合，组合，聚合等。其中我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

类图——聚合关系

聚合关系表示的是整体和部分的关系，整体与部分可以分开。聚合关系是关联关系的特例，所以它具有关联的导航性与多重性。

get set

类图——组合关系

组合关系也是整体与部分的关系，但是整体与部分不可以分开

在内部new出来


//IDCard与Person是聚合
//Head与Person是组合
public class Person{
    private IDCard card;
    private Head head = new Head();
}
public class IDCard{}
public class Head{}

设计模式：

设计模式分为三种类型

创建性模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式

单例模式

使用场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或者耗费资源过多（即；重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂）

饿汉模式：

在初始化时就创建，可能造成内存的浪费

package type.singleton.type1;

public class SingletonTest01 {


    public static void main(String[] args) {

//        测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton:"+singleton.hashCode());
        System.out.println("singleton1:"+singleton1.hashCode());
    }
}

//饿汉式（静态变量）
class Singleton{
//    1.构造器私有化，外部能new
    private Singleton(){

    }
//    2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

//    3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }

}

懒汉式（线程不安全）

//        在一个线程进入if判断的时候还未来记得往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以多线程下不饿能使用这种方式
//        在实际开发中不能使用这个方式
class Singleton{
    private static Singleton instance;
    private Singleton(){}

//    提供一个静态的共有方法，当使用到该方法时才去船舰instance
//    即懒汉模式
    public static Singleton getInstance(){
//        在一个线程进入if判断的时候还未来记得往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以多线程下不饿能使用这种方式
//        在实际开发中不能使用这个方式
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉式（线程安全）

解决了线程不安全问题

效率太低，每个线程想在获得类的实例时候，执行getInstance()方法时都要进行synchronized同步。而其实这个方法只执行一次实例化代码就够了，后面想获得该类实例，直接return。同步效率太低。

在实际开发中，不推荐使用这种方式

class Singleton{
    private static Singleton instance;
    private Singleton(){}

//    提供一个静态的共有方法，当使用到该方法时才去船舰instance
//    即懒汉模式
//    使用synchronized使线程变得安全
    public static synchronized Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

※懒汉式（双重检查）线程安全，同步方法

//线程安全，同步方法
class Singleton{
    private static Singleton instance;
    private Singleton(){}
//    提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题

    public static synchronized Singleton getInstance(){
        if (instance == null){

//            提供一个静态的公有方法，加入双创代码检查，解决线程安全问题，同时解决线程安全问题，同时解决懒加载问题
//            同时保证了效率，推荐使用
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

线程安全。延时加载，效率较高

推荐使用

※静态内部类

推荐使用

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。

静态内部类方式在singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

**类的静态属性只会在第一次加载类的时候初始化，**所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程时无法进入的。

优点：避免了线程不安全，利用进程内部类特点实现延迟加载，效率高

package type.singleton.type7.type6;

public class SingletonTest07 {
    public static void main(String[] args) {
//        测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton == singleton1);
        System.out.println("singleton:"+singleton.hashCode());
        System.out.println("singleton1:"+singleton1.hashCode());
    }
}

//静态内部类完成。推荐使用
class Singleton{
    private static Singleton instance;
//    构造器私有化
    private Singleton(){}

//    写一个静态内部类，
    private  static class SingletonInstance{
        private  static final Singleton INSTANCE = new Singleton();
}
//    提供一个静态的公有方法，直接返回SingleInstance.INSTANCE
    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }

}

※枚举方式实现单例

推荐使用

借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

package type.singleton.type8;

public class SingletonTest08 {
    public static void main(String[] args) {
//        测试
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;
        System.out.println(singleton == singleton1);
        System.out.println("singleton:"+singleton.hashCode());
        System.out.println("singleton1:"+singleton1.hashCode());
        singleton.sayOK();
    }
}

//枚举方式
enum Singleton{
    INSTANCE;
    public void sayOK(){
        System.out.println("OK~");
    }
}

单例模式JDK源码分析

java.lang.Runtime就是经典的单例模式（饿汉式）

简单工厂模式

例子：需求:披萨项目

披萨有多个种类、披萨有多种制作方式、完成披萨店订购功能。

没有使用简单工厂模式：优点是比较好理解，简单易操作。缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候尽量不修改代码，或者尽可能少修改代码。

改进方向：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可以，其他有创建到pizza对象的代码就不需要修改了

CheesPizza.java

package type.factory.simplefactory.pizzastore.pizza;

public class CheesPizza  extends Pizza{

    @Override
    public void prepare() {
        System.out.println("给制作奶酪Pizza准备原材料");
    }

}

GreekPizza.java

package type.factory.simplefactory.pizzastore.pizza;

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("给制作希腊披萨  准备原材料");
    }
}

PepperPizza.java

package type.factory.simplefactory.pizzastore.pizza;

public class PepperPizza extends Pizza{

    @Override
    public void prepare() {
        System.out.println("给胡椒披萨准备原材料");
    }
}

Pizza

package type.factory.simplefactory.pizzastore.pizza;

//将Pizza类做成抽象
public abstract class Pizza {
//    名字
    protected String name;
//    准备材料，不同的pizza不一样，因此，我们做成抽象方法
    public abstract void prepare();

    public void bake(){
        System.out.println(name + "baking;");
    }
    public void box(){
        System.out.println(name + "boxing;");
    }
    public void cut(){
        System.out.println(name + "cutting;");
    }
    public void setName(String name) {
        this.name = name;
    }
}

简单工厂模式：其实就是将OrderPozza中的挑选订购披萨的类型和具体的订购动作给分隔开，让简单工厂类SimpleFactory来进行挑选订购披萨的类型，订购动作OrderPozza只负责处理订购

OrderPozza.java

package type.factory.simplefactory.pizzastore.order;

import type.factory.simplefactory.pizzastore.pizza.*;
import type.factory.simplefactory.pizzastore.pizza.CheesPizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

//订购披萨动作类
public class OrderPozza {

    构造器
//    public OrderPozza(){
//        Pizza pizza = null;
        订购披萨的类型
//        String orderType;
//        do {
//            orderType = getType();
//            if (orderType.equals("greek")){
//                pizza = new GreekPizza();
//                pizza.setName("希腊披萨");
//            }else if (orderType.equals("cheese")){
//                pizza = new CheesPizza();
//                pizza.setName("奶酪披萨");
//            }else if (orderType.equals("pepper")){
//                pizza = new PepperPizza();
//                pizza.setName("胡椒披萨");
//            }else {
//                break;
//            }
//            pizza.prepare();
//            pizza.bake();
//            pizza.cut();
//            pizza.box();
//
//        }while (true);
//    }


//    定义一个简单工厂对象
    SimpleFactory simpleFactory;
    Pizza pizza = null;

//    构造器
    public  OrderPozza(SimpleFactory simpleFactory){
        setSimpleFactory(simpleFactory);
    }

    public void setSimpleFactory(SimpleFactory simpleFactory){
//        用户输入的
        String orderType = "";

//        设置简单工厂对象
        this.simpleFactory = simpleFactory;

        do {
            orderType = getType();
//            选择pizza
            pizza = this.simpleFactory.createPizza(orderType);
//            输出pizza
            if (pizza != null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            }else{
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }

//    写一个方法可以获取顾客希望订购的披萨种类
    private String getType(){
        try{
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}

PizzaStore.java

package type.factory.simplefactory.pizzastore.order;

public class PizzaStore {
    public static void main(String[] args) {
//        new OrderPozza();
//        使用简单工厂模式
        new OrderPozza(new SimpleFactory());
        System.out.println("退出程序");
    }
}

SimpleFactory.java

package type.factory.simplefactory.pizzastore.order;

import type.factory.simplefactory.pizzastore.pizza.CheesPizza;
import type.factory.simplefactory.pizzastore.pizza.GreekPizza;
import type.factory.simplefactory.pizzastore.pizza.PepperPizza;
import type.factory.simplefactory.pizzastore.pizza.Pizza;

public class SimpleFactory {
    public Pizza createPizza(String orderType){

        Pizza pizza =null;

        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        }else if (orderType.equals("cheese")){
            pizza = new CheesPizza();
            pizza.setName("奶酪披萨");
        }else if (orderType.equals("pepper")){
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}