设计模式_策略模式_Strategy

案例引入

  • 有各种鸭子，比如野鸭、北京鸭、水鸭等。 鸭子有各种行为，比如走路、叫、飞行等。不同鸭子的行为可能略有不同。要求显示鸭子的信息

传统方案实现

不同的鸭子继承一个父类Duck，如果是相同的行为就继承，不同行为就重写方法

实现

【鸭子抽象类】

package com.test.strategy;

public abstract class Duck {

public Duck() {

}

/**
* 显示鸭子信息
*/
public abstract void display();

/**
* 叫法
*/
public void quack() {
System.out.println("鸭子嘎嘎叫~~");
}

/**
* 游泳方法
*/
public void swim() {
System.out.println("鸭子会游泳~~");
}

/**
* 飞翔方法
*/
public void fly() {
System.out.println("鸭子会飞翔~~~");
}

}

【野鸭】

package com.test.strategy;

public class WildDuck extends Duck {

@Override
public void display() {
System.out.println(" 这是野鸭 ");
}

}

【北京鸭】

package com.test.strategy;

public class PekingDuck extends Duck {

@Override
public void display() {
System.out.println("~~北京鸭~~~");
}

/**
* 因为北京鸭不能飞翔，因此需要重写fly
*/
@Override
public void fly() {
System.out.println("北京鸭不能飞翔");
}

}

【玩具鸭】

package com.test.strategy;

public class ToyDuck extends Duck {
@Override
public void display() {
System.out.println("玩具鸭");
}

//-------需要重写父类的所有方法---------

public void quack() {
System.out.println("玩具鸭不能叫~~");
}

public void swim() {
System.out.println("玩具鸭不会游泳~~");
}

public void fly() {
System.out.println("玩具鸭不会飞翔~~~");
}
}
分析
  • 缺点：因为继承了Duck，所有鸭子都有了会飞的方法，虽然可以通过覆盖fly方法来解决，但是，如果子类很多方法都不需要呢，如果每个都要去覆盖一下就很麻烦了
  • 改进：使用策略模式

介绍

基本介绍

  • 策略模式中，定义算法族，分别封装到不同的类中，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。使用策略模式可以整体地替换算法的实现部分，让我们可以轻松地以不同的算法去解决同一个问题
  • 该模式体现了几个设计原则：把变化的代码从不变的代码中分离出来；针对接口编程而不是具体类(定义了策略接口)；多用组合/聚合，少用继承(客户通过组合方式使用策略)

登场角色

在这里插入图片描述

在这里插入图片描述

Context聚合了策略接口，后面需要使用到哪个具体策略的方法，就传入该具体策略的实例作为参数即可

  • Strategy(策略)：Strategy角色负责定义实现策略所必需的接口(API)
  • ConcreteStrategy(具体的策略)：ConcreteStrategy角色负责实现Strategy角色的接口(API)，即负责实现具体的策略(战略、方向、方法和算法)
  • Context(上下文)：负责使用Strategy角色。Context角色保存了ConcreteStrategy角色的实例，并使用ConcreteStrategy角色（即调用Strategy角色的接口）去实现需求

案例实现

案例一

类图

在这里插入图片描述

实现

【飞翔策略 FlyBehavior】

package com.test.strategy.improve;

public interface FlyBehavior {

/**
* 让子类具体实现
*/
void fly();
}

【叫策略 QuackBehavior】

package com.test.strategy.improve;

public interface QuackBehavior {
void quack();
}

【飞翔技术高超：GoodFlyBehavior】

package com.test.strategy.improve;

public class GoodFlyBehavior implements FlyBehavior {

@Override
public void fly() {
System.out.println(" 飞翔技术高超 ~~~");
}

}

【飞翔技术一般：BadFlyBehavior 】

package com.test.strategy.improve;

public class BadFlyBehavior implements FlyBehavior {

@Override
public void fly() {
System.out.println(" 飞翔技术一般 ");
}

}

