设计模式(一)

1、适配器模式

(1)概述

  • 适配器中有一个适配器包装类Adapter,其包装的对象为适配者Adaptee,适配器作用就是将客户端请求转化为调用适配者中的接口;
  • 当调用适配器中的方法时,适配器内部会调用适配者类的方法,这个调用对客户端是透明,实现了不同接口之间由于不兼容的类,可以相互调用;

(2)对象适配器

  • Target(目标抽象类):可以是一个抽象类或接口,该类为客户端所需要的接口;
  • Adapter(适配器类):Adapter可以调用另外一个接口,对Target和Adaptee进行适配,Target通过Adapter可以调用Adaptee中的业务逻辑,对客户端是透明的;
  • Adaptee(适配者类):定义了一个已经存在的接口,适配者类一般是一个具体的类,包含了客户需要调用的业务方法;
  • Adapter和Adaptee是关联关系;

//适配器
public class Adapter implements Target{private MySQLConnect mySQLConnect;//适配者对象public Adapter(MySQLConnect mySQLConnect){this.mySQLConnect=mySQLConnect;}@Overridepublic void connect() {mySQLConnect.mysqlConnect();}
}
public interface Target {public void connect();
}
//适配者
public class MySQLConnect {public void mysqlConnect(){System.out.println("数据库链接配置");}
}
//测试
public class Main {public static void main(String[] args) {Target target=new Adapter(new MySQLConnect());target.connect();}
}

(3)类适配器

  • 适配器和适配者之间的关系为继承;
  • 适配器实现了Target接口,继承了Adapteee类;
  • 当Target不是接口,而是抽象类,则无法使用类适配器,当Adaptee类被final修饰,也不能使用类适配器;
//适配器类,其他代码和上一样
public class Adapter extends MySQLConnect implements Target{@Overridepublic void connect() {mysqlConnect();}
}

(3)缺省适配器

  • ServiceInterface(适配者接口):为一个接口,实现大量方法;
  • AbstractServiceClass(缺省适配器类):实现了适配者接口中所有方法,使用空方法形式;
  • ConcreteServiceClass(业务类):为缺省适配器的子类,在没有适配器之前,该类需要实现ServiceInterface中所有方法,引入适配器类后,只需要继承适配器类,实现对应的方法即可;
public interface ServiceInterface {public void print();public void eat();public void smell();
}
public class AbstractService implements ServiceInterface{//缺省适配器@Overridepublic void print() { }@Overridepublic void eat() { }@Overridepublic void smell() { }
}
public class ConcreteService extends AbstractService{@Overridepublic void print() {//重写打印接口System.out.println("打印");}
}

(4)总结

优点:

  • 目标类和适配者类解耦,通过引入一个适配器类来重用现有的适配者类,无序修改原有代码结构;
  • 增加了类的透明性和复用性,将业务代码封装在适配者类中,对于用户是透明的,同时适配者类可以被多个不同系统调用
  • 灵活性和扩展性好,通过配置文件切换适配器类,可以在原有基础上添加新的适配器类,符合开闭原则;

缺点:

  • 类适配器中只能适配一个适配者类,java不能多继承;
  • 对象适配器,在适配器重置换适配者类比较麻烦,需要先创建一个适配者类的子类,重写需要置换的方法,然后再将适配器适配到这个子类;

使用场景:

  • 系统需要使用已有的接口,而这些接口不符合系统需求,甚至没有源代码;
  • 想创建一个可以重复使用的类,用于一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作;

2、工厂方法模式

(1)概述

  • 工厂方法定义一个创建对象的接口,让实现该接口的子类取实例化对象。
  • 工厂方法将对象的实例化延迟到其子类创建;

(2)角色

  • Product(抽象产品):定义产品接口(某个类型产品),是工厂方法模式中,所有创建对象的公共父类;
  • ConcreteProduct(具体产品):实现抽象产品的接口,即某种类型的具体产品,与一个具体工厂一一对应;
  • Factory(抽象工厂):创建对象工厂的接口,声明工厂方法(Factory Method),用于返回一个产品,所有创建对象的工厂类都需要实现该接口;
  • ConcreteFactory(具体工厂):实现抽象工厂的工厂方法,返回一个具体的产品;

(3)实现

public interface Factory {public Product create();
}
public class MySQLFactory implements Factory{@Overridepublic Product create() {return new MySQLProduct();}
}
public abstract class Factory {//抽象工厂public void connect(){//对客户端隐藏调用具体产品的方法Product product = this.create();product.connect();}public abstract Product create();
}
public class MySQLFactory extends Factory{//具体工厂@Overridepublic Product create() {return new MySQLProduct();}
}
public class Main {public static void main(String[] args) {Factory factory=new MySQLFactory();//可以通过配置文件配置,进行工厂方法切换factory.connect();}
}

(4)总结

优点

  • 客户端只需要知道创建对象的工厂方法,工厂方法隐藏具体具体对象被实例化的细节,客户端无需关系对象如何创建,甚至无需关心对象的具体类名;
  • 当需要加入一个新的对象产品时,无需修改原系统,只需要新增一个具体对象类和对应的工厂类即可;

缺点:

  • 每新增一个产品,就需要新增对应的产品类和工厂类,增加系统复杂度,同时由更多类需要被系统加载,会给系统带来一些而外的开销;
  • 引入抽象层,增加系统抽象性和可理解性;

使用场景:

  • 客户端不知道他所需要的类;
  • 抽象工厂类通过子类创建对象;

3、抽象工厂模式

(1)概述

  • 产品等级结构:即产品的继承结构,一个抽象产品,多个相同的产品继承该抽象产品,一个抽象产品与其子类构成一个产品等级结构。如:电视机为抽象类,则海尔电视机,华普电视机,创维电视机为其子类,共同构成一个产品等级结构;
  • 产品族:产品族是由同一个工厂产生的,位于不同产品等级结构的一组产品;
  • 一个工厂负责生产一个产品族(即下图颜色相同的);
  • 抽象工厂会提供一个创建一系列相关或相互依赖的对象的接口,而无需指定他们的具体实现类;

(2)角色

  • AbstractFactory(抽象工厂):声明一些列创建产品族的方法,每一个方法对应一个产品;
  • ConcreteFactory(具体工厂):实现抽象工厂中的方法,用于创建一组具体产品,这些具体产品构成一个产品族,位于一个产品等级结构中;
  • AbstractProduct(抽象产品):为每种产品生成一种接口,在抽象产品中声明了产品所具有的业务方法;
  • ConcreteProduct(具体产品):他定义具体工厂生成的产品对象,实现抽象产品接口中声明的业务方法;

(3)实现

public interface AbstractFactory {//抽象工厂public AbstractProductA createProductA();public AbstractProductB createProductB();
}
public class ConcreteProduct1 implements AbstractFactory{//具体工厂1@Overridepublic AbstractProductA createProductA() {return new ProductA1();}@Overridepublic AbstractProductB createProductB() {return new ProductB1();}
}
public class ConcreteProduct2 implements AbstractFactory{//具体工厂2@Overridepublic AbstractProductA createProductA() {return new ProductA2();}@Overridepublic AbstractProductB createProductB() {return new ProductB2();}
}
public interface AbstractProductA {//抽象产品Apublic void printA();
}
public class ProductA1 implements AbstractProductA{//具体产品A--1@Overridepublic void printA() {System.out.println("产品A类--型号1类型");}
}
public class ProductA2 implements AbstractProductA{//具体产品A---2@Overridepublic void printA() {System.out.println("产品A类--型号2类型");}
}
public interface AbstractProductB {//抽象产品Bpublic void printB();
}
public class ProductB1 implements AbstractProductB{//具体产品B--1@Overridepublic void printB() {System.out.println("产品B类--型号1类型");}
}
public class ProductB2 implements AbstractProductB{//具体产品B--2@Overridepublic void printB() {System.out.println("产品B类--型号2类型");}
}
public class Main {//测试类public static void main(String[] args) {System.out.println("工厂1生成对应1号类型的产品族");AbstractFactory factory1=new ConcreteProduct1();factory1.createProductA().printA();factory1.createProductB().printB();System.out.println("工厂2生成对应的2号类型的产品族");AbstractFactory factory2=new ConcreteProduct2();factory2.createProductA().printA();factory2.createProductB().printB();}
}

(4)总结

优点:

  • 客户端不需要知道产品如何创建,如果需要切换产品,更换一个具体工厂即可;
  • 增加新的产品族十分方便,无需修改原系统,符合开闭原则;

缺点:

  • 添加一个产品等级结构系列时,需要从修改原有系统中的所有工厂方法,不符合开闭原则;

使用场景:

  • 一个系统不依赖对象的创建,组合,客户端无需知道对象如何创建;
  • 系统中有多个产品族,每次只使用一个产品族;
  • 同一个产品族中的产品将在一起使用,同一个产品族的产品可以没有任何关系,但必须是有一总共同约束;

4、装饰器模式

(1)概述

  • 装饰模式可以在不改变原有对象的模式下,增加额外行为;
  • 可以动态给对象增加一些职责;

(2)角色

  • Component(抽象组件):他是具体组件和装饰组件的父类,声明了具体组件实现的业务方法,为客户端提供以一致方式处理装饰前以及装饰后的组件;
  • ConcreteComponent(具体组件):Component的子类,用于定义具体的组件方法,装饰器类可以给他增加额外职责;
  • Decorator(抽象装饰类):Component子类,用于给具体组件添加新的职责,他维护一个指向抽象组件的应用,通过该应用可以调用装饰之前的组件,并通过起子类扩展职责;
  • ConcreteDecorator(具体装饰类):抽象装饰类的子类,负责向具体组件添加新的职责;

(3)实现

public interface Component {//抽象组件public void operation();
}
public class ConcreteComponent implements Component{//具体组件@Overridepublic void operation() {System.out.println("组件操作");}
}
public class Decorator implements Component{//抽象装饰器private Component component;public Decorator(Component component){this.component=component;}@Overridepublic void operation() {component.operation();}
}
public class ConcreteDecoratorA extends Decorator{//具体装饰类public ConcreteDecoratorA(Component component) {super(component);}@Overridepublic void operation() {super.operation();addState();}public void addState(){System.out.println("添加机器状态");}
}
public class ConcreteDecoratorB extends Decorator {//具体装饰类public ConcreteDecoratorB(Component component) {super(component);}@Overridepublic void operation() {super.operation();addMoney();}public void addMoney(){System.out.println("加钱,买更多机器投入操作");}
}
public class Main {//main方法public static void main(String[] args) {Component component=new ConcreteComponent();System.out.println("装饰器A-----------");Decorator decorator=new ConcreteDecoratorA(component);decorator.operation();System.out.println("装饰器B---------------");decorator=new ConcreteDecoratorB(component);decorator.operation();}
}

(4)总结

优点:

  • 装饰器比继承更加灵活,不会导致类个数急剧增加;
  • 可以动态的扩展一个对象功能,通过配置类可以在运行时选择不同的配置类,从而实现不同行为;
  • 可以对一个对象装饰多次,采用不同1装饰类可以组装出多个不同的行为;
  • 具体的组件类和装饰类可以独立添加,可以根据需要添加新的构建类和组件类,符合开闭原则;

缺点:

  • 会产生大量的小对象,这些小对象随着不断累积,会消耗大量内存;
  • 对于排错,需要多级查找;

使用场景:

  • 在不影响其他对象的情况下,动态,透明的给一个对象添加职责;
  • 系统中存在大量独立的类,不可以使用装饰器模式,否则会产生大量的子类;

5、建造者模式

(1)概述

  • 将一个复杂对象的构建与他的表示分离,使得同样构建过程可以创建不同的表示;
  • 不同的具体建造者定义不同的创建过程,且具体的建造者相互独立,增加新的建造者非常方便;

(2)角色

  • Builder(抽象建造者):他为建造复杂对象的各个部件定义接口,在接口中声明方法中,一类是buildProductX方法,用于构建各个组件,另外一类为getProduct()方法,用于获取构建后的对象;既可以是接口,也可以是抽象类;
  • Concretebuilder(具体建造者):实现Builder接口,实现各个构造组件的方法,并实现返回一个对象的方法;
  • Product(产品):具体的构建对象,包含多个组件,由ConcreteBuilder装配;
  • Director(指挥者):定义一个construct()方法,复杂组件装配的顺序,返回构造好的对象,一般该类与客户端进行交互;内部维护一个Builder类;
  • 复杂对象:包含多个属性的对象;

(3)实现

@Data
public class Product {//产品类private String A;private String B;
}
public abstract class Builder {//建造者抽象类protected Product product=new Product();public abstract void buildPathA(String value);public abstract void buildPathB(String value);public Product getProduct(){return this.product;}
}
public class ConcreteBuilder extends Builder{//具体建造类@Overridepublic void buildPathA(String value) {product.setA(value);}@Overridepublic void buildPathB(String value) {product.setB(value);}
}
public class Director {//指挥者类private Builder builder;public Director(Builder builder){this.builder=builder;}public Product construct(String A,String B){builder.buildPathA(A);builder.buildPathB(B);return builder.getProduct();}
}
public class Main {public static void main(String[] args) {Builder builder=new ConcreteBuilder();Product product=new Director(builder).construct("属性A","属性B");System.out.println(product.getA());System.out.println(product.getB());}
}

(4)总结

优点:

  • 在建造者模式中,客户端不必直到内部如何构建,将产品本身与产品构建之间解耦,使得相同的构建过程可以构建不同的产品;
  • 每一个构建者相对独立,客户端可以很方便的添加新的构造者,同时增加新的构造者,不用修改原有的代码符合开闭原则;

缺点:

  • 产品之间相差过大,各个组成部分由较大差异,不适合使用该模式;
  • 产品的组件变化复杂,需要定义过多的构造类来实现这种变化,导致系统过于庞大;

使用场景:

  • 需要生成复杂对象,这些对象通常包含多个属性;
  • 对象之间的属性相互依赖,且由一定的顺序性;
  • 隔离复杂对象的创建和使用,使得相同的创建过程可以构建出不同的对象;

6、组合模式

(1)概述

  • 组合多个对象成为树形结构,对于叶子对象和容器对象的操作都具有一致性;
  • 当调用容器对象的某一个方法时,将会遍历整个树,寻找包含这个方法的成员变量,使用递归对整个树结构进行调用;
  • 叶子对象:没有字节点;
  • 容器对象:包含多个叶子对象和多个容器对象;

(2)角色

  • Component(抽象构件):为叶子构件和容器构件声明了接口,定义了其子类共有的行为方法;
  • Leaf(叶子构件):实现了Component接口中的行为方法,没有子节点;
  • Composite(容器构件):该节点有子节点,子节点可以是容器节点,也可以是叶子节点。有一个列表属性,用于存储子节点,实现了Component接口定义的行为方法,该方法可以递归调用子节点的业务方法;同时包含管理子构建的方法;

(3)实现

public abstract class Component {//抽象组件public abstract void add(Component component);//添加构建public abstract void remove(Component component);//删除构建public abstract List<Component> getChild();//获取子类public abstract void print();//输出文件
}
public class OssLeaf extends Component{//叶子组件private String name;public OssLeaf(String name){this.name=name;}@Overridepublic void add(Component component) {System.out.println("异常处理");}@Overridepublic void remove(Component component) {System.out.println("异常处理");}@Overridepublic List<Component> getChild() {return null;}@Overridepublic void print() {System.out.println("输出"+name+"文件");}
}
public class TxtLeaf extends Component{//叶子组件private String name;public TxtLeaf(String name){this.name=name;}@Overridepublic void add(Component component) {System.out.println("异常处理");}@Overridepublic void remove(Component component) {System.out.println("异常处理");}@Overridepublic List<Component> getChild() {return null;}@Overridepublic void print() {System.out.println("输出"+name+"文件类型");}
}
public class Composite extends Component{//容器组件//记录该组件的子组件(叶子组件、容器组件)private List<Component> componentList=new ArrayList<>();private String name;public Composite(String name){this.name=name;}@Overridepublic void add(Component component) {componentList.add(component);}@Overridepublic void remove(Component component) {componentList.remove(component);}@Overridepublic List<Component> getChild() {return componentList;}@Overridepublic void print() {System.out.println("输出"+name+"类型的文件,输出如下:");//调用子类的方法for (Component component : componentList) {component.print();}}
}
public class Main {//测试方法public static void main(String[] args) {OssLeaf ossLeaf1=new OssLeaf("图片");OssLeaf ossLeaf2=new OssLeaf("视频");TxtLeaf txtLeaf=new TxtLeaf("txt");TxtLeaf txtLeaf1=new TxtLeaf("docx");TxtLeaf txtLeaf2=new TxtLeaf("pptx");Composite composite1=new Composite("oss类型文件");composite1.add(ossLeaf1);composite1.add(ossLeaf2);composite1.print();Composite composite2=new Composite("文本类型文件");composite2.add(txtLeaf);composite2.add(txtLeaf1);composite2.add(txtLeaf2);composite2.print();}
}

(4)总结

优点:

  • 在新增新的叶子组件或容器组件时,无需修改原有代码,符合开闭原则;
  • 忽略客户端层次差异,方便对整个层次进行控制;

缺点:新增新的组件时,难以对组件的类型进行控制;

使用场景:

  • 需要处理一个树型结构;
  • 系统中可以分离出叶子组件和容器组件,类型不固定,需要增加一些新的类型;
  • 整体和部分具有层次结构,需要处理忽略他们的层次差,使用客户端一致调用这些业务方法;

7、观察者模式

(1)概述

  • 定义一种一堆多的关系,使得每当一个对象发生改变时,会通知其关联对象并自动更新;
  • 发生改变的对象为观察目标,而被通知的对象为观察者,这些观察者之间没有任何联系;

(2)角色

  • Subject(目标):被观察的对象,在目标中定义了一个观察者对象集合,提供删除,添加观察者的方法,同时定义了通知方法notify,可以是接口,抽象类或具体类;
  • ConcreteSubject(具体目标):Subject的子类,他包含发生改变的数据,当该数据发生改变时,会通知集合中的观察者,同时还实现目标类中的抽象业务方法;(无需扩展目标类,该类可以省略)
  • Observer(抽象观察者):观察者对改变做出响应,一般为接口,声明update方法;
  • ConcreteObserver(具体观察者):实现抽象观察者中的update方法,同时维护一个ConcreteSubject对象的应用,存储具体观察者有关状态,该状态需要与目标对象状态一致;

(3)实现

public abstract class Subject {//抽象目标public List<Observer> observerList=new ArrayList<>();//观察者集合public void add(Observer observer){//添加观察者observerList.add(observer);}public void delete(Observer observer){//删除观察者observerList.remove(observer);}public abstract void notifyObserver(String name);}
public class ConcreteSubject extends Subject{//具体目标类@Overridepublic void notifyObserver(String name) {//通知每一个观察者处理errorfor (Observer observer : observerList) {if (!((ConcreteObserver) observer).getName().equals(name)){observer.dealError();}}}
}
public interface Observer {//抽象观察者public void dealError();//在发生error时触发public void error(Subject subject);
}
public class ConcreteObserver implements Observer{//具体观察者private String name;public ConcreteObserver(String name){this.name=name;}public String getName(){return this.name;}//处理错误@Overridepublic void dealError() {System.out.println(name+"来处理error了");}//发生错误@Overridepublic void error(Subject subject) {System.out.println(name+"发生error,都来处理error");subject.notifyObserver(name);}
}
public class Main {public static void main(String[] args) {Subject subject=new ConcreteSubject();Observer observer1=new ConcreteObserver("A");Observer observer2=new ConcreteObserver("B");Observer observer3=new ConcreteObserver("C");subject.add(observer1);subject.add(observer2);subject.add(observer3);observer1.error(subject);}
}

(4)总结

优点:

  • 观察者适合广播通信,目标对象发生改变时,会通知所有订阅目标的观察者;
  • 添加具体观察者,无需修改原有代码,每一个观察者之间无任何联系,符合开闭原则;

缺点:

  • 目标类如果有过多的观察者,通知时会耗费大量时间;
  • 观察者和目标之间存在循环依赖,通知时,会导致死循环;
  • 观察者无法直到观察对象是如何变化的,只能直到该对象发生了变化;

使用场景:

  • 一个对象发生改变会影响多个对象,而这些对象之间相互无任何联系;
  • 链式触发,如A影响B,B影响C,。。。;

8、责任链模式

(1)概述

避免请求发送者和接收者耦合在一起,让多个对象都可以接收请求,将这些对象合成一条链,并且沿着这条链传递请求,直到有对象处理该请求为止;

(2)角色

  • Handler(抽象处理者):定义了一个处理请求的接口,不同的处理者对每一个请求的处理方式不同,因此定义抽象处理者。每一个处理者的下一个还是处理者,在抽象类中定义一个处理者对象,用于对下一个处理者的调用;
  • ConcreteHandler(具体处理者):抽象处理者的实现类,实现具体的请求处理方法,处理请求之前需要先判断是否有权限处理,有则处理,否则将请求转发给下一个处理者;

(3)实现

@Data
public abstract class Handler {protected Handler handler;//下一个处理者protected String name;//姓名public Handler(String name){this.name=name;}//处理请求逻辑方法public abstract void processorHandler(int money);
}
public class ConcreteHandlerA extends Handler{public ConcreteHandlerA(String name){super(name);}@Override//可以审批5000元以下public void processorHandler(int money) {if (money<=5000){System.out.println(name+"进行审批,审批通过");}else {System.out.println(name+"无法审批金额,流转下一个审批者");handler.processorHandler(money);}}
}
public class ConcreteHandlerB extends Handler{public ConcreteHandlerB(String name){super(name);}@Override//可以审批5000-20000public void processorHandler(int money) {if (money>5000&&money<=20000){System.out.println(name+"进行审批,审批通过");}else {System.out.println(name+"无法审批金额,流转下一个审批者");handler.processorHandler(money);}}
}
public class ConcreteHandlerC extends Handler{public ConcreteHandlerC(String name){super(name);}@Override//可以审批20000以上public void processorHandler(int money) {if (money>20000){System.out.println(name+"进行审批,审批通过");}else {System.out.println(name+"无法审批金额,流转下一个审批者");handler.processorHandler(money);}}
}
public class Main {public static void main(String[] args) {Handler handlerA=new ConcreteHandlerA("主管");Handler handlerB=new ConcreteHandlerB("经理");Handler handlerC=new ConcreteHandlerC("董事长");//设置下一个处理者handlerA.setHandler(handlerB);handlerB.setHandler(handlerC);handlerA.processorHandler(30000);}
}

(4)总结

优点:

  • 发送者和接收者都没有对方的信息,只知道请求会被处理,降低系统耦合度;
  • 职责链的处理更加灵活,可以动态增加和删除处理者,来改变处理一个请求的职责;
  • 增加一个新的请求者无需修改原有代码,只需添加新连接即可,符合开闭原则;

缺点:

  • 请求没有明确接收者,可能导致请求走完职责链也并未被处理;
  • 请求处理需要多个对象进行处理,系统性能将受一定的影响;
  • 创建的连接不当,可能会造成系统死循环;

使用场景:

  • 多个对象处理一个请求,请求需要等到运行时才能确定哪一个处理者处理;
  • 不明确处理者对象,向多个对象提交一个请求;
  • 指定一组对象进行处理,客户端可以动态添加处理对象,并且可以改变顺序;

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/110128.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

加密的PDF文件,如何解密?

PDF文件带有打开密码、限制编辑&#xff0c;这两种密码设置了之后如何解密&#xff1f; 不管是打开密码或者是限制编辑&#xff0c;在知道密码的情况下&#xff0c;解密PDF密码&#xff0c;我们只需要在PDF编辑器中打开文件 – 属性 – 安全&#xff0c;将权限状态修改为无保护…

React常见面试题

文章目录 1.1、React生命周期1.2、JSX1.3、类组件和函数组件1.4、react组件设计模式1.5、高阶组件1.6、setState的同步异步1.7、调用setState后会发生什么1.8、组件通信1.9、虚拟DOM、diff算法、key的作用1.10、什么是 React1.11、react渲染流程1.12、React Router常用API1.12、…

2023年7月京东护发市场数据分析(京东数据产品)

如今&#xff0c;与面部护肤相比&#xff0c;多数消费者认为头皮也需要认真对待&#xff0c;这在年轻消费群体中体现的较为明显。 随着消费者对护发理念的认同感不断加深&#xff0c;人们日常居家洗护的步骤也更加精细、使用产品品类也愈加多样化。除传统的护发素、发膜等护发…

TinyVue - 华为云 OpenTiny 出品的企业级前端 UI 组件库,免费开源,同时支持 Vue2 / Vue3,自带 TinyPro 中后台管理系统

华为最新发布的前端 UI 组件库&#xff0c;支持 PC 和移动端&#xff0c;自带了 admin 后台系统&#xff0c;完成度很高&#xff0c;web 项目开发又多一个选择。 关于 OpenTiny 和 TinyVue 在上个月结束的华为开发者大会2023上&#xff0c;官方正式进行发布了 OpenTiny&#…

大数据Flink(六十九):SQL 数据类型

文章目录 SQL 数据类型 一、原子数据类型 二、​​​​​​复合数据类型 SQL 数据类型 在介绍完一些基本概念之后,我们来认识一下

Flutter可执行屏幕动画的AnimateView

1.让动画使用起来就像使用widget。 2.可自定义动画。 3.内置平移动画。 演示&#xff1a; 代码: import dart:math; import package:flutter/cupertino.dart;class AnimateView extends StatefulWidget {///子Widgetfinal Widget child;///动画自定义final IAnimate? anim…

自实现getprocaddress(名称查找或者序号查找)

通过名称去找 // MyGETPRCOADDRESS.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 //#include <iostream> #include<Windows.h>/*WINBASEAPI //导出不需要使用&#xff0c;那么我们注释掉*/ FARPROC WINAPI MyGetProcAddress(_In_ HMO…

AIGC - 生成模型

AIGC - 生成模型 0. 前言1. 生成模型2. 生成模型与判别模型的区别2.1 模型对比2.2 条件生成模型2.3 生成模型的发展2.4 生成模型与人工智能 3. 生成模型示例3.1 简单示例3.2 生成模型框架 4. 表示学习5. 生成模型与概率论6. 生成模型分类小结 0. 前言 生成式人工智能 (Generat…

面试中的代码写作:如何撰写清晰、高效的示例代码

&#x1f337;&#x1f341; 博主猫头虎 带您 Go to New World.✨&#x1f341; &#x1f984; 博客首页——猫头虎的博客&#x1f390; &#x1f433;《面试题大全专栏》 文章图文并茂&#x1f995;生动形象&#x1f996;简单易学&#xff01;欢迎大家来踩踩~&#x1f33a; &a…

软考A计划-网络工程师-常用计算公式汇总

点击跳转专栏>Unity3D特效百例点击跳转专栏>案例项目实战源码点击跳转专栏>游戏脚本-辅助自动化点击跳转专栏>Android控件全解手册点击跳转专栏>Scratch编程案例点击跳转>软考全系列点击跳转>蓝桥系列 &#x1f449;关于作者 专注于Android/Unity和各种游…

Zabbix 5.0 媒体介质 邮箱配置例子

QQ企业邮箱 参考&#xff1a;zabbix 腾讯企业邮箱配置图_harveymomo的博客-CSDN博客

分布式计算框架:Spark、Dask、Ray

目录 什么是分布式计算 分布式计算哪家强&#xff1a;Spark、Dask、Ray 2 选择正确的框架 2.1 Spark 2.2 Dask 2.3 Ray 什么是分布式计算 分布式计算是一种计算方法&#xff0c;和集中式计算是相对的。 随着计算技术的发展&#xff0c;有些应用需要非常巨大的计算能力才…

python web GUI框架-NiceGUI 教程(二)

python web GUI框架-NiceGUI 教程&#xff08;二&#xff09; streamlit可以在一些简单的场景下仍然推荐使用&#xff0c;但是streamlit实在不灵活&#xff0c;受限于它的核心机制&#xff0c;NiceGUI是一个灵活的web框架&#xff0c;可以做web网站也可以打包成独立的exe。 基…

几个nlp的小任务(机器翻译)

几个nlp的小任务(机器翻译) 安装依赖库数据集介绍与模型介绍加载数据集看一看数据集的样子评测测试数据预处理测试tokenizer处理目标特殊的token预处理函数对数据集的所有数据进行预处理微调预训练模型设置训练参数需要一个数据收集器,把处理好数据喂给模型设置评估方法参数…

python爬虫12:实战4

python爬虫12&#xff1a;实战4 前言 ​ python实现网络爬虫非常简单&#xff0c;只需要掌握一定的基础知识和一定的库使用技巧即可。本系列目标旨在梳理相关知识点&#xff0c;方便以后复习。 申明 ​ 本系列所涉及的代码仅用于个人研究与讨论&#xff0c;并不会对网站产生不好…

yo!这里是Linux基础开发工具介绍

目录 前言 基础开发工具 yum vim 1.基本介绍 2.基本操作 3.正常模式常用命令 4.底行模式常用命令 gcc/g gdb 1.基本介绍 2.常用操作 make/Makefile 1.背景 2.介绍 3.使用 git 1.介绍 2.操作 进度条程序简单实现 后记 前言 在学完初步的基础指令及权限控…

JVM虚拟机:定位对象的两种方式

定位对象的方式 1、句柄池 2、直接指针 ‘句柄池 直接指针 在Java中&#xff0c;可以使用两种方式来定位对象&#xff1a;句柄池和直接指针。 1. 句柄池&#xff1a;在Java的句柄池模型中&#xff0c;Java虚拟机&#xff08;JVM&#xff09;会为每个对象创建一个句柄&#xff…

关于 MySQL、PostgresSQL、Mariadb 数据库2038千年虫问题

MySQL 测试时间&#xff1a;2023-8 启动MySQL服务后&#xff0c;将系统时间调制2038年01月19日03时14分07秒之后的日期&#xff0c;发现MySQL服务自动停止。 根据最新的MySQL源码&#xff08;mysql-8.1.0&#xff09;分析&#xff0c;sql/sql_parse.cc中依然存在2038年千年虫…

【UE5】用法简介-使用MAWI高精度树林资产的地形材质与添加风雪效果

首先我们新建一个basic工程 然后点击floor按del键&#xff0c;把floor给删除。 只留下空白场景 点击“地形” 在这个范例里&#xff0c;我只创建一个500X500大小的地形&#xff0c;只为了告诉大家用法&#xff0c;点击创建 创建好之后有一大片空白的地形出现 让我们点左上角…

以udp协议创建通信服务器

概念图 创建服务器让A,B主机完成通信。 认识接口 socket 返回值&#xff1a;套接字&#xff0c;你可以认为类似fd 参数&#xff1a; domain->:哪种套接字&#xff0c;常用AF_INET(网络套接字)、AF_LOCAL(本地套接字)type->&#xff1a;发送数据类型&#xff0c;常用 …