java中设计模式的使用（持续更新中）

news/2024/11/16 19:54:36/

概述

设计模式的目的：编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序（软件），具有更好的

  • 代码重用性（相同功能的代码，不用多次编写）
  • 可读性（编程规范性，便于其他程序员的阅读和理解）
  • 可扩展性（当需要增加新的功能时，非常的方便，也叫可维护性）
  • 可靠性（当我们增加新的功能后，对原来的功能没用影响）
  • 使程序呈现高内聚，低耦合的特性

设计模式的七大原则：

  1. 单一职责原则
  • 对类来说，及一个类应该只负责一项职责。如类A负责两个不同的职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2。（例如一个UserDao,同时操作user表和order表，因此需要将UserDao拆分为UserDao和OrderDao）
  • 单一职责原则注意事项和细节
    • 降低类的复杂度，一个类只负责一项职责
    • 提高类的可读性，可维护性
    • 降低变更引起的风险
    • 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则
  1. 接口隔离原则
  • 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
  1. 依赖倒转原则
  • 高层模块不应该依赖底层模块，二者都应该依赖其抽象
  • 抽象不应该依赖细节，细节应该依赖抽象
  • 依赖倒转的中心思想是面向接口编程
  • 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的框架要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现
  • 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成
  1. 里氏替换原则
  • 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。
  • 继承在给程序设计带来遍历的同时，也带来了弊端。比如使用继承会给程序带来侵入性。程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且修改后，所有设计到子类的功能都有可能产生故障。
  1. 开闭原则ocp（开闭原则，工厂模式）
  • 开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则
  • 一个软件实体如类，模块和函数应该对扩展开放（针对提供方），对修改关闭（针对使用方）用抽象构建框架，用实现扩展细节
  • 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
  • 编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则
  1. 迪米特法则
  • 一个对象应该对其他对象保持最少的了解
  • 类与类关系越密切，耦合度越大
  • 迪米特法则，又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么的复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不对外泄漏任务信息
  • 迪米特法则还有哥更简单的定义：只与直接的朋友通信。（直接朋友：每个对象都会与其他对象有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部）
  1. 合成复用原则
  • 原则是尽量使用合成/聚合的方式，而不是使用继承

设计模式分为三种类型

  • 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式
  • 结构型模式：适配器模式、桥接模式、装饰者模式、组合模式、外观模式、享元模式、代理模式
  • 行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式

1.单例模式

所谓类得单例设计模式、就是采取一定得方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得对象实例的方法（一般静态方法）。

  • 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  • 当想实例化一个单例类时候，必须要记住使用相应的获取对象的方法，而不是使用new
  • 单例模式使用的场景：需要频繁的进行创建和销毁的对象，创建对象时耗时过多或消耗资源过多（即：重量级对象），但又经常用到的对象，工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）

单例模式有八种方式：

  • 饿汉式（静态常量）
  • 饿汉式（静态代码块）
  • 懒汉式（线程不安全）
  • 懒汉式（线程安全，同步方法）
  • 懒汉式（线程安全，同步代码块）
  • 双重检查
  • 静态内部类
  • 枚举

步骤：构造方法私有化，提供一个公共的方法供外部获取对象

饿汉式（静态常量）

优点：在类装载的时候就完成实例化，避免了线程同步问题

缺点：从未使用过这个实例，造成内存浪费

java">public class Singleton {private static final Singleton instance = new Singleton();//构造方法私有化private Singleton(){}//公共方法获取实例public static Singleton getInstance(){return instance;}
}
饿汉式（静态代码块）
java">public class Singleton {private static Singleton instance;static {instance = new Singleton();}private Singleton(){}public static Singleton getInstance(){return instance;}
}
懒汉式（线程不安全）

在多线程环境下，一个线程进入了if判断语句块，还未来得及往下执行，另外一个线程获得cpu的时间片往下执行，会创建多个实例。

java">public class Singleto {private static Singleto instance;private Singleto(){}public static Singleto getInstance(){if(instance == null){instance = new Singleto();}return instance;}
}
懒汉式（线程安全，同步方法）

解决线程不安全问题，但是效率低，当对象已经被创建后，所有线程都还是会去竞争锁，还是会去进入判断

java">public class Singleto {private static Singleto instance;private Singleto(){}public static synchronized  Singleto getInstance(){if(instance == null){instance = new Singleto();}return instance;}
}
懒汉式（线程安全，同步代码块）
java">public class Singleto {private static Singleto instance;private Singleto(){}public static  Singleto getInstance(){synchronized (Singleto.class) {if (instance == null) {instance = new Singleto();}return instance;}}
}
双重检查

又叫双重校验锁，解决线程安全问题，同时解决竞争锁性能问题，并且满足懒加载

java">public class Singleto {private static Singleto instance;private Singleto() {}public static Singleto getInstance() {if (instance == null) {synchronized (Singleto.class) {if (instance == null) {instance = new Singleto();}}}return instance;}
}
静态内部类

SingletonHolder在Singleto装载时不会被加载，在调用getInstance时才被加载，达到懒加载模式。并且jvm加载类时是线程安全的。

java">public class Singleto {private Singleto(){}private static class SingletonHolder{private static final Singleto INSTANCE = new Singleto();}public static Singleto getInstance(){return SingletonHolder.INSTANCE;} 
}
枚举
java">public enum Singleton {INSTANCE;public void doSomething() {}
}

2.工厂模式

  • 工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性
  • 三种工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）
  • 创建对象实例时，不要直接new，而是吧这个new类的动作放在一个工厂的方法中，并返回，变量不要直接持有具体类的引用。
  • 不要让类继续具体类，而是继承抽象类或者是实现接口
  • 不要覆盖基类中已经实现的方法
2.1简单工厂模式

简单工厂模式又叫静态工厂模式，原理就是将需要创建的对象抽取到一个工厂类中。使用的时候通过调用工厂获取对象，这样可以将对象的创建等细节抽取到一处，发生变更时只用更改工厂类即可，满足ocp原则。

披萨基类

java">public abstract class Pizza {String name;public abstract void prepare();public abstract void bake();public abstract void cut();public abstract void box();
}

创建两种披萨

java">/*** 芝士披萨** @author * @date 2024-11-06*/
public class CheesePizza extends Pizza {public CheesePizza() {super.name = "奶酪披萨";}public void prepare() {System.out.println("开始制作" + name);}public void bake() {System.out.println(name + "烘烤中");}public void cut() {System.out.println(name + "切割中");}public void box() {System.out.println(name + "打包中");}
}
java">/*** 牛肉披萨** @author * @date 2024-11-06*/
public class BeefPizza extends Pizza{public BeefPizza() {super.name = "牛肉披萨";}public void prepare() {System.out.println("开始制作" + name);}public void bake() {System.out.println(name + "烘烤中");}public void cut() {System.out.println(name + "切割中");}public void box() {System.out.println(name + "打包中");}
}

创建一个披萨订单

java">/*** 订一个披萨** @author * @date 2024-11-06*/
public class OrderPizza {String type;public OrderPizza(String type) {this.type = type;}public void submitOrder() {String orderType;orderType = getType();Pizza pizza = PizzaFactory.createPizza(orderType);pizza.prepare();pizza.bake();pizza.cut();pizza.box();}private String getType() {return this.type;}
}

创建披萨工厂

java">/*** 披萨工厂** @author * @date 2024-11-06*/
public class PizzaFactory {public static Pizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new CheesePizza();} else if (orderType.equals("beef")) {pizza = new BeefPizza();} else {System.out.println("没有该类型");}return pizza;}
}

披萨店订购披萨

java">/*** 披萨店** @author * @date 2024-11-06*/
public class PizzaStore {public static void main(String[] args) {OrderPizza orderPizza = new OrderPizza("beef");orderPizza.submitOrder();}
}

这样的好处就是扩展性强，以后有其他的披萨类型，只用创建一个新的披萨类，然后再工厂中添加新的披萨，其他使用工厂的创建即可，不用关心对象的创建。不使用工厂模式，新添加一个类型时，所有创建披萨的地方都要更改。

2.2工厂方法模式

工厂方法模式：定义一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

披萨基类

java">public abstract class Pizza {String name;public abstract void prepare();public abstract void bake();public abstract void cut();public abstract void box();
}

不同区域和口味的披萨

java">public class BJBeefPizza extends Pizza {public BJBeefPizza() {super.name = "北京牛肉披萨";}public void prepare() {System.out.println("开始制作" + name);}public void bake() {System.out.println(name + "烘烤中");}public void cut() {System.out.println(name + "切割中");}public void box() {System.out.println(name + "打包中");}
}public class BJCheesePizza extends Pizza {public BJCheesePizza() {super.name = "北京奶酪披萨";}public void prepare() {System.out.println("开始制作" + name);}public void bake() {System.out.println(name + "烘烤中");}public void cut() {System.out.println(name + "切割中");}public void box() {System.out.println(name + "打包中");}
}public class CDBeefPizza extends Pizza {public CDBeefPizza() {super.name = "成都牛肉披萨";}public void prepare() {System.out.println("开始制作" + name);}public void bake() {System.out.println(name + "烘烤中");}public void cut() {System.out.println(name + "切割中");}public void box() {System.out.println(name + "打包中");}
}public class CDCheesePizza extends Pizza {public CDCheesePizza() {super.name = "成都奶酪披萨";}public void prepare() {System.out.println("开始制作" + name);}public void bake() {System.out.println(name + "烘烤中");}public void cut() {System.out.println(name + "切割中");}public void box() {System.out.println(name + "打包中");}
}

抽象工厂方法类

java">public abstract class OrderPizza {protected String orderType;abstract Pizza createPizza(String orderType);public OrderPizza(String type) {orderType = type;}public void submitOrder() {Pizza pizza = createPizza(orderType);pizza.prepare();pizza.bake();pizza.cut();pizza.box();}
}

具体的工厂实现

java">public class BJOrderPizza extends OrderPizza {public BJOrderPizza(String type) {super(type);}Pizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new BJCheesePizza();} else if (orderType.equals("beef")) {pizza = new BJBeefPizza();}return pizza;}
}public class CDOrderPizza extends OrderPizza{public CDOrderPizza(String type) {super(type);}Pizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new CDCheesePizza();} else if (orderType.equals("beef")) {pizza = new CDBeefPizza();}return pizza;}
}

演示

java">
public class PizzaStore {public static void main(String[] args) {new BJOrderPizza("cheese").submitOrder();new CDOrderPizza("beef").submitOrder();}
}
2.3抽象工厂模式
  • 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
  • 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
  • 从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）
  • 将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。程序员可以根据创建对象类型使用相应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

抽象工厂

java">public interface AbsFactory {Pizza createPizza(String type);
}

具体的工厂

java">public class BJFactory implements AbsFactory{public Pizza createPizza(String type) {Pizza pizza = null;if (type.equals("cheese")) {pizza = new BJCheesePizza();} else if (type.equals("beef")) {pizza = new BJBeefPizza();}return pizza;}
}public class CDFactory implements AbsFactory{public Pizza createPizza(String type) {Pizza pizza = null;if (type.equals("cheese")) {pizza = new CDCheesePizza();} else if (type.equals("beef")) {pizza = new CDBeefPizza();}return pizza;}
}

工厂的使用

java">public class OrderPizza {AbsFactory factory;public OrderPizza(AbsFactory factory){this.factory = factory;}public void submitOrder(String orderType) {Pizza pizza = factory.createPizza(orderType);pizza.prepare();pizza.bake();pizza.cut();pizza.box();}
}

结果展示

java">
public class PizzaStore {public static void main(String[] args) {OrderPizza orderPizza = new OrderPizza(new BJFactory());orderPizza.submitOrder("cheese");}
}

3.原型模式

  • 原型模式（prototype）是指：用原型实例指定创建对象的种类。并且通过拷贝这些原型，创建新的对象。
  • 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需指定如何创建的细节
  • 工作原理是通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即，对象.clone()
3.1代码实现

原型类实现Cloneable接口，覆写clone方法

java">public class Sheep implements Cloneable{private String name;private int age;private String color;public Sheep(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {}@Overridepublic String toString() {return "Sheep{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
3.2深拷贝和浅拷贝问题

浅拷贝

  • 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象
  • 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
  • 浅拷贝则是使用默认的clone（）方法来实现

深拷贝

  • 复制对象的所有基本数据类型的成员变量值
  • 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝
  • 深拷贝实现方式1：重写clone方法来实现深拷贝
  • 深拷贝实现方式2：通过对象序列化实现深拷贝（推荐）
java">package com.demo.design_pattern.prototype;import java.io.Serializable;public class Beef implements Cloneable, Serializable {private String name;public Beef(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Beef{" +"name='" + name + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}

java">package com.demo.design_pattern.prototype;import java.io.*;public class Sheep implements Cloneable , Serializable {private String name;private int age;private String color;private Beef friend;public Sheep(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public Beef getFriend() {return friend;}public void setFriend(Beef friend) {this.friend = friend;}@Overridepublic String toString() {return "Sheep{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +", friend=" + friend +'}';}/** 方式一：完成深拷贝* */@Overrideprotected Object clone() throws CloneNotSupportedException {Object clone = super.clone();Sheep sheep = (Sheep) clone;sheep.friend = (Beef) this.friend.clone();return clone;}/** 方式二：完成深拷贝* */public Object deepClone(){Sheep sheep = null;ByteArrayOutputStream bos = null;ObjectOutputStream oos = null;ByteArrayInputStream bis =null;ObjectInputStream ois =null;//创建流对象try {bos = new ByteArrayOutputStream();oos = new ObjectOutputStream(bos);// 序列号，写入当前对象的二进制流oos.writeObject(this);bis = new ByteArrayInputStream(bos.toByteArray());ois = new ObjectInputStream(bis);// 反序列化，从二进制流产生当前对象sheep = (Sheep) ois.readObject();} catch (Exception e){e.printStackTrace();}finally {try {assert bos != null;bos.close();assert oos != null;oos.close();assert bis != null;bis.close();assert ois != null;ois.close();} catch (IOException e) {e.printStackTrace();}}return sheep;}
}

代码演示


java">  Sheep sheep = new Sheep("肖恩", 12, "白色");sheep.setFriend(new Beef("小黑"));
//        Sheep sheep1 = (Sheep) sheep.clone();Sheep sheep1 = (Sheep) sheep.deepClone();System.out.println(sheep1.getFriend() == sheep.getFriend());System.out.println(sheep1);System.out.println(sheep);

原型模式的注意事项和细节：

  • 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能提高效率
  • 不用重新初始化对象，而是动态地获得运行时的状态
  • 如果原始对象发生改变（增加或减少属性），其它克隆对象也会发生相应的变化，而无需修改代码
  • 缺点：需要为每一个类配备一个克隆方法，对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了opc原则。

4.建造者模式

4.1概念
  • 建造者模式（Builder Pattern）又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象
  • 建造者模式使一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。
4.2核心角色
  • Product(产品角色)：一个具体的产品对象
  • Builder（抽象建造者）：创建一个Product对象的各个部件指定的接口/抽象类。
  • ConcreteBuilder（具体建造者）：实现接口，构建和装配各个部件。
  • Director（指挥者）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要又两个作用，一是：隔离了客户与对象的生产过程，二是负责控制产品对象的生产过程。
4.3代码实现

4.3.1建造的产品
java">/*** 房子 --- 对应product** @author * @date 2024-11-11*/
public class House {private String basic;private String wall;private String roofed;public String getBasic() {return basic;}public void setBasic(String basic) {this.basic = basic;}public String getWall() {return wall;}public void setWall(String wall) {this.wall = wall;}public String getRoofed() {return roofed;}public void setRoofed(String roofed) {this.roofed = roofed;}}
4.3.2抽象建造者-定义建造的方法
java">/*** 房屋建造者 --- 对应抽象的建造者** @author * @date 2024-11-11*/
public abstract class HouseBuilder {protected House house = new House();/** 定义房子建造的步骤* */public abstract void buildBasic();public abstract void buildWall();public abstract void roofed();public House buildHouse() {return house;}
}
4.3.3具体的建造执行者--实现具体的建造方法
java">public class HigBuilding extends HouseBuilder{@Overridepublic void buildBasic() {System.out.println("高楼房子打地基50米");house.setBasic("高楼房子打地基50米");}@Overridepublic void buildWall() {System.out.println("高楼房子砌墙80cm");house.setWall("高楼房子砌墙80cm");}@Overridepublic void roofed() {System.out.println("高楼房子封顶");house.setRoofed("高楼房子封顶");}
}
4.3.4指挥者 --- 定义建造的流程（控制方法的执行流程）
java">/*** 房子建造指挥者** @author * @date 2024-11-11*/
public class HouseDirector {private HouseBuilder houseBuilder;public HouseDirector(HouseBuilder houseBuilder) {this.houseBuilder = houseBuilder;}/*** 建造房子，定义产品的创建过程** @return */public House constructHouse() {// 调用建造者中的方法，完成产品的创建houseBuilder.buildBasic();houseBuilder.buildWall();houseBuilder.roofed();return houseBuilder.buildHouse();}
}
4.3.5使用
java">public class Client {public static void main(String[] args) {HigBuilding higBuilding = new HigBuilding();HouseDirector houseDirector = new HouseDirector(higBuilding);House house = houseDirector.constructHouse();System.out.println(house);}
}
4.3.6建造者模式的注意事项和细节
  • 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制
  • 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式

抽象工厂模式 vs 建造者模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要去按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品


http://www.ppmy.cn/news/1547527.html

相关文章

数据结构题集-第二章-线性表-有序未去重顺序表的交集

数据结构题集-第二章-线性表-有序未去重顺序表的交集

有序未去重顺序表的交集 说明2.27 假设两个元素依值递增有序排列的线性表A和B解1解2 说明 本文参照严蔚敏《数据结构(C语言版)题集》一书中包含的问答题和算法设计题目，提供解答和算法的解决方案。请读者在自己已经解决了某个题目或进行了充分的思考之后&#xff0…
阅读更多...
图形几何之美系列：仿射变换矩阵之先转后偏

图形几何之美系列：仿射变换矩阵之先转后偏

“在几何计算、图形渲染、动画、游戏开发等领域，常需要进行元素的平移、旋转、缩放等操作，一种广泛应用且简便的方法是使用仿射变换进行处理。相关的概念还有欧拉角、四元数等，四元数在图形学中主要用于解决旋转问题，特别是在三维…
阅读更多...
DB-GPT系列（四）：DB-GPT六大基础应用场景part1

DB-GPT系列（四）：DB-GPT六大基础应用场景part1

一、基础问答 进入DB-GPT后，再在线对话默认的基础功能就是对话功能。这里我们可以和使用通义千问、文心一言等在线大模型类似的方法， 来和DB-GPT进行对话。 但是值得注意的是，DB-GPT的输出结果是在内置提示词基础之上进行的回答&#xff0c…
阅读更多...
Java项目实战II基于微信小程序的实习记录（开发文档+数据库+源码）

Java项目实战II基于微信小程序的实习记录（开发文档+数据库+源码）

目录 一、前言 二、技术介绍 三、系统实现 四、文档参考 五、核心代码 六、源码获取 全栈码农以及毕业设计实战开发，CSDN平台Java领域新星创作者，专注于大学生项目实战开发、讲解和毕业答疑辅导。获取源码联系方式请查看文末 一、前言 在高等教育…
阅读更多...
spark.default.parallelism 在什么时候起作用，与spark.sql.shuffle.partitions有什么异同点？

spark.default.parallelism 在什么时候起作用，与spark.sql.shuffle.partitions有什么异同点？

spark.default.parallelism 和 spark.sql.shuffle.partitions 是 Spark 中两个控制并行度的配置参数，但它们作用的场景和用途不同： spark.default.parallelism 用途：spark.default.parallelism 用于控制 RDD 中的默认分区数。适用场景&…
阅读更多...
音视频入门基础：MPEG2-TS专题（4）——使用工具分析MPEG2-TS传输流

音视频入门基础：MPEG2-TS专题（4）——使用工具分析MPEG2-TS传输流

一、引言 有很多工具可以分析MPEG2-TS文件/流，比如Elecard Stream Analyzer、PROMAX TS Analyser、easyice等。下面一一对它们进行简介（个人感觉easyice功能更强大一点）。 二、Elecard Stream Analyzer 使用Elecard Stream Analyzer工具可以…
阅读更多...
【mysql】使用宝塔面板在云服务器上安装MySQL数据库并实现远程连接

【mysql】使用宝塔面板在云服务器上安装MySQL数据库并实现远程连接

前言 使用宝塔Linux面板安装MySQL数据库并实现远程连接 使用宝塔面板安装mysql 宝塔面板，华为云开放3306端口 一些命令 // 命令行连接数据库 mysql -uroot -p // MySQL 5 版本 GRANT ALL ON *.* TO root% IDENTIFIED BY 替换成你的root密码 WITH GRANT OPTION; // …
阅读更多...
C++ 数据结构详解

C++ 数据结构详解

目录 C 数据结构详解 引言 1. 数组 (Array) 示例代码 2. 向量 (Vector) 示例代码 3. 链表 (List) 示例代码 4. 栈 (Stack) 示例代码 5. 队列 (Queue) 示例代码 6. 集合 (Set) 示例代码 7. 映射 (Map) 示例代码 C 数据结构详解 引言 数据结构是计算机科学中的…
阅读更多...
最新文章

Copyright @ 2022~2023