diff --git "a/2022/07/20/Markdown \347\232\204\350\257\255\346\263\225/index.html" "b/2022/07/20/Markdown \347\232\204\350\257\255\346\263\225/index.html" index ded1e66b..8bbcba52 100644 --- "a/2022/07/20/Markdown \347\232\204\350\257\255\346\263\225/index.html" +++ "b/2022/07/20/Markdown \347\232\204\350\257\255\346\263\225/index.html" @@ -7,7 +7,7 @@ - +

无题

发表于|更新于
|字数总计:0|阅读时长:1分钟|阅读量:
评论
avatar
Jc Zhang
文章
55
标签
43
分类
21
Follow Me
公告
This is my Blog
+ + \ No newline at end of file diff --git "a/2024/05/19/\346\257\217\346\227\245\344\273\273\345\212\241/test/index.html" "b/2024/05/19/\346\257\217\346\227\245\344\273\273\345\212\241/test/index.html" new file mode 100644 index 00000000..9c5b668b --- /dev/null +++ "b/2024/05/19/\346\257\217\346\227\245\344\273\273\345\212\241/test/index.html" @@ -0,0 +1,348 @@ +test | 一个网站 + + + + + + + + + + + +

test

发表于|更新于
|字数总计:14|阅读时长:1分钟|阅读量:
    +

  • asd

    +

    asd

    asd

    1
    asdad
    +
      +
    • ajsd
      • +
    • asdsd
      • +
    • asdasd
      • +
    +
    • +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
asdads
asdasd
+
+

asdad

asdas

阿松大

+
评论
avatar
Jc Zhang
文章
55
标签
43
分类
21
Follow Me
公告
This is my Blog
+ + \ No newline at end of file diff --git "a/2024/05/24/java/\346\265\205\346\236\220\345\207\240\347\247\215\345\224\257\344\270\200id\347\224\237\346\210\220\347\256\227\346\263\225/index.html" "b/2024/05/24/java/\346\265\205\346\236\220\345\207\240\347\247\215\345\224\257\344\270\200id\347\224\237\346\210\220\347\256\227\346\263\225/index.html" new file mode 100644 index 00000000..42ebd9b9 --- /dev/null +++ "b/2024/05/24/java/\346\265\205\346\236\220\345\207\240\347\247\215\345\224\257\344\270\200id\347\224\237\346\210\220\347\256\227\346\263\225/index.html" @@ -0,0 +1,300 @@ +浅析几种唯一id生成算法 | 一个网站 + + + + + + + + + + + +

浅析几种唯一id生成算法

发表于|更新于
|字数总计:52|阅读时长:1分钟|阅读量:

UUID

UUID （Universally Unique Identifier），通用唯一识别码的缩写。UUID是由一组32位数的16进制数字所构成，所以UUID理论上的总数为 16^32=2^128，约等于 3.4 x 10^38。 ^3250ce

+
评论
avatar
Jc Zhang
文章
55
标签
43
分类
21
Follow Me
公告
This is my Blog
目录
  1. 1. UUID
+ + \ No newline at end of file diff --git "a/2024/05/26/java/\350\256\276\350\256\241\346\250\241\345\274\217/index.html" "b/2024/05/26/java/\350\256\276\350\256\241\346\250\241\345\274\217/index.html" new file mode 100644 index 00000000..1631f630 --- /dev/null +++ "b/2024/05/26/java/\350\256\276\350\256\241\346\250\241\345\274\217/index.html" @@ -0,0 +1,404 @@ +设计模式 | 一个网站 + + + + + + + + + + + +

设计模式

发表于|更新于
|字数总计:2.7k|阅读时长:9分钟|阅读量:

设计模式的六大原则

开放封闭原则（Open Close Principle）

    +
  • 原则思想：尽量通过扩展软件实体来解决需求变化，而不是通过修改已有的代码来完成变化
    • +
  • 描述：一个软件产品在生命周期内，都会发生变化，既然变化是一个既定的事实，我们就应该在设计的时候尽量适应这些变化，以提高项目的稳定性和灵活性。
    • +

  • 优点：单一原则告诉我们，每个类都有自己负责的职责，里氏替换原则不能破坏继承关系的体系。

    +

    里氏代换原则（Liskov Substitution Principle）

    • +

  • 原则思想：使用的基类可以在任何地方使用继承的子类，完美的替换基类。

    +
    • +
  • 大概意思是：子类可以扩展父类的功能，但不能改变父类原有的功能。子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法，子类中可以增加自己特有的方法。
    • +

  • 优点：增加程序的健壮性，即使增加了子类，原有的子类还可以继续运行，互不影响。

    +

    依赖倒转原则（Dependence Inversion Principle）

    • +

  • 依赖倒置原则的核心思想是面向接口编程.

    +
    • +

  • 依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类，

    +
    • +

  • 这个是开放封闭原则的基础，具体内容是：对接口编程，依赖于抽象而不依赖于具体。

    +

    接口隔离原则（Interface Segregation Principle）

    • +

  • 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

    +
    • +

  • 例如：支付类的接口和订单类的接口，需要把这俩个类别的接口变成俩个隔离的接口

    +

    单一职责原则（Principle of single responsibility）

    • +

  • 原则思想：一个方法只负责一件事情。

    +
    • +
  • 描述：单一职责原则很简单，一个方法 一个类只负责一个职责，各个职责的程序改动，不影响其它程序。 这是常识，几乎所有程序员都会遵循这个原则。
    • +
  • 优点：降低类和类的耦合，提高可读性，增加可维护性和可拓展性，降低可变性的风险。
    • +
+

创建型设计模式6

单例模式(Singleton pattern)

其目的是确保一个类只有一个实例，并提供一个全局访问点来访问该实例

+
+

全局访问点（Global Access Point）是指一种设计模式或机制，通过它可以从应用程序中的任何位置访问某个特定的资源或对象。在单例模式中，全局访问点通常是通过一个公共的静态方法来实现的，这个方法会返回单例类的唯一实例

+
+

应用场景:

    +
  • 网站的计数器：多个实例难以同步，保证线程安全。
    • +
  • 日志：节省资源，保证一致性，
      +
    • 关于一致性：
        +
      • 如果日志记录器有多个实例，可能会导致日志记录不一致。例如，不同的实例可能会配置不同的日志格式、输出目的地等，导致日志信息分散在不同的地方，难以统一管理和分析。单例模式保证了日志记录器的配置和行为在整个应用程序中是一致的。
        • +
      +
      • +
    +
    • +
  • 多线程的线程池的设计一般也是采用单例模式，因为线程池要方便对池中的线程进行控制。
    • +
  • Windows的（任务管理器）和回收站就是很典型的单例模式，他们不能打开俩个。

    单例创建方式

    • +

  • 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。，但如果实例占用资源多且未被使用，会造成资源浪费。

    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class EagerSingleton {
        private static final EagerSingleton instance = new EagerSingleton();

        private EagerSingleton() {
            // 私有化构造方法，防止外部实例化
        }

        public static EagerSingleton getInstance() {
            return instance;
        }
    }

    +
    • +

  • 懒汉式: 懒汉式在第一次使用时创建实例，适合延迟加载，但需要注意线程安全问题。

    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class LazySingleton {
        private static LazySingleton instance;

        private LazySingleton() {
            // 私有化构造方法，防止外部实例化
        }

        public static synchronized LazySingleton getInstance() {
            if (instance == null) {
                instance = new LazySingleton();
            }
            return instance;
        }
    }

    +
    • +

  • 静态内部方式: 结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载(静态内部类只有在其被使用时才会被加载)，加载类是线程安全的.

    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class StaticInnerClassSingleton {
        private StaticInnerClassSingleton() {
            // 私有化构造方法，防止外部实例化
        }

        private static class SingletonHolder {
            private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
        }

        public static StaticInnerClassSingleton getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }

    • +
  • 枚举单例：使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点是没有延迟加载。
    1
    2
    3
    4
    5
    6
    7
    public enum EnumSingleton {
        INSTANCE;

        public void doSomething() {
            System.out.println("Doing something...");
        }
    }
    • +
  • 双重检测锁方式: 在Java 5及以后的版本中，使用volatile关键字的双重检查锁定是安全且推荐的。对于Java 5之前的版本，由于没有volatile关键字的支持，双重检查锁定确实存在问题。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class DCLSingleton {
        private static volatile DCLSingleton instance;

        private DCLSingleton() {
            // 私有化构造方法，防止外部实例化
        }

        public static DCLSingleton getInstance() {
            if (instance == null) {
                synchronized (DCLSingleton.class) {
                    if (instance == null) {
                        instance = new DCLSingleton();
                    }
                }
            }
            return instance;
        }
    }

    +
    • +
+

工厂模式

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的方式，而无需在代码中显式指定具体类。这种模式将实例化对象的过程封装在工厂类中，从而使得代码更具灵活性和可维护性。
好处：

+
    +
  • 工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。
    • +
  • 利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。
    • +
  • 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

    简单工厂(Simple Factory)

    简单工厂模式通过一个静态方法，根据传入的参数决定创建哪一种类的实例。
    • +
+
    +
  1. 创建工厂
    1
    public interface Car { public void run(); }
    2. +
  2. 创建工厂的产品（宝马）
    1
    2
    3
    4
    5
    public class Bmw implements Car {
    	public void run() {
    		System.out.println("我是宝马汽车...");
    	}
    }
    3. +
  3. 创建工另外一种产品（奥迪）
    1
    2
    3
    4
    5
    public class AoDi implements Car {
    	public void run() {
    		System.out.println("我是奥迪汽车..");
    	}
    }
    4. +
  4. 创建核心工厂类，由他决定具体调用哪产品
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class CarFactory {

    	 public static Car createCar(String name) {
    		if ("".equals(name)) {
                 return null;
    		}
    		if(name.equals("奥迪")){
    			return new AoDi();
    		}
    		if(name.equals("宝马")){
    			return new Bmw();
    		}
    		return null;
    	}
    }
    +使用示例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class Client01 {

    	public static void main(String[] args) {
    		Car aodi  =CarFactory.createCar("奥迪");
    		Car bmw  =CarFactory.createCar("宝马");
    		aodi.run();
    		bmw.run();
    	}
    }
    5. +
+
    +
  • 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
    • +
  • 缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

    创建型 - 工厂方法(Factory Method)

    • +
  • 工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    // 产品接口（Product）
    public interface Car {
    	public void run();
    }
    // 具体产品（ConcreteProduct）
    public class AoDi implements Car {
    	public void run() {
    		System.out.println("我是奥迪汽车..");
    	}
    }

    public class Bmw implements Car {
    	public void run() {
    		System.out.println("我是宝马汽车...");
    	}
    }
    // 工厂接口（Creator）
    public interface CarFactory {

    	Car createCar();

    }
    // 具体工厂（ConcreteCreator）
    public class AoDiFactory implements CarFactory {

    	public Car createCar() {
    	
    		return new AoDi();
    	}
    }

    public class BmwFactory implements CarFactory {

    	public Car createCar() {

    		return new Bmw();
    	}

    }
    +使用：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class Client {

    	public static void main(String[] args) {
    		Car aodi = new AoDiFactory().createCar();
    		Car jili = new BmwFactory().createCar();
    		aodi.run();
    		jili.run();
    	}
    }
    +优点
    • +
+
    +

  1. 分离接口与实现：

    +
      +
    • 客户端代码通过抽象接口操作具体对象，而不关心具体实现类，符合依赖倒置原则（DIP）。
      • +
    +
    2. +

  2. 产品族一致性：

    +
      +
    • 抽象工厂模式可以确保同一个产品族中的对象一起使用时是兼容的，防止产品之间的不一致性问题。
      • +
    +
    3. +

  3. 符合开闭原则：

    +
      +
    • 增加新的产品族时，只需要增加具体的工厂类和产品类，而无需修改现有代码，符合开闭原则（OCP）。
      • +
    +
    4. +

  4. 高内聚：

    +
      +
    • 工厂类封装了创建对象的逻辑，单一职责明确，使代码更加模块化和可维护。
      • +
    +

    缺点

    +
    5. +

  5. 复杂性增加：

    +
      +
    • 引入大量的类，增加了系统的复杂度和理解难度，特别是在产品族和产品种类较多时。
      • +
    +
    6. +

  6. 难以扩展新的产品等级结构：

    +
      +
    • 抽象工厂模式很容易增加新的产品族，但不太容易增加新的产品等级结构（即增加新的产品种类）。如果需要增加新的产品种类，则需要修改抽象工厂接口及其所有子类。

      抽象工厂(Abstract Factory)

      • +
    +
    7. +
+

生成器(Builder)

原型模式(Prototype)

结构型设计模式7

外观模式(Facade pattern)

适配器模式(Adapter pattern)

桥接模式(Bridge pattern)

组合模式(composite pattern)

装饰者模式(decorator pattern)

享元模式(Flyweight Pattern)

代理模式(Proxy pattern)

行为型设计模式11

责任链模式(Chain of responsibility pattern)

策略模式(strategy pattern)

模板方法模式(Template pattern)

命令模式(Command pattern)

观察者模式(observer pattern)

访问者模式(visitor pattern)

状态模式(State pattern)

解释器模式(Interpreter pattern)

迭代器模式(iterator pattern)

中介者模式(Mediator pattern)

备忘录模式(Memento pattern)

评论
avatar
Jc Zhang
文章
55
标签
43
分类
21
Follow Me
公告
This is my Blog
+ + \ No newline at end of file diff --git a/about/index.html b/about/index.html index 0aa3d3c1..dd617109 100644 --- a/about/index.html +++ b/about/index.html @@ -139,7 +139,7 @@ } } detectApple() - })(window)

about

评论
avatar
Jc Zhang
文章
51
标签
43
分类
21
Follow Me
公告
This is my Blog
+ })(window)

about

评论
avatar
Jc Zhang
文章
55
标签
43
分类
21
Follow Me
公告
This is my Blog
分类 @@ -147,8 +147,8 @@
标签
gitmarkdownSpringBoot跨域问题操作系统PV操作Vue全栈前端后端java双指针快慢指针链表Leetcode栈算法数据结构堆，二叉树哈希表异或滑动窗口单调栈Linux队列单片机MSP430数据库吐槽日常实用技巧内网穿透编译原理JavaSEKMP动态规划二叉搜索树二叉树dp微服务
归档 -
网站资讯
文章数目 :
51
已运行时间 :
本站总字数 :
49.7k
本站访客数 :
本站总访问量 :
最后更新时间 :
Pixiv日榜

2024

文章总览 - 14
2024
Java集合
Java集合
leetcode_142. 环形链表 II
leetcode_142. 环形链表 II
leetcode_206. 反转链表
leetcode_206. 反转链表
感想
感想
avatar
Jc Zhang
文章
55
标签
43
分类
21
Follow Me
公告
This is my Blog
+ + 分类 + + +
+
标签
gitmarkdownSpringBoot跨域问题操作系统PV操作Vue全栈前端后端java双指针快慢指针链表Leetcode栈算法数据结构堆，二叉树哈希表异或滑动窗口单调栈Linux队列单片机MSP430数据库吐槽日常实用技巧内网穿透编译原理JavaSEKMP动态规划二叉搜索树二叉树dp微服务
归档 +
网站资讯
文章数目 :
55
已运行时间 :
本站总字数 :
57.2k
本站访客数 :
本站总访问量 :
最后更新时间 :
Pixiv日榜
+ + \ No newline at end of file diff --git a/archives/index.html b/archives/index.html index 053cc215..5e0936e2 100644 --- a/archives/index.html +++ b/archives/index.html @@ -48,7 +48,7 @@ isHome: false, isHighlightShrink: false, isToc: false, - postUpdate: '2024-05-14 22:28:33' + postUpdate: '2024-05-26 23:24:28' }