【不会飞翔】

package com.test.strategy.improve;

public class NoFlyBehavior implements FlyBehavior{

@Override
public void fly() {
System.out.println(" 不会飞翔  ");
}

}

【鸭子抽象类】

package com.test.strategy.improve;

public abstract class Duck {

/**
* 策略接口 飞翔
*/
FlyBehavior flyBehavior;
/**
* 策略接口 叫
*/
QuackBehavior quackBehavior;

public Duck() {

}

/**
* 显示鸭子信息
*/
public abstract void display();

public void quack() {
System.out.println("鸭子嘎嘎叫~~");
}

public void swim() {
System.out.println("鸭子会游泳~~");
}

public void fly() {
//改进
if(flyBehavior != null) {
flyBehavior.fly();
}
}

public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}


public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}



}

【野鸭】

package com.test.strategy.improve;

public class WildDuck extends Duck {

/**
* 构造器，传入FlyBehavor 的对象
*/
public  WildDuck() {
// 野鸭飞翔技术较强
flyBehavior = new GoodFlyBehavior();
}


@Override
public void display() {
System.out.println(" 这是野鸭 ");
}

}

【北京鸭】

package com.test.strategy.improve;

public class PekingDuck extends Duck {

/**
* 假如北京鸭可以飞翔，但是飞翔技术一般
*/
public PekingDuck() {
flyBehavior = new BadFlyBehavior();

}

@Override
public void display() {
System.out.println("~~北京鸭~~~");
}

}

【玩具鸭】

package com.test.strategy.improve;

public class ToyDuck extends Duck {
public ToyDuck() {
// 玩具鸭不会飞翔
flyBehavior = new NoFlyBehavior();
}

@Override
public void display() {
System.out.println("玩具鸭");
}

/**
* 需要重写父类的所有方法
*/
public void quack() {
System.out.println("玩具鸭不能叫~~");
}

public void swim() {
System.out.println("玩具鸭不会游泳~~");
}

}

【主类】

package com.test.strategy.improve;

public class Client {

public static void main(String[] args) {
WildDuck wildDuck = new WildDuck();
wildDuck.fly();

ToyDuck toyDuck = new ToyDuck();
toyDuck.fly();

PekingDuck pekingDuck = new PekingDuck();
pekingDuck.fly();

//可以动态改变某个对象的行为, 将北京鸭改成不能飞
pekingDuck.setFlyBehavior(new NoFlyBehavior());
System.out.println("北京鸭的实际飞翔能力");
pekingDuck.fly();
}

}

【输出】

飞翔技术高超 ~~~
不会飞翔  
飞翔技术一般 
北京鸭的实际飞翔能力
不会飞翔  

Process finished with exit code 0

尖叫策略和飞翔策略的实现方式一样，这里就不再实现了

案例二

类图

在这里插入图片描述

实现

【手势类：并不是策略模式的角色】

package com.test.strategy.Sample;

/**
* 手势
*/
public class Hand {
/**
* 表示石头的值
*/
public static final int HANDVALUE_GUU = 0;
/**
* 表示剪刀的值
*/
public static final int HANDVALUE_CHO = 1;
/**
* 表示布的值
*/
public static final int HANDVALUE_PAA = 2;
/**
* 表示猜拳中3种手势的实例
*/
public static final Hand[] hand = {
new Hand(HANDVALUE_GUU),
new Hand(HANDVALUE_CHO),
new Hand(HANDVALUE_PAA),
};
/**
* 表示猜拳中手势所对应的字符串
*/
private static final String[] name = {
"石头", "剪刀", "布",
};
/**
* 表示猜拳中出的手势的值
*/
private int handvalue;

private Hand(int handvalue) {
this.handvalue = handvalue;
}

/**
* 根据手势的值获取其对应的实例，这是一种单例模式，每种手势只有一个实例
*
* @param handvalue
* @return
*/
public static Hand getHand(int handvalue) {
return hand[handvalue];
}

/**
* 如果this胜了h则返回true
*
* @param h
* @return
*/
public boolean isStrongerThan(Hand h) {
return fight(h) == 1;
}

/**
* 如果this输给了h则返回true
*
* @param h
* @return
*/
public boolean isWeakerThan(Hand h) {
return fight(h) == -1;
}

/**
* 计分：平0, 胜1, 负-1
*
* @param h
* @return
*/
private int fight(Hand h) {
if (this == h) {
return 0;
} else if ((this.handvalue + 1) % 3 == h.handvalue) {
// 当(this.handvalue + 1) % 3 == h.handvalue时，可能得手势组合如下
// this是石头，h是剪刀
// this是剪刀，h是布
// this是布，h是石头
return 1;
} else {
return -1;
}
}

/**
* 转换为手势值所对应的字符串
*
* @return
*/
public String toString() {
return name[handvalue];
}
}

【策略接口】

package com.test.strategy.Sample;

public interface Strategy {
/**
* 获取下一局要出的手势
* @return
*/
public abstract Hand nextHand();

/**
* 学习上一局的手势是否获胜了，获胜就传进来true，否则返回false
* @param win
*/
public abstract void study(boolean win);
}

【具体策略一】

package com.test.strategy.Sample;

import java.util.Random;

/**
* 该策略是：如果上一局赢了，这局的手势就和上一局的相同；如果上一局输了，就随机出
*/
public class WinningStrategy implements Strategy {
private Random random;
/**
* 保存上一局是赢还是输了
*/
private boolean won = false;
/**
* 保存上一局出的手势
*/
private Hand prevHand;

public WinningStrategy(int seed) {
random = new Random(seed);
}
public Hand nextHand() {
if (!won) {
prevHand = Hand.getHand(random.nextInt(3));
}
return prevHand;
}
public void study(boolean win) {
won = win;
}
}

【具体策略二】

package com.test.strategy.Sample;

import java.util.Random;

public class ProbStrategy implements Strategy {
private Random random;
private int prevHandValue = 0;
private int currentHandValue = 0;
/**
* 过去的胜率：history[上一局出的手势][这一局所出的手势]
* 假设上一局出的手势是石头：
* history[0][0]：两局分别出了石头、石头的获胜次数
* history[0][1]：两局分别出了石头、剪刀的获胜次数
* history[0][2]：两局分别出了石头、布的获胜次数
* 若history[0][0]=3；history[0][1]=5；history[0][2]=7
* 下一把出什么？使用轮盘赌的方式，出石头的概率是3/15；出剪刀的概率是5/15；出布的概率是7/15
*/
private int[][] history = {
{ 1, 1, 1, },
{ 1, 1, 1, },
{ 1, 1, 1, },
};
public ProbStrategy(int seed) {
random = new Random(seed);
}

/**
* 学习历史胜率，根据轮盘赌的方式来出下一个手势
* @return
*/
public Hand nextHand() {
int bet = random.nextInt(getSum(currentHandValue));
int handvalue = 0;
if (bet < history[currentHandValue][0]) {
handvalue = 0;
} else if (bet < history[currentHandValue][0] + history[currentHandValue][1]) {
handvalue = 1;
} else {
handvalue = 2;
}
prevHandValue = currentHandValue;
currentHandValue = handvalue;
return Hand.getHand(handvalue);
}

/**
* 获取第一把出hv，第二把出1、2、3的总次数
* @param hv
* @return
*/
private int getSum(int hv) {
int sum = 0;
for (int i = 0; i < 3; i++) {
sum += history[hv][i];
}
return sum;
}

/**
* 学习经验，更新 history 表格
* @param win
*/
public void study(boolean win) {

if (win) {
history[prevHandValue][currentHandValue]++;
} else {
history[prevHandValue][(currentHandValue + 1) % 3]++;
history[prevHandValue][(currentHandValue + 2) % 3]++;
}
}
}

【游戏选手类】

package com.test.strategy.Sample;

/**
* 玩猜拳游戏的选手类
*/
public class Player {
private String name;
/**
* 记录选手要选用的策略
*/
private Strategy strategy;

/**
* 赢的局数
*/
private int wincount;
/**
* 输的局数
*/
private int losecount;
/**
* 总局数
*/
private int gamecount;

/**
* 传入选手的姓名和策略
*
* @param name
* @param strategy
*/
public Player(String name, Strategy strategy) {
this.name = name;
this.strategy = strategy;
}

/**
* 策略决定下一局要出的手势
*
* @return
*/
public Hand nextHand() {
return strategy.nextHand();
}

/**
* 猜拳胜利
*/
public void win() {                 
strategy.study(true);
wincount++;
gamecount++;
}

/**
* 猜拳失败
*/
public void lose() {                
strategy.study(false);
losecount++;
gamecount++;
}

/**
* 猜拳平局
*/
public void even() {                
gamecount++;
}

public String toString() {
return "[" + name + ":" + gamecount + " games, " + wincount + " win, " + losecount + " lose" + "]";
}
}

【主类】

package com.test.strategy.Sample;

public class Main {
public static void main(String[] args) {
// 让选手分别使用两种策略来比试
Player player1 = new Player("Taro", new WinningStrategy(314));
Player player2 = new Player("Hana", new ProbStrategy(12));
for (int i = 0; i < 10000; i++) {
Hand nextHand1 = player1.nextHand();
Hand nextHand2 = player2.nextHand();
if (nextHand1.isStrongerThan(nextHand2)) {
//                System.out.println("Winner:" + player1);
player1.win();
player2.lose();
} else if (nextHand2.isStrongerThan(nextHand1)) {
//                System.out.println("Winner:" + player2);
player1.lose();
player2.win();
} else {
//                System.out.println("Even...");
player1.even();
player2.even();
}
}
System.out.println("Total result:");
System.out.println(player1.toString());
System.out.println(player2.toString());
}
}

【运行】

Total result:
[Taro:10000 games, 3107 win, 3617 lose]
[Hana:10000 games, 3617 win, 3107 lose]

Process finished with exit code 0
问答

如果需要增加一个随机出手势的策略，需要怎么实现

答：在nextHand方法中使用随机数即可，因为全部都是随机的，不需要学习之前的经验，因此study方法可以是空方法

在示例程序中，Hand类的fight方法负责判断平局。在进行判断时，它使用的表达式不是this.handValue == h.value，而是this==h，请问为什么可以这样写?

答：因为使用了单例模式，只有三个手势实例，如果两个手势的handValue相同，说明两个实例就是同一个实例

编写Winningstrategy类时，won 字段的定义不是private boolean won = false; 而是写成了如下这样private boolean won;虽然写法不同，但是两者的运行结果一样，为什么？

答：因为全局变量如果没有被赋值就会被自动初始化：boolean类型默认是false；数值类型默认是0；引用类型默认是null。注意，局部变量不会被自动初始化

策略模式在JDK源码中的使用

简单来说，就是在排序的时候，可以指定不同的排序策略

package com.atguigu.jdk;

import java.util.Arrays;
import java.util.Comparator;


public class Strategy {

public static void main(String[] args) {
// TODO Auto-generated method stub
//数组
Integer[] data = {9, 1, 2, 8, 4, 3};
// 实现降序排序，返回-1放左边，1放右边，0保持不变

// 说明
// 1. 实现了 Comparator 接口（策略接口） , 匿名类对象：new Comparator<Integer>(){..}
// 2. 对象 new Comparator<Integer>(){..} 就是实现了 策略接口 的对象
// 3. public int compare(Integer o1, Integer o2){} 指定具体的处理策略
Comparator<Integer> comparator = new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
if (o1 > o2) {
    return -1;
} else {
    return 1;
}
}
};

// sort源码说明 传入数字和一个排序策略
/*
* public static <T> void sort(T[] a, Comparator<? super T> c) {
if (c == null) {
  sort(a); //默认方法
} else {
  if (LegacyMergeSort.userRequested)
      legacyMergeSort(a, c); //使用策略对象c
  else
     // 使用策略对象c
      TimSort.sort(a, 0, a.length, c, null, 0, 0);
}
}
*/
// 方式1
Arrays.sort(data, comparator);
// 降序排序
System.out.println(Arrays.toString(data));

//方式2- 同时lambda 表达式实现 策略模式
Integer[] data2 = {19, 11, 12, 18, 14, 13};

// 换一个排序策略
Arrays.sort(data2, (var1, var2) -> {
if (var1.compareTo(var2) > 0) {
return -1;
} else {
return 1;
}
});

System.out.println("data2=" + Arrays.toString(data2));

}

}

总结

【说明】

  • 策略模式的关键是分析项目中变化部分与不变部分

【优点】

  • 策略模式的核心思想是：多用组合/聚合，少用继承；用行为类来组合，而不是行为的继承
  • 体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略 (或者行为)即可，避免了使用多重判断语句 (if…else if…else)
  • 提供了可以替换继承关系的办法: 策略模式将算法封装在独立的Strategy类中使得你可以独立于其他Context改变它，使它易于切换、易于理解、易于扩展
  • 程序运行过程中也可以切换策略：如果使用Strategy模式，在程序运行中也可以切换ConcreteStrategy角色。如在内存较少的环境使用一种算法，内存较多的环境使用另外一种算法

【缺点】

  • 每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大

【问答】

为什么需要特意编写Strategy角色

答：当我们想要通过改善算法来提高算法的处理速度时，如果使用了Strategy模式，就不必修改Strategy角色的接口(API)了，仅仅修改ConcreteStrategy角色即可。而且，使用委托这种弱关联关系可以很方便地整体替换算法，这样也更加方便算法的比较

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Mode Management】BswM模块和其他模块的交互

【Mode Management】BswM模块和其他模块的交互

目录 1.BSWM模块和COM模块 2.BSWM模块和ComM模块 3.BSWM模块和CanSM模块 4.BSWM模块和DCM模块 4.1 DCM通过BSWM控制通信 4.2 DCM通过BSWM控制ECU复位 5.BSWM模块和自定义SWC模块 6.BSWM模块和NVM模块 6.1 BswMNvMJobModeIndication 6.2 BswMNvMRequest 6.3 小结 1.B…
阅读更多...
C++初阶 内存管理和模板

C++初阶 内存管理和模板

目录 一、new 1.1什么是new&#xff1f; 1.2为什么要有new&#xff1f; 1.3使用new 1.4 new的超级好处 二、delete 2.1什么是delete&#xff1f; 2.2为什么要有delete&#xff1f; 2.3使用delete 三、 malloc / free和new / delete的共同点和区别 四、浅谈模板 4.1什…
阅读更多...
可解释性AI(XAI)：构建透明和值得信赖的决策过程

可解释性AI(XAI)：构建透明和值得信赖的决策过程

可解释性AI&#xff08;XAI&#xff09;旨在提高人工智能系统的透明度和可理解性&#xff0c;使人们更好地理解AI的决策过程和原理。随着AI技术的广泛应用&#xff0c;XAI成为了一个备受关注的重要领域。它不仅有助于建立人们对AI的信任&#xff0c;还可以帮助解决AI伦理和偏见…
阅读更多...
系统添加多版本支持

系统添加多版本支持

记录一下最近做的一个需求&#xff1a; 前段时间做的【监狱点名系统】改成公司打卡考勤用的系统&#xff0c;里面的"服刑人员"、"监区"、"入监/出监"……等相关配置需要做改动&#xff0c;所以考虑加一个全局的标志&#xff0c;来区分一下版本。…
阅读更多...
大数据本地环境搭建03-Spark搭建

大数据本地环境搭建03-Spark搭建

需要提前部署好 Zookeeper/Hadoop/Hive 环境 1 Local模式 1.1 上传压缩包 下载链接 链接&#xff1a;https://pan.baidu.com/s/1rLq39ddxh7np7JKiuRAhDA?pwde20h 提取码&#xff1a;e20h 将spark-3.1.2-bin-hadoop3.2.tar.gz压缩包到node1下的/export/server目录 1.2 解压压…
阅读更多...
EF Core入门例子(以SqLite为数据库)

EF Core入门例子(以SqLite为数据库)

测试环境&#xff1a; visual studio 2017 .net core 2.1 具体步骤如下&#xff1a; 1 新增名称为EFCoreDemo的.net core控制台程序&#xff0c;版本选择.net core 2.1&#xff0c;项目不能放到带中文的目录下&#xff0c;不然到后面执行Add-Migration命令时会报如下的错误…
阅读更多...
关于ZYZ旋转和XYZ旋转

关于ZYZ旋转和XYZ旋转

ZYZ旋转和XYZ旋转 概述1、XYZ旋转2、ZYZ旋转 概述 以下公式默认为右手坐标系&#xff1b;ZYZ通常可以避免死解情况&#xff0c;因此在六轴末端解算时常被用到&#xff1b;参考文章 1、XYZ旋转 XYZ旋转一般是绕固定轴旋转(外旋)&#xff0c;旋转矩阵的构成为&#xff1a;RzRy…
阅读更多...
供应链系统架构的设计与实践

供应链系统架构的设计与实践

供应链系统是现代企业管理中不可或缺的一部分&#xff0c;它涉及到从原材料采购到产品销售的整个生产流程。一个高效的供应链系统可以帮助企业实现成本控制、库存优化和客户满意度提升等目标。在本文中&#xff0c;我们将讨论供应链系统的设计与实践。 一、供应链系统设计 1.…
阅读更多...
kerberos+kafka（2.13）认证（单节点ubuntu）

kerberos+kafka（2.13）认证（单节点ubuntu）

一&#xff1a;搭建kerberos。 1. 运行安装命令 apt-get install krb5-admin-server krb5-kdc krb5-user krb5-config2. 检查服务是否启动。 systemctl status krb5-admin-server systemctl status krb5-kdcsystemctl start krb5-admin-server systemctl startkrb5-kdc3. 修…
阅读更多...
GrayLog踩坑历险记

GrayLog踩坑历险记

背景 GrayLog作为ELK的替代产品&#xff0c;是新生代的日志采集框架。在一个采集节点日志的需求中&#xff0c;因为节点很多&#xff0c;产生的日志也很多&#xff0c;因此尝试了使用GrayLog进行日志的采集。下面记录一下使用GrayLog中遇到的坑和解决方案。 一、部署与启动 …
阅读更多...
【开源】WordPress一键崩溃宕机插件（整活娱乐）

【开源】WordPress一键崩溃宕机插件（整活娱乐）

插件介绍 可一键实现Wordpress崩溃宕机的整活向插件&#xff08;请勿用于非法途径&#xff0c;仅供整活娱乐&#xff09;。鼓励关注网站性能的提升&#xff0c;以提供更好的用户体验&#xff0c;提倡为用户提供良好体验和高效速度的原则。 介绍 长期以来&#xff0c;人们都在…
阅读更多...
iOS图像处理----OpenGL ES之大长腿特效

iOS图像处理----OpenGL ES之大长腿特效

目录 一、代码部分概括 二、实现流程概括 1、第一次加载图片 ①、GLKView初始化数据 这部分内容主要是初始化顶点数组、上下文以及顶点数组缓存区&#xff0c;需要在加载图片之前做好准备​编辑 ②、加载图片 ③、绘制 2、拉伸图片 ①、滑块调整 ②、图片拉伸过程 3、…
阅读更多...
【React】react组件传参

【React】react组件传参

【React】react组件传参 一、props&#xff1a;父组件向子组件传参1、将普通的参数作为props传递2、将jsx作为props传递&#xff08;组件插槽&#xff09; 二、自定义事件&#xff1a;子父组件向父组件传参三、context进行多级组件传参四、redux全局状态管理 一、props&#xf…
阅读更多...
Redis客户端有哪些：你了解吗？

Redis客户端有哪些：你了解吗？

一、分类 Redis客户端工具是用来连接和管理redis服务器的软件&#xff0c;它们可以有不同的类型&#xff0c;如桌面客户端、web客户端和IDE插件。不同的客户端工具有各自的优缺点和特色&#xff0c;你可以根据你的需求和喜好选择合适的工具。 1、Redis 命令行工具 redis-cli官…
阅读更多...
智慧商城（continue）

智慧商城（continue）

文章目录 1.静态页面结构准备和动态渲染2.搜索 - 历史记录管理1. 写好基础静态页面,可以先往里面加一点假数据2. 上面基本的渲染直接利用history渲染就可以了3. 搜索历史基本渲染结束了,开始点击搜索添加历史4. vant内用v-model" ",可以快速拿到搜索框的值5. 往历史记…
阅读更多...
【DevOps】产品需求文档（PRD）与常见原型软件

【DevOps】产品需求文档（PRD）与常见原型软件

文章目录 1、PRD介绍1.1、概述1.2、前提条件1.3、主要目的1.4、关键内容1.5、表述方式1.6、需求评审人员1.7、一般内容结构 2、需求流程3、常见原型软件3.1、Word3.2、Axure3.2.1、详细介绍3.2.2、应用分类3.2.3、优缺点 3.3、摹客RP3.4、蓝湖3.5、GUI Design Studio 1、PRD介绍…
阅读更多...
TQ15EG开发板教程：在VIVADO2023.1 以及VITIS环境下 检测DDR4

TQ15EG开发板教程：在VIVADO2023.1 以及VITIS环境下 检测DDR4

打开VIVADO2023.1 创建一个新的工程&#xff0c;设置工程名称和地址 选择RTL工程&#xff0c;勾选不添加文件 搜索15eg&#xff0c;选择xqzu15eg-ffrb1156-2-i 完成创建工程 添加设计模块 设置模块名称 在模块中添加mpsoc器件 双击器件进行配置 若有配置文件预设可以直接导入配…
阅读更多...
分布式任务调度框架XXL-JOB详解

分布式任务调度框架XXL-JOB详解

分布式任务调度 概述 场景: 如12306网站根据不同车次设置放票时间点&#xff0c;商品成功发货后向客户发送短信提醒等任务,某财务系统需要在每天上午10天前统计前一天的账单数据 任务的调度是指系统为了完成特定业务&#xff0c;基于给定的时间点&#xff0c;时间间隔&#…
阅读更多...
C# SSH.NET 长命令及时返回

C# SSH.NET 长命令及时返回

在SSH中执行长时间的命令&#xff0c;SSH.NET及时在文本框中返回连续显示结果。 c# - Execute long time command in SSH.NET and display the results continuously in TextBox - Stack Overflow 博主管理了一个服务器集群&#xff0c;准备上自动巡检工具&#xff0c;测试在…
阅读更多...
计算机网络实验二

计算机网络实验二

目录 实验二 交换机的基本配置 1、实验目的 2、实验设备 &#xff08;1&#xff09;实验内容&#xff1a; &#xff08;2&#xff09;练习&#xff1a; 1.实验内容一&#xff1a;&#xff08;交换机的配置方式&#xff09; 2.实验内容二&#xff1a;&#xff08;交换机…
阅读更多...
最新文章

Copyright @ 2022~2023