常用的设计模式--笔记

已于 2023-05-08 14:04:45 修改
阅读量102 收藏
点赞数
分类专栏： java 文章标签： 设计模式 笔记 java
于 2023-05-08 13:59:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59850019/article/details/130557605
版权

常用的设计模式

一 创建型模式

1-单例模式

1.Example
// 饿汉
public class SingletonExample {

    private static boolean flag = false;

    private static final SingletonExample singletonExample = new SingletonExample();

    private SingletonExample() {
        //防止反射创建,正常不需要
        if (flag) {
            throw new RuntimeException();
        } else {
            flag = true;
        }
    }


    public static SingletonExample getInstance() {
        return singletonExample;
    }
}

// 懒汉
public class SingletonPattern1 {

    private static boolean flag = false;

    private SingletonPattern1() {
        if (flag) {
            throw new RuntimeException();
        } else {
            flag = true;
        }
    }

    private static volatile SingletonPattern1 singletonPattern1 = null;

    /**
     * 懒汉模式非线程安全,需要加上线程安全
     *
     * @return
     */
    public static SingletonPattern1 getInstance() {
        if (singletonPattern1 == null) {
            singletonPattern1 = new SingletonPattern1();
        }
        return singletonPattern1;

    }
2.特点和使用场景:

1>优点

只有一个实例,减少内存开销;

2>缺点

扩展困难,只能修改代码

3.使用场景

windows的任务管理器 ,windows的回收站 ,同步计数器

2-工厂模式

1.Example

基类

//子类1
public class Cat implements Animal {
    @Override
    public void getName() {
        System.out.println("cat");
    }

    @Override
    public void playGame() {
        System.out.println("猫走猫步");
    }
}

//子类2
public class Dog implements Animal {
    @Override
    public void getName() {
        System.out.println("dog");
    }

    @Override
    public void playGame() {
        System.out.println("狗嗷嗷叫");
    }
}

//父接口
public interface Animal {

    void getName();

    void playGame();
}

//枚举类
public enum  AnimalEnum  {

    ANIMAL_CAT("1", Cat.class, "猫"),
    ANIMAL_DOG("2", Dog.class,"狗"),

    ;


    private String code;
    private Class aClass;
    private String desc;

    public Class getaClass() {
        return aClass;
    }

    public String getDesc() {
        return desc;
    }

    AnimalEnum(String code, Class aClass, String desc) {
        this.code = code;
        this.aClass = aClass;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public static  AnimalEnum getAnimalByCode(String code){

        for(AnimalEnum animalEnum :AnimalEnum.values()){
            if (animalEnum.getCode().equals(code)){
                return animalEnum;
            }
        }
        return null;
    }
}

简单工厂

//通过Map存储,type获取需要使用的类 
public class AnimalFactory {
   public static final  HashMap<String, Animal> animalHashMap = new HashMap<>();
    static {
        animalHashMap.put("1",new Cat());
        animalHashMap.put("2",new Dog());
    }

    public static Animal getAnimal(String type){

        return animalHashMap.get(type);
    }

}

反射工厂

//通过class获取反射  通过泛型通用
public class FactoryAnimal {
    public static <T> T  create(Class<? extends T> clazz, Class<T> tClass)  {
        try {
            if (clazz != null) {
                return clazz.newInstance();
            }
        } catch (Exception e) {
            throw  new RuntimeException("创建基类报错");
        }
        return null;
    }
}

测试:

public class FactoryTest {

    @Test
    public void get(){
        String type="1";
        //type 获取反射
        Animal animal = AnimalFactory.getAnimal(type);
        animal.getName();
        Class<Cat> catClass = Cat.class;
        Class<? extends Animal> aClass = animal.getClass();
        if (animal==null){
            throw new RuntimeException();
        }
        //通过枚举反射获取
        Animal animal1 =  FactoryAnimal.create(AnimalEnum.getAnimalByCode(type).getaClass(),Animal.class);
       animal.getName();
    }

} 


/*结果:cat
cat

Process finished with exit code 0
*/
2.特点和使用场景:

1>优点

避免创建类的重复代码出现,同时避免同一类的各种产品,同一种规则的不同实现;

2>缺点

多一种产品就需要多一种实现的方式,需要通过代码解决

3>使用场景

不同产品大部分流程相同,特定流程特定处理的问题;

例如:订单不同产品,不同发货的问题(虚拟发货,实体发货)

3.原型模式

1.Example

基类

@AllArgsConstructor
@NoArgsConstructor
public class Book implements Cloneable,Serializable{

    private int price;

    private String color;

    //简单克隆基础类,地址指向一致
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    //深克隆,地址指向不一致
    protected Object deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

  

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

测试类:

public class BookTest {

    public static void main(String[] args) throws Exception {
        Book book = new Book();
        book.setColor("123");
        book.setPrice(123);
        //浅克隆
        long time1 = new Date().getTime();
        //循环百万次
        for (int i = 0; i <1000000; i++) {
            Object clone = book.clone();
        }
        long time2 = new Date().getTime();
        System.out.println("浅克隆事件 = " + (time2-time1));


        //深克隆
        long time3 = new Date().getTime();
        //循环百万次
        for (int i = 0; i <1000000 ; i++) {
            Object o = book.deepClone();
        }
        long time4 = new Date().getTime();
        System.out.println("深克隆 = " + (time4-time3));

        //对象复制 地址指向不同,同时赋值
        long time5 = new Date().getTime();
        //循环百万次
        for (int i = 0; i <1000000 ; i++) {
            Book book1 = new Book();
            book1.setColor(book.getColor());
            book1.setPrice(book.getPrice());
        }
        long time6 = new Date().getTime();
        System.out.println("对象set = " + (time6-time5));


        //对象复制 地址指向不同,同时赋值
        long time7 = new Date().getTime();
        //循环百万次
        for (int i = 0; i <1000000 ; i++) {
            Book book1 = new Book();
            BeanUtils.copyProperties(book,book1);
        }
        long time8 = new Date().getTime();
        System.out.println("beanUtil = " + (time8-time7));

    }
}
2.特点和使用场景:

1>优点

网上表示能够比new 更节约时间,简化创建过程

2>缺点

没啥有点

3>使用场景

没想到特别好的场景,set速度更快,懒人用BeanUtils可能更好

4.建造者模式

1.建造者模式平常用的比较比较多的就是builder.链式创建对象;目前用封装的比较多

二 结构模式

1-代理模式

1-静态代理**
2-动态代理
1.Example

基类

public interface People {
    void  sleep();
}

public class Boy implements People {
    @Override
    public void sleep() {
        System.out.println("boy");
    }
}

public class Girl implements People{
    @Override
    public void sleep() {
        System.out.println("girl");
    }
}

动态代理

public class proxyAction<T> implements InvocationHandler {
    private T obj;

    public proxyAction() {
    }

    public T getObject(T obj) {
        this.obj = obj;
        Class aClass = obj.getClass();
        T o = (T)Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), 		this);
        return o;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] args) throws Throwable {
        System.out.println(1);
        Object invoke = method.invoke(this.obj, args);
        System.out.println(2);
        return invoke;
    }
	
	//测试
    public static void main(String[] args) {
        Girl girl = new Girl();
        //创建代理是确定泛型
        proxyAction<People> proxyAction = new proxyAction();
        People people =  proxyAction.getObject(girl);
        people.sleep();
    }
/*
//测试结果
1
girl
2
*/

}

2-适配者模式

1.Example
public interface Tyre {

    int getTyreOne();

    int getTyreTwo();

    int getTyreThree();

    int getTyreFour();
}

public interface Vehicle {
    int getTyre();
}

public class Bicycle implements Vehicle{


    @Override
    public int getTyre() {
        TyreLoad tyreLoad = new TyreLoad();
        return tyreLoad.getTyre(1);
    }
}

public class Car implements Vehicle{

    @Override
    public int getTyre() {
        TyreLoad tyreLoad = new TyreLoad();
        return tyreLoad.getTyre(4);
    }
}

// 适配器
public class TyreLoad implements Tyre{


    @Override
    public int getTyreOne() {
        return 1;
    }

    @Override
    public int getTyreTwo() {
        return 2;
    }

    @Override
    public int getTyreThree() {
        return 3;
    }

    @Override
    public int getTyreFour() {
        return 4;
    }

    public  int  getTyre(int a){
        if (a==1){
            return getTyreOne();
        }
        if (a==2){
            return getTyreTwo();
        }
        if (a==3){
            return getTyreThree();
        }
        if (a==4){
            return getTyreFour();
        }
        return 0;
    }

// 测试类
public class AdapterTest {

    public static void main(String[] args) {
        Car car = new Car();
        System.out.println(car.getTyre());
    }
}

/* 输出
4
*/

优点:

根据不同的类型给到不同的解决方案;

只定义规则,不涉及具体实现;

使用场景:

jdbc 连接数据库等

3-装饰模式

1.example
//房子
@Data
public class Home {
    //房价
    private int price;
    //房子
    private String desc;

    //实体构造
    public Home(Home home) {
        this.desc = home.getDesc();
        this.price = home.getPrice();
    }

    public Home(int price, String desc) {
        this.price = price;
        this.desc = desc;
    }

}

//装饰类
public class Door extends Home{

    //房价
    private int price;
    //房子
    private String desc;

    public Door(Home home) {
        super(home);
    }

    @Override
    public int getPrice() {
        return super.getPrice()+2;
    }

    @Override
    public String getDesc() {
        return "有门的"+super.getDesc();
    }

}

//测试类
public class DecoratorTest {

    public static void main(String[] args) {
        //构造基础类房子
        Home home = new Home(123, "房子");
        example(home);
        //装饰房子
        Door door = new Door(home);
        example(door);
    }


    public static void example(Home home){
        System.out.println(home.getDesc()+"价格是"+home.getPrice()+"万元");
    }
}

/*
运行结果
房子价格是123万元
有门的房子价格是125万元
*/

优点:

装饰模式很明显就是装修,对于原有功能的基础上添加功能,相比较静态代理而言更直接;

场景:

场景比较多,多数为对于同一产品的不同的处理,比如商品的包装;

4-桥接模式

1.example

不做具体代码实现,只是一种方式

桥接模式相比较适配差不多;

比如手机需要充电,都是充电头加充电线,以及连接方式,桥接如果没有现成结果可以制造一个方式;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tZVKfOgK-1683525491046)(C:\Users\33478\AppData\Roaming\Typora\typora-user-images\image-20230407103038727.png)]

不管中间的实现,只关注头跟尾;

沈么鬼？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
软件设计师笔记（面向对象---设计模式）
m0_58342134的博客
08-09 2658
软件设计师笔记（面向对象---设计模式）
常用的设计模式
weixin_41270708的博客
10-15 191
一、建造者 需求： 画人物，需要画一个人的左手，右手，左脚，右脚，身体，头部 画一个瘦子、画一个胖子 from abc import ABCMeta,abstractmethod class Builder(): __metaclass__=ABCMeta @abstractmethod def draw_left_arm(self): ...
Spring常用设计模式--抽象工厂模式
热门推荐
想着百万年薪努力的小赵
03-15 3万+
本专栏内容参考自：咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》，仅作个人学习记录使用，如有侵权，联系速删。   抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们的具体类。客户端（应用层）不依赖于产品实体类如何被创建、如何被实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。   看抽象工厂模式之前，我们要了解两个概念：产品等级结构和产品族.
Java设计模式-工厂模式
Java厂长
08-06 1万+
Java设计模式-工厂模式 什么是工厂模式？ 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 简单编写一个类： 1、简单工厂模式 interface IFruit{ public void eat(); //吃水果 } class Apple implements IFruit{ public voi
《C++20设计模式》学习笔记-第12章代理模式-配套代码
02-22
《C++20设计模式》学习笔记-第12章代理模式-配套代码
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
02-20
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
《C++20设计模式》学习笔记-第13章职责链模式-配套代码
02-27
《C++20设计模式》学习笔记-第13章职责链模式-配套代码
《C++20设计模式》学习笔记-第11章享元模式-配套代码
02-22
《C++20设计模式》学习笔记-第11章享元模式-配套代码
《C++20设计模式》学习笔记-第9章装饰器模式-配套代码
02-20
《C++20设计模式》学习笔记-第9章装饰器模式-配套代码
24下半年学习计划
最新发布
2301_80336512的博客
09-08 477
上课的时候认真听，不要以为提前了解一些知识就认为不重要，不听也要坚持看书，不要被外界吸引。我以后大概率走后端方向，对于后端的一些技术栈目前只是跟着网上的教程学，网上的教程大部分。只适合入门，对其原理背后的实行的机制还是需要看一些经典书籍，因此在这一学期除了完成实验。《设计模式之美》，提高自己编写代码的规范性，了解设计原理，养成良好的写代码习惯。，数据库对于后端开发者来说十分重要，这一部分知识要熟悉掌握。早睡早起，少熬夜，最好是每天早晨记10个单词，晚上睡前复习。
结构型设计模式—桥接模式
-
09-03 1186
桥接模式是一种很实用的结构型设计模式。如果软件系统中某个类存在两个独立变化的维度，通过该模式可以将这两个维度分离出来，使两者可以独立扩展，让系统更加符合单一职责原则。与多层继承方案不同，它将两个独立变化的维度设计为两个独立的继承等级结构，并且在抽象层建立一个抽象关联，该关联关系类似一条连接两个独立继承结构的桥，故名桥接模式。桥接模式用一种巧妙的方式处理多层继承存在的问题。
Java设计模式【备忘录模式】-行为型
lianyinghhh的博客
09-05 958
备忘录模式（Memento Pattern）是一种行为型设计模式，允许在不破坏封装的前提下，捕获并保存一个对象的内部状态，然后可以在以后将其恢复到原先保存的状态。备忘录模式的核心思想是记录和恢复对象的状态，通常用于“撤销（undo）”操作中。发起人（Originator）：负责创建备忘录对象来存储其内部状态，并能够从备忘录对象中恢复其状态。备忘录（Memento）：存储发起人的内部状态。备忘录对其他对象（尤其是管理者）是透明的，不能对其内部状态进行操作。管理者（Caretaker）
在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲
HGX-DJK
09-08 318
【代码】在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲。
Java设计模式中工厂模式与策略模式的区别
招风的黑耳CSDN
09-05 611
提供一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。这种模式使得系统能够独立于这些对象的创建过程，增加了系统的灵活性和可扩展性。
设计模式——建造者模式
weixin_44814196的博客
09-04 965
建造者模式（Builder Pattern）也叫做生成器模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
什么是Java中的模板方法模式？请给出示例。Java中的设计模式有哪些？请列举几个并解释其应用场景。
weixin_53180424的博客
09-05 822
定义并实现了一个模板方法，这个模板方法通常是一个具体方法，它给出了一个算法轮廓和骨架。这个模板方法中包含了若干个基本操作，这些基本操作可以是具体的，也可以是抽象的，需要由子类实现。
行为型设计模式-命令（command）模式-python实现
linkedin_21843693的博客
09-04 722
命令模式通过将请求封装成对象，实现了请求的发送者和接收者之间的解耦，提高了软件系统的灵活性。它适用于需要对操作进行记录、请求排队、撤销/重做操作等场景。在图形用户界面（GUI）工具栏和菜单、数据库事务操作等领域，命令模式是非常常见的设计模式。
漫谈设计模式 [10]：享元模式
刘炫320的博客
09-07 383
老鸟：假设你在游戏中有很多相同的树对象，每个树对象都保存了相同的属性，比如类型、颜色等。你会怎么实现呢？菜鸟：可能会创建一个Tree类，然后每次需要时实例化一个新的对象。# 创建很多树对象老鸟：这就是问题所在。你创建了很多相同的树对象，占用了大量内存。其实这些对象的某些属性是可以共享的。老鸟：总结一下，享元模式通过共享相似对象的内部状态，减少内存占用。适用于需要大量相似对象的场景。你可以参考《设计模式》这本书，里面有详细的介绍。菜鸟我会继续学习其他设计模式的！老鸟。
Head First 设计模式学习笔记概览
"这是一份关于Head First 设计模式的学习笔记，涵盖了多种常见的设计模式，包括但不限于观察者模式、装饰者模式、工厂模式、单件模式、命令模式、适配器与外观模式、模板方法模式、迭代器与组合模式、状态模式、代理...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值