Welcome to Hexo! This is your very first post. Check documentation for more
info. If you get any problems when using Hexo, you can find the answer
in troubleshooting or you can ask me
on GitHub.
$ hexo new "My New Post" |
More info: Writing
$ hexo server |
More info: Server
$ hexo generate |
More info: Generating
$ hexo deploy |
More info: Deployment
hexo-algoliasearch
vkkkv
Welcome to Hexo! This is your very first post. Check documentation for more
info. If you get any problems when using Hexo, you can find the answer
in troubleshooting or you can ask me
on GitHub.
$ hexo new "My New Post" |
More info: Writing
$ hexo server |
More info: Server
$ hexo generate |
More info: Generating
$ hexo deploy |
More info: Deployment
hexo-algoliasearch
vkkkv
自 2022 年 9 月搭建博客，至今 2024 年细算已有一年有余。
其间数次意欲证明己身实力，post 篇技术文章。奈何脑中文字所得尽数拾人牙慧，一无所长，以至于达不到理想中的原创文章。
我能轻松学会的知识、技术，为何别人不能学会，我能写出的博客，为何别人写不出。一念之间想法打消，怔怔空对文档，对博客的热情也淡了下来。
文章标题为 zero-blog 。因为过去的一无所获，无一可数，只好从零数起开始反省。反思我在已经得到所有想要的东西后还能想要什么，在失去得不到的东西后还能再失去什么。
心中剩下的只有对于电子设备的热情，这情绪的由来早已遗忘，还停留的是小时候摸到 psp 扳机的触感，点击键盘见到 flash 游戏的新鲜感。那时觉得电脑键盘是永远都玩不腻的玩具，中学接触信息课是这么想，填写志愿是这么想，多少学了点皮毛技术的现在也是。
恐怕我一生都会这么想，这个人可以离开很多东西，但早已经离不开计算机和游戏了。
如今不敢想象 2021 年的夏天，那是第一次拥有一台笔记本电脑，有机会天天摸到键盘，学习编程，那是连键盘盲打都不会，鼠标也用不顺手，却依然对控制台输出星号三角形乐此不疲的时间。那种勃勃生机，万物竞发的境界犹在眼前。
这样的体验带来的感觉虽然不再常有，但我还有的是时间去找感觉。
end
祝你我都好。
搭建博客时所学习参考的文章不会忘。
如今再次点开链接查看文章，shoka 主题竟然已三年未曾更新过，恐怕博客主人早已过了爱折腾的年纪，一瞬间欲言又止，心中只有时过境迁之感。
到此为止不再多想，开始着手写博客，无论内容多少，只保质不保量。给自己
自 2022 年 9 月搭建博客，至今 2024 年细算已有一年有余。
其间数次意欲证明己身实力，post 篇技术文章。奈何脑中文字所得尽数拾人牙慧，一无所长，以至于达不到理想中的原创文章。
我能轻松学会的知识、技术，为何别人不能学会，我能写出的博客，为何别人写不出。一念之间想法打消，怔怔空对文档，对博客的热情也淡了下来。
文章标题为 zero-blog 。因为过去的一无所获，无一可数，只好从零数起开始反省。反思我在已经得到所有想要的东西后还能想要什么，在失去得不到的东西后还能再失去什么。
心中剩下的只有对于电子设备的热情，这情绪的由来早已遗忘，还停留的是小时候摸到 psp 扳机的触感，点击键盘见到 flash 游戏的新鲜感。那时觉得电脑键盘是永远都玩不腻的玩具，中学接触信息课是这么想，填写志愿是这么想，多少学了点皮毛技术的现在也是。
恐怕我一生都会这么想，这个人可以离开很多东西，但早已经离不开计算机和游戏了。
如今不敢想象 2021 年的夏天，那是第一次拥有一台笔记本电脑，有机会天天摸到键盘，学习编程，那是连键盘盲打都不会，鼠标也用不顺手，却依然对控制台输出星号三角形乐此不疲的时间。那种勃勃生机，万物竞发的境界犹在眼前。
这样的体验带来的感觉虽然不再常有，但我还有的是时间去找感觉。
end
祝你我都好。
搭建博客时所学习参考的文章不会忘。
如今再次点开链接查看文章，shoka 主题竟然已三年未曾更新过，恐怕博客主人早已过了爱折腾的年纪，一瞬间欲言又止，心中只有时过境迁之感。
到此为止不再多想，开始着手写博客，无论内容多少，只保质不保量。给自己
Streamlit 特别适合需要在 Web 应用中快速展示数据或算法的项目，
比如
这是我实现的一个应用：
https://github.com/VKKKV/cypherpro
安装 Streamlit ：在终端或命令提示符中运行以下命令：
pip install streamlit |
创建一个新的 Python 文件：在你的工作目录中创建一个新的 Python 文件，比如叫做 app.py 。
编写 Streamlit 代码：在 app.py 文件中，写下以下代码：
import streamlit as st | |
# 设置页面标题 | |
st.title('我的Streamlit应用') | |
# 显示文本 | |
st.write('这是一个基本的Streamlit应用，用于展示文本和图像。') | |
# 显示图像 | |
st.image('image.jpg', caption='Sunrise by the mountains') |
运行
streamlit run app.py |
st.columns() 用于在水平方向上分割页面布局，创建并排放置的多个元素。
# 分列 | |
col1, col2, col3 = st.columns(3) | |
with col1: | |
st.write("这是第一列") | |
with col2: | |
st.write("这是第二列") | |
with col3: | |
st.write("这是第三列") |
这段代码会在页面上创建三列，每列分别显示不同的文本。
创建入口文件后，在 pages 目录中创建 .py 文件添加页面。
下面是多页应用的有效目录结构：
Home.py # This is the file you run with "streamlit run" | |
└─── pages/ | |
└─── About.py # This is a page | |
└─── 2_Page_two.py # This is another page | |
└─── 3_😎_three.py # So is this |
API# 这是最通用的命令，用于在应用中显示文本、数据、图表等。 | |
st.write() | |
# 用 Markdown 格式显示文本。 | |
st.markdown() | |
# 创建一个文本输入框。 | |
st.text_input() | |
# 创建一个按钮，当被点击时返回 True。 | |
st.button() | |
# 创建标题. | |
st.header() | |
# 创建一个文件上传控件。 | |
st.file_uploader() |
更多关于 Streamlit API 的信息，请参考
https://docs.streamlit.io/
https://cheat-sheet.streamlit.app/
第三方组件
https://streamlit.io/components
Streamlit 特别适合需要在 Web 应用中快速展示数据或算法的项目，
比如
这是我实现的一个应用：
https://github.com/VKKKV/cypherpro
安装 Streamlit ：在终端或命令提示符中运行以下命令：
pip install streamlit |
创建一个新的 Python 文件：在你的工作目录中创建一个新的 Python 文件，比如叫做 app.py 。
编写 Streamlit 代码：在 app.py 文件中，写下以下代码：
import streamlit as st | |
# 设置页面标题 | |
st.title('我的Streamlit应用') | |
# 显示文本 | |
st.write('这是一个基本的Streamlit应用，用于展示文本和图像。') | |
# 显示图像 | |
st.image('image.jpg', caption='Sunrise by the mountains') |
运行
streamlit run app.py |
st.columns() 用于在水平方向上分割页面布局，创建并排放置的多个元素。
# 分列 | |
col1, col2, col3 = st.columns(3) | |
with col1: | |
st.write("这是第一列") | |
with col2: | |
st.write("这是第二列") | |
with col3: | |
st.write("这是第三列") |
这段代码会在页面上创建三列，每列分别显示不同的文本。
创建入口文件后，在 pages 目录中创建 .py 文件添加页面。
下面是多页应用的有效目录结构：
Home.py # This is the file you run with "streamlit run" | |
└─── pages/ | |
└─── About.py # This is a page | |
└─── 2_Page_two.py # This is another page | |
└─── 3_😎_three.py # So is this |
API# 这是最通用的命令，用于在应用中显示文本、数据、图表等。 | |
st.write() | |
# 用 Markdown 格式显示文本。 | |
st.markdown() | |
# 创建一个文本输入框。 | |
st.text_input() | |
# 创建一个按钮，当被点击时返回 True。 | |
st.button() | |
# 创建标题. | |
st.header() | |
# 创建一个文件上传控件。 | |
st.file_uploader() |
更多关于 Streamlit API 的信息，请参考
https://docs.streamlit.io/
https://cheat-sheet.streamlit.app/
第三方组件
https://streamlit.io/components
Project Object Model (POM) 是 Maven 项目配置的核心概念。在 Maven 项目中，POM 通过一个名为 pom.xml 的 XML 文件表示。它包含了项目的基本信息和配置详情，如项目名称、版本、依赖项、插件、目标等。POM 使得项目的构建过程变得透明化，并且可重复，确保了持续集成和部署的一致性。
下面是 POM 中一些关键部分的概述：
基本信息：包括项目的坐标，即 groupId , artifactId , 和 version 。这些元素唯一地定义了项目在仓库中的位置。
依赖管理：在 <dependencies> 部分定义项目所需的库。每个依赖项都有其自己的坐标和范围，指明了库在项目生命周期中的使用阶段。
插件和目标： <build> 部分中的 <plugins> 定义了项目构建过程中使用的插件及其配置。这些插件可以绑定到生命周期的不同阶段上。
属性：可以定义一些属性来简化配置，例如，可以指定编译器版本或者文件编码方式。
构建配置：如源码路径、测试路径、输出文件等也在 POM 中配置。
构建生命周期：POM 文件定义了项目的构建生命周期，包括编译、测试、打包和部署等阶段。
项目继承：通过 <parent> 元素，POM 可以继承另一个 POM 的配置。这在多模块项目中特别有用。
项目聚合：通过 <modules> 元素，可以定义项目的子模块，允许一次性构建多个模块。
仓库管理：指定项目使用的仓库地址，用于依赖项的下载和项目成果的上传。
配置管理：可以包括对源代码管理系统的引用。
在实际开发过程中，经常使用的命令有：
mvn clean ：清理所有生成的 class 和 jar；mvn clean compile ：先清理，再执行到 compile；mvn clean test ：先清理，再执行到 test，因为执行 test 前必须执行 compile，所以这里不必指定 compile；mvn clean package ：先清理，再执行到 package。大多数阶段 ( phase ) 在执行过程中，因为我们通常没有在 pom.xml 中配置相关的设置，所以这些 phase 什么事情都不做。
经常用到的 phase 其实只有几个：clean ：清理compile ：编译test ：运行测试package ：打包
根目录：工程名 | |
|---`src`：源码 | |
|---|---`main`: 存放主程序 | |
|---|---|---`java`：java源码文件 | |
|---|---|---`resource`：存放框架的配置文件 | |
|---|---`test`：存放测试程序 | |
|---`pom.xml`：maven的核心配置文件 |
vkkkv
Project Object Model (POM) 是 Maven 项目配置的核心概念。在 Maven 项目中，POM 通过一个名为 pom.xml 的 XML 文件表示。它包含了项目的基本信息和配置详情，如项目名称、版本、依赖项、插件、目标等。POM 使得项目的构建过程变得透明化，并且可重复，确保了持续集成和部署的一致性。
下面是 POM 中一些关键部分的概述：
基本信息：包括项目的坐标，即 groupId , artifactId , 和 version 。这些元素唯一地定义了项目在仓库中的位置。
依赖管理：在 <dependencies> 部分定义项目所需的库。每个依赖项都有其自己的坐标和范围，指明了库在项目生命周期中的使用阶段。
插件和目标： <build> 部分中的 <plugins> 定义了项目构建过程中使用的插件及其配置。这些插件可以绑定到生命周期的不同阶段上。
属性：可以定义一些属性来简化配置，例如，可以指定编译器版本或者文件编码方式。
构建配置：如源码路径、测试路径、输出文件等也在 POM 中配置。
构建生命周期：POM 文件定义了项目的构建生命周期，包括编译、测试、打包和部署等阶段。
项目继承：通过 <parent> 元素，POM 可以继承另一个 POM 的配置。这在多模块项目中特别有用。
项目聚合：通过 <modules> 元素，可以定义项目的子模块，允许一次性构建多个模块。
仓库管理：指定项目使用的仓库地址，用于依赖项的下载和项目成果的上传。
配置管理：可以包括对源代码管理系统的引用。
在实际开发过程中，经常使用的命令有：
mvn clean ：清理所有生成的 class 和 jar；mvn clean compile ：先清理，再执行到 compile；mvn clean test ：先清理，再执行到 test，因为执行 test 前必须执行 compile，所以这里不必指定 compile；mvn clean package ：先清理，再执行到 package。大多数阶段 ( phase ) 在执行过程中，因为我们通常没有在 pom.xml 中配置相关的设置，所以这些 phase 什么事情都不做。
经常用到的 phase 其实只有几个：clean ：清理compile ：编译test ：运行测试package ：打包
根目录：工程名 | |
|---`src`：源码 | |
|---|---`main`: 存放主程序 | |
|---|---|---`java`：java源码文件 | |
|---|---|---`resource`：存放框架的配置文件 | |
|---|---`test`：存放测试程序 | |
|---`pom.xml`：maven的核心配置文件 |
vkkkv
# this is h1 | |
`this is code ` | |
> this is block quote | |
**this is b** | |
*this is i* | |
~~中划线~~ | |
<u>下划线</u> | |
\转义 |
\```markdown 行高亮 https://google.com link mark:1 |
:kissing_heart: | |
:ring: |
快捷键 [Ctrl]{.kbd} + [C]{.kbd .red} | |
H~2~0 | |
29^th^ |
快捷键 Ctrl + C
H20
29th
[default]{.label} | |
[primary]{.label .primary} | |
[info]{.label .info} | |
[success]{.label .success} | |
[warning]{.label .warning} | |
[danger]{.label .danger} |
info
- [ ] 这是一个小叉叉
+markdown 语法和部分主题扩展 - Note | vkkkv = vkkkv's blog = Technology & Life markdown 语法和部分主题扩展
# 原生语法
n # this is h1`this is code `> this is block quote**this is b***this is i*~~中划线~~<u>下划线</u>
\转义
# 部分扩展语法
# code
行高亮link \```markdown 行高亮 https://google.com link mark:1
# emoji
:kissing_heart:
:ring:
# effects
快捷键 [Ctrl]{.kbd} + [C]{.kbd .red}H~2~029^th^
快捷键 Ctrl + C
H20
29th
# label
[default]{.label}[primary]{.label .primary}[info]{.label .info}[success]{.label .success}[warning]{.label .warning}[danger]{.label .danger}
info
# taskList
- [ ] 这是一个小叉叉
- [x] 这是一个红色勾勾
{.danger}
@@ -28,4 +28,4 @@
url: https://test
{% endmedia %}
-
![vkkkv]()
vkkkv
Sharing insights on technology and lifevkkkv
Marp for VS Code 将 Markdown 转换为 PPTMarkdown 是一种轻量级标记语言，广泛用于撰写文档和笔记。
VSCode 是一个功能丰富的代码编辑器，它支持许多插件，包括 Marp，可以将 Markdown 文档转换为演示文稿。
VSCodeMarp for VS Code 扩展Markdown 文件YAML Front Matter``：--- | |
marp: true | |
--- |
--- 分隔，在单页顶部使用 <!-- --> 修改局部配置，语法支持 markdown 。Front Matter ：--- | |
marp: true | |
<!-- 设置主题 --> | |
theme: | |
<!-- 显示页码 --> | |
paginate: true | |
<!-- 全局background --> | |
backgroundColor: | |
backgroundImage: | |
<!-- 页眉 --> | |
header: | |
<!-- 页脚 --> | |
footer: | |
--- |
for example :
--- | |
marp: true | |
theme: gaia | |
_class: lead | |
paginate: true | |
backgroundImage: url('https://marp.app/assets/hero-background.svg') | |
--- | |
 | |
# **Marp** | |
`Markdown` Presentation Ecosystem | |
https://marp.app/ | |
--- | |
<!-- _header: header --> | |
# title | |
```java | |
class HelloWorld { | |
public static void main(String[] args) { | |
System.out.println("Hello, world."); | |
} | |
} | |
``` |
directives局部设置有 local 和 spot 两种。
常用的是 spot ，用来设置单页的页眉。用法如下：
<!-- _header: 小标题 --> |
themes配置项：
"markdown.marp.themes": [ | |
"yourlocalpathOrurl/yourthemes.css", | |
"another" | |
] |
预览演示文稿：点击右上角的预览图标
导出为 PPT ：点击右上角 Marp 图标，然后选择 export slide deck 导出为 ppt x。
推荐一个好看的主题 Awesome-Marp
更多 marp 信息查看 Marpit documentation
vkkkv
Marp for VS Code 将 Markdown 转换为 PPTMarkdown 是一种轻量级标记语言，广泛用于撰写文档和笔记。
VSCode 是一个功能丰富的代码编辑器，它支持许多插件，包括 Marp，可以将 Markdown 文档转换为演示文稿。
VSCodeMarp for VS Code 扩展Markdown 文件YAML Front Matter``：--- | |
marp: true | |
--- |
--- 分隔，在单页顶部使用 <!-- --> 修改局部配置，语法支持 markdown 。Front Matter ：--- | |
marp: true | |
<!-- 设置主题 --> | |
theme: | |
<!-- 显示页码 --> | |
paginate: true | |
<!-- 全局background --> | |
backgroundColor: | |
backgroundImage: | |
<!-- 页眉 --> | |
header: | |
<!-- 页脚 --> | |
footer: | |
--- |
for example :
--- | |
marp: true | |
theme: gaia | |
_class: lead | |
paginate: true | |
backgroundImage: url('https://marp.app/assets/hero-background.svg') | |
--- | |
 | |
# **Marp** | |
`Markdown` Presentation Ecosystem | |
https://marp.app/ | |
--- | |
<!-- _header: header --> | |
# title | |
```java | |
class HelloWorld { | |
public static void main(String[] args) { | |
System.out.println("Hello, world."); | |
} | |
} | |
``` |
directives局部设置有 local 和 spot 两种。
常用的是 spot ，用来设置单页的页眉。用法如下：
<!-- _header: 小标题 --> |
themes配置项：
"markdown.marp.themes": [ | |
"yourlocalpathOrurl/yourthemes.css", | |
"another" | |
] |
预览演示文稿：点击右上角的预览图标
导出为 PPT ：点击右上角 Marp 图标，然后选择 export slide deck 导出为 ppt x。
推荐一个好看的主题 Awesome-Marp
更多 marp 信息查看 Marpit documentation
vkkkv
Creational Patterns创建型模式包括：
保证一个类只有一个实例， 并提供一个访问该实例的全局节点。
public class Singleton { | |
private volatile static Singleton singleton; | |
private Singleton (){} | |
public static Singleton getSingleton() { | |
if (singleton == null) { | |
synchronized (Singleton.class) { | |
if (singleton == null) { | |
singleton = new Singleton(); | |
} | |
} | |
} | |
return singleton; | |
} | |
} |
volatile : 这是 Java 语言的一个关键字，用于指示 JVM（Java 虚拟机），这个变量可能会被多个线程同时访问和修改，但是它不会被线程缓存（每次访问变量时都要从主内存中读取），并且每次修改都会立即写入主内存。这个关键字的主要作用是确保变量的可见性和防止指令重排序优化，这对于多线程环境下安全创建单例至关重要。public interface Shape { | |
void draw(); | |
} | |
//////////////////////////////// | |
public class Rectangle implements Shape { | |
@Override | |
public void draw() { | |
System.out.println(); | |
} | |
} | |
////////////// | |
public class ShapeFactory { | |
// 使用 getShape 方法获取形状类型的对象 | |
public Shape getShape(String shapeType){ | |
if(shapeType == null){ | |
return null; | |
} | |
if(shapeType.equalsIgnoreCase("CIRCLE")){ | |
return new Circle(); | |
} else if ... | |
return null; | |
} | |
} |
// 定义抽象工厂 | |
public interface GUIFactory { | |
Button createButton(); | |
Checkbox createCheckbox(); | |
} | |
// 接着，定义 Button 和 Checkbox 接口： | |
public interface Button { | |
void paint(); | |
} | |
public interface Checkbox { | |
void paint(); | |
} | |
// 然后，实现具体的工厂类 WinFactory 和 MacFactory： | |
public class WinFactory implements GUIFactory { | |
@Override | |
public Button createButton() { | |
return new WinButton(); | |
} | |
@Override | |
public Checkbox createCheckbox() { | |
return new WinCheckbox(); | |
} | |
} | |
public class MacFactory implements GUIFactory { | |
@Override | |
public Button createButton() { | |
return new MacButton(); | |
} | |
@Override | |
public Checkbox createCheckbox() { | |
return new MacCheckbox(); | |
} | |
} | |
// 定义具体产品类 WinButton, WinCheckbox, MacButton, 和 MacCheckbox： | |
public class WinButton implements Button { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a button in Windows style."); | |
} | |
} | |
public class MacButton implements Button { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a button in macOS style."); | |
} | |
} | |
public class WinCheckbox implements Checkbox { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a checkbox in Windows style."); | |
} | |
} | |
public class MacCheckbox implements Checkbox { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a checkbox in macOS style."); | |
} | |
} | |
// 最后，实现客户端代码 Application 和 ApplicationConfigurator： | |
public class Application { | |
private GUIFactory factory; | |
private Button button; | |
public Application(GUIFactory factory) { | |
this.factory = factory; | |
} | |
public void createUI() { | |
this.button = factory.createButton(); | |
} | |
public void paint() { | |
button.paint(); | |
} | |
} | |
public class ApplicationConfigurator { | |
public static void main(String[] args) { | |
GUIFactory factory; | |
String OS = System.getProperty("os.name"); | |
if (OS.contains("Windows")) { | |
factory = new WinFactory(); | |
} else if (OS.contains("Mac")) { | |
factory = new MacFactory(); | |
} else { | |
throw new RuntimeException("Error! Unknown operating system."); | |
} | |
Application app = new Application(factory); | |
app.createUI(); | |
app.paint(); | |
} | |
} |
这段 Java 代码完整实现了抽象工厂模式，包括抽象工厂接口、具体工厂类、抽象产品接口、具体产品类以及客户端代码。客户端代码仅依赖于抽象类型（GUIFactory、Button 和 Checkbox），使得你可以在不修改客户端代码的情况下引入新的工厂或产品变体。
public class Car { | |
// 假设这里有一些属性和方法来表示汽车的各种特性 | |
} | |
public class Manual { | |
// 假设这里有一些属性和方法来表示手册的各种特性 | |
} | |
// 接下来是 `Builder` 接口的定义，包括创建产品对象不同部件的方法： | |
public interface Builder { | |
void reset(); | |
void setSeats(int number); | |
void setEngine(String engine); | |
void setTripComputer(boolean present); | |
void setGPS(boolean present); | |
} | |
// 然后，我们实现具体的生成器类 `CarBuilder` 和 `CarManualBuilder`： | |
public class CarBuilder implements Builder { | |
private Car car; | |
public CarBuilder() { | |
this.reset(); | |
} | |
@Override | |
public void reset() { | |
this.car = new Car(); | |
} | |
@Override | |
public void setSeats(int number) { | |
// 实现设置座位数的逻辑 | |
} | |
@Override | |
public void setEngine(String engine) { | |
// 实现设置引擎的逻辑 | |
} | |
@Override | |
public void setTripComputer(boolean present) { | |
// 实现设置行车电脑的逻辑 | |
} | |
@Override | |
public void setGPS(boolean present) { | |
// 实现设置 GPS 的逻辑 | |
} | |
public Car getProduct() { | |
Car product = this.car; | |
this.reset(); | |
return product; | |
} | |
} | |
public class CarManualBuilder implements Builder { | |
private Manual manual; | |
public CarManualBuilder() { | |
this.reset(); | |
} | |
@Override | |
public void reset() { | |
this.manual = new Manual(); | |
} | |
@Override | |
public void setSeats(int number) { | |
// 实现添加关于座椅的文档逻辑 | |
} | |
@Override | |
public void setEngine(String engine) { | |
// 实现添加关于引擎的介绍逻辑 | |
} | |
@Override | |
public void setTripComputer(boolean present) { | |
// 实现添加关于行车电脑的介绍逻辑 | |
} | |
@Override | |
public void setGPS(boolean present) { | |
// 实现添加关于 GPS 的介绍逻辑 | |
} | |
public Manual getProduct() { | |
Manual product = this.manual; | |
this.reset(); | |
return product; | |
} | |
} | |
// 接着，实现 `Director` 类，它负责定义构建过程的不同步骤： | |
public class Director { | |
public void constructSportsCar(Builder builder) { | |
builder.reset(); | |
builder.setSeats(2); | |
builder.setEngine("SportEngine"); | |
builder.setTripComputer(true); | |
builder.setGPS(true); | |
} | |
// 这里可以添加更多的方法来构建不同类型的汽车 | |
} | |
// 最后是客户端代码，它演示了如何使用这些类来构建产品： | |
public class Application { | |
public static void main(String[] args) { | |
Director director = new Director(); | |
CarBuilder carBuilder = new CarBuilder(); | |
director.constructSportsCar(carBuilder); | |
Car car = carBuilder.getProduct(); | |
CarManualBuilder manualBuilder = new CarManualBuilder(); | |
director.constructSportsCar(manualBuilder); | |
Manual manual = manualBuilder.getProduct(); | |
// 在这里，car 和 manual 是根据相同的构建过程创建的， | |
// 但它们是完全不同的产品。 | |
} | |
} |
这段 Java 代码展示了如何实现生成器模式，其中包括创建复杂对象的过程，使得最终产品的构建与其表示分离，允许相同的构建过程创建不同的表示。
复制已有对象
当直接创建对象的代价比较大时，则采用这种模式。
Java 中，原型模式通常通过实现 Cloneable 接口并重写 Object 类的 clone() 方法来实现。
import java.util.HashMap; | |
import java.util.Map; | |
// 抽象类实现 Cloneable 接口 | |
abstract class Shape implements Cloneable { | |
private String id; | |
protected String type; | |
abstract void draw(); | |
public String getType() { | |
return type; | |
} | |
public String getId() { | |
return id; | |
} | |
public void setId(String id) { | |
this.id = id; | |
} | |
public Object clone() { | |
Object clone = null; | |
try { | |
clone = super.clone(); | |
} catch (CloneNotSupportedException e) { | |
e.printStackTrace(); | |
} | |
return clone; | |
} | |
} | |
// 具体的形状类 | |
class Rectangle extends Shape { | |
public Rectangle() { | |
type = "Rectangle"; | |
} | |
@Override | |
void draw() { | |
System.out.println("Inside Rectangle::draw() method."); | |
} | |
} | |
class Circle extends Shape { | |
public Circle() { | |
type = "Circle"; | |
} | |
@Override | |
void draw() { | |
System.out.println("Inside Circle::draw() method."); | |
} | |
} | |
// 缓存类 | |
class ShapeCache { | |
private static Map<String, Shape> shapeMap = new HashMap<>(); | |
public static Shape getShape(String shapeId) { | |
Shape cachedShape = shapeMap.get(shapeId); | |
return (Shape) cachedShape.clone(); | |
} | |
public static void loadCache() { | |
Circle circle = new Circle(); | |
circle.setId("1"); | |
shapeMap.put(circle.getId(), circle); | |
Rectangle rectangle = new Rectangle(); | |
rectangle.setId("2"); | |
shapeMap.put(rectangle.getId(), rectangle); | |
} | |
} | |
// 客户端代码 | |
public class PrototypePatternDemo { | |
public static void main(String[] args) { | |
ShapeCache.loadCache(); | |
Shape clonedShape1 = ShapeCache.getShape("1"); | |
System.out.println("Shape : " + clonedShape1.getType()); | |
Shape clonedShape2 = ShapeCache.getShape("2"); | |
System.out.println("Shape : " + clonedShape2.getType()); | |
} | |
} |
这段代码展示了原型设计模式的核心：通过克隆现有对象来创建新对象，从而避免了通过 new 关键字创建对象带来的成本。这里， Shape 抽象类实现了 Cloneable 接口，允许其子类 Rectangle 和 Circle 被克隆。 ShapeCache 类用于预存储和克隆形状对象，而客户端代码演示了如何从缓存中获取并使用这些克隆对象。
vkkkv
Creational Patterns创建型模式包括：
保证一个类只有一个实例， 并提供一个访问该实例的全局节点。
public class Singleton { | |
private volatile static Singleton singleton; | |
private Singleton (){} | |
public static Singleton getSingleton() { | |
if (singleton == null) { | |
synchronized (Singleton.class) { | |
if (singleton == null) { | |
singleton = new Singleton(); | |
} | |
} | |
} | |
return singleton; | |
} | |
} |
volatile : 这是 Java 语言的一个关键字，用于指示 JVM（Java 虚拟机），这个变量可能会被多个线程同时访问和修改，但是它不会被线程缓存（每次访问变量时都要从主内存中读取），并且每次修改都会立即写入主内存。这个关键字的主要作用是确保变量的可见性和防止指令重排序优化，这对于多线程环境下安全创建单例至关重要。public interface Shape { | |
void draw(); | |
} | |
//////////////////////////////// | |
public class Rectangle implements Shape { | |
@Override | |
public void draw() { | |
System.out.println(); | |
} | |
} | |
////////////// | |
public class ShapeFactory { | |
// 使用 getShape 方法获取形状类型的对象 | |
public Shape getShape(String shapeType){ | |
if(shapeType == null){ | |
return null; | |
} | |
if(shapeType.equalsIgnoreCase("CIRCLE")){ | |
return new Circle(); | |
} else if ... | |
return null; | |
} | |
} |
// 定义抽象工厂 | |
public interface GUIFactory { | |
Button createButton(); | |
Checkbox createCheckbox(); | |
} | |
// 接着，定义 Button 和 Checkbox 接口： | |
public interface Button { | |
void paint(); | |
} | |
public interface Checkbox { | |
void paint(); | |
} | |
// 然后，实现具体的工厂类 WinFactory 和 MacFactory： | |
public class WinFactory implements GUIFactory { | |
@Override | |
public Button createButton() { | |
return new WinButton(); | |
} | |
@Override | |
public Checkbox createCheckbox() { | |
return new WinCheckbox(); | |
} | |
} | |
public class MacFactory implements GUIFactory { | |
@Override | |
public Button createButton() { | |
return new MacButton(); | |
} | |
@Override | |
public Checkbox createCheckbox() { | |
return new MacCheckbox(); | |
} | |
} | |
// 定义具体产品类 WinButton, WinCheckbox, MacButton, 和 MacCheckbox： | |
public class WinButton implements Button { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a button in Windows style."); | |
} | |
} | |
public class MacButton implements Button { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a button in macOS style."); | |
} | |
} | |
public class WinCheckbox implements Checkbox { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a checkbox in Windows style."); | |
} | |
} | |
public class MacCheckbox implements Checkbox { | |
@Override | |
public void paint() { | |
System.out.println("Rendering a checkbox in macOS style."); | |
} | |
} | |
// 最后，实现客户端代码 Application 和 ApplicationConfigurator： | |
public class Application { | |
private GUIFactory factory; | |
private Button button; | |
public Application(GUIFactory factory) { | |
this.factory = factory; | |
} | |
public void createUI() { | |
this.button = factory.createButton(); | |
} | |
public void paint() { | |
button.paint(); | |
} | |
} | |
public class ApplicationConfigurator { | |
public static void main(String[] args) { | |
GUIFactory factory; | |
String OS = System.getProperty("os.name"); | |
if (OS.contains("Windows")) { | |
factory = new WinFactory(); | |
} else if (OS.contains("Mac")) { | |
factory = new MacFactory(); | |
} else { | |
throw new RuntimeException("Error! Unknown operating system."); | |
} | |
Application app = new Application(factory); | |
app.createUI(); | |
app.paint(); | |
} | |
} |
这段 Java 代码完整实现了抽象工厂模式，包括抽象工厂接口、具体工厂类、抽象产品接口、具体产品类以及客户端代码。客户端代码仅依赖于抽象类型（GUIFactory、Button 和 Checkbox），使得你可以在不修改客户端代码的情况下引入新的工厂或产品变体。
public class Car { | |
// 假设这里有一些属性和方法来表示汽车的各种特性 | |
} | |
public class Manual { | |
// 假设这里有一些属性和方法来表示手册的各种特性 | |
} | |
// 接下来是 `Builder` 接口的定义，包括创建产品对象不同部件的方法： | |
public interface Builder { | |
void reset(); | |
void setSeats(int number); | |
void setEngine(String engine); | |
void setTripComputer(boolean present); | |
void setGPS(boolean present); | |
} | |
// 然后，我们实现具体的生成器类 `CarBuilder` 和 `CarManualBuilder`： | |
public class CarBuilder implements Builder { | |
private Car car; | |
public CarBuilder() { | |
this.reset(); | |
} | |
@Override | |
public void reset() { | |
this.car = new Car(); | |
} | |
@Override | |
public void setSeats(int number) { | |
// 实现设置座位数的逻辑 | |
} | |
@Override | |
public void setEngine(String engine) { | |
// 实现设置引擎的逻辑 | |
} | |
@Override | |
public void setTripComputer(boolean present) { | |
// 实现设置行车电脑的逻辑 | |
} | |
@Override | |
public void setGPS(boolean present) { | |
// 实现设置 GPS 的逻辑 | |
} | |
public Car getProduct() { | |
Car product = this.car; | |
this.reset(); | |
return product; | |
} | |
} | |
public class CarManualBuilder implements Builder { | |
private Manual manual; | |
public CarManualBuilder() { | |
this.reset(); | |
} | |
@Override | |
public void reset() { | |
this.manual = new Manual(); | |
} | |
@Override | |
public void setSeats(int number) { | |
// 实现添加关于座椅的文档逻辑 | |
} | |
@Override | |
public void setEngine(String engine) { | |
// 实现添加关于引擎的介绍逻辑 | |
} | |
@Override | |
public void setTripComputer(boolean present) { | |
// 实现添加关于行车电脑的介绍逻辑 | |
} | |
@Override | |
public void setGPS(boolean present) { | |
// 实现添加关于 GPS 的介绍逻辑 | |
} | |
public Manual getProduct() { | |
Manual product = this.manual; | |
this.reset(); | |
return product; | |
} | |
} | |
// 接着，实现 `Director` 类，它负责定义构建过程的不同步骤： | |
public class Director { | |
public void constructSportsCar(Builder builder) { | |
builder.reset(); | |
builder.setSeats(2); | |
builder.setEngine("SportEngine"); | |
builder.setTripComputer(true); | |
builder.setGPS(true); | |
} | |
// 这里可以添加更多的方法来构建不同类型的汽车 | |
} | |
// 最后是客户端代码，它演示了如何使用这些类来构建产品： | |
public class Application { | |
public static void main(String[] args) { | |
Director director = new Director(); | |
CarBuilder carBuilder = new CarBuilder(); | |
director.constructSportsCar(carBuilder); | |
Car car = carBuilder.getProduct(); | |
CarManualBuilder manualBuilder = new CarManualBuilder(); | |
director.constructSportsCar(manualBuilder); | |
Manual manual = manualBuilder.getProduct(); | |
// 在这里，car 和 manual 是根据相同的构建过程创建的， | |
// 但它们是完全不同的产品。 | |
} | |
} |
这段 Java 代码展示了如何实现生成器模式，其中包括创建复杂对象的过程，使得最终产品的构建与其表示分离，允许相同的构建过程创建不同的表示。
复制已有对象
当直接创建对象的代价比较大时，则采用这种模式。
Java 中，原型模式通常通过实现 Cloneable 接口并重写 Object 类的 clone() 方法来实现。
import java.util.HashMap; | |
import java.util.Map; | |
// 抽象类实现 Cloneable 接口 | |
abstract class Shape implements Cloneable { | |
private String id; | |
protected String type; | |
abstract void draw(); | |
public String getType() { | |
return type; | |
} | |
public String getId() { | |
return id; | |
} | |
public void setId(String id) { | |
this.id = id; | |
} | |
public Object clone() { | |
Object clone = null; | |
try { | |
clone = super.clone(); | |
} catch (CloneNotSupportedException e) { | |
e.printStackTrace(); | |
} | |
return clone; | |
} | |
} | |
// 具体的形状类 | |
class Rectangle extends Shape { | |
public Rectangle() { | |
type = "Rectangle"; | |
} | |
@Override | |
void draw() { | |
System.out.println("Inside Rectangle::draw() method."); | |
} | |
} | |
class Circle extends Shape { | |
public Circle() { | |
type = "Circle"; | |
} | |
@Override | |
void draw() { | |
System.out.println("Inside Circle::draw() method."); | |
} | |
} | |
// 缓存类 | |
class ShapeCache { | |
private static Map<String, Shape> shapeMap = new HashMap<>(); | |
public static Shape getShape(String shapeId) { | |
Shape cachedShape = shapeMap.get(shapeId); | |
return (Shape) cachedShape.clone(); | |
} | |
public static void loadCache() { | |
Circle circle = new Circle(); | |
circle.setId("1"); | |
shapeMap.put(circle.getId(), circle); | |
Rectangle rectangle = new Rectangle(); | |
rectangle.setId("2"); | |
shapeMap.put(rectangle.getId(), rectangle); | |
} | |
} | |
// 客户端代码 | |
public class PrototypePatternDemo { | |
public static void main(String[] args) { | |
ShapeCache.loadCache(); | |
Shape clonedShape1 = ShapeCache.getShape("1"); | |
System.out.println("Shape : " + clonedShape1.getType()); | |
Shape clonedShape2 = ShapeCache.getShape("2"); | |
System.out.println("Shape : " + clonedShape2.getType()); | |
} | |
} |
这段代码展示了原型设计模式的核心：通过克隆现有对象来创建新对象，从而避免了通过 new 关键字创建对象带来的成本。这里， Shape 抽象类实现了 Cloneable 接口，允许其子类 Rectangle 和 Circle 被克隆。 ShapeCache 类用于预存储和克隆形状对象，而客户端代码演示了如何从缓存中获取并使用这些克隆对象。
vkkkv
设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
1、开闭原则 Open Close Principle
2、里氏代换原则 Liskov Substitution Principle
3、依赖倒转原则 Dependence Inversion Principle
4、接口隔离原则 Interface Segregation Principle
5、迪米特法则，又称最少知道原则 Demeter Principle
6、合成复用原则 Composite Reuse Principle
Creational PatternsStructural PatternsBehavioral Patterns 。
设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
1、开闭原则 Open Close Principle
2、里氏代换原则 Liskov Substitution Principle
3、依赖倒转原则 Dependence Inversion Principle
4、接口隔离原则 Interface Segregation Principle
5、迪米特法则，又称最少知道原则 Demeter Principle
6、合成复用原则 Composite Reuse Principle
Creational PatternsStructural PatternsBehavioral Patterns 。在进行密码破解任务时，我遇到了一个典型但容易被忽视的问题：不同操作系统间的换行符差异。在这篇博客中，我将分享我的经验和解决方案，希望能帮助那些可能面临同样挑战的人。
在 Windows 系统上生成了一个用于密码破解的字典文件，文件中的换行符遵循 Windows 的标准，即 CRLF ( \r\n )。然而，我的破解工具运行在 WSL 环境中，该环境以及大多数 Linux 工具期望的换行符是 LF ( \n )。
我确定字典中有正确密码。当使用 VSCode 的 WSL 终端运行如下 fcrackzip 命令时，破解尝试失败了
fcrackzip -D -p ./vspro/passwords.txt -u flag.zip |
通过 file 命令检查字典文件，确认了问题所在：
➜ code file ./vspro/passwords.txt | |
./vspro/passwords.txt: ASCII text, with CRLF line terminators |
这表明文件是用 CRLF 作为换行符的，而不是 WSL 和 Linux 工具期望的 LF
If conditions permit在 linux 环境中使用脚本生成字典。
Else 使用指令转换换行符为了解决这个问题，我需要将字典文件中的 CRLF 换行符转换为 LF 。 Linux 和 WSL 提供了一个非常方便的工具 dos2unix ，它可以实现这种转换。
sudo apt update && sudo apt install dos2unix |
安装完成后，使用 dos2unix 命令转换文件：
dos2unix ./vspro/passwords.txt |
转换完成后，再次使用 file 命令验证文件的换行符：
➜ code file ./vspro/passwords.txt | |
./vspro/passwords.txt: ASCII text |
这次，文件描述不再提到 CRLF 换行符，说明转换成功。
转换换行符后，我再次运行了 fcrackzip 命令，这次成功破解了 ZIP 文件的密码。
This experience highlights that, when working across different platforms, even minor details like line breaks can lead to significant obstacles. Despite their seeming insignificance, these differences can greatly impact how files are processed and texts are parsed. Thankfully, with the use of straightforward tools and commands, these issues can be easily overcome, allowing for a seamless workflow.
I hope this blog post assists those facing similar challenges in cross-platform tasks, such as password cracking or any activity involving text file processing. Remember, when you come across unusual issues, it's worth starting with the basics, like the seemingly trivial matter of line breaks.
vkkkv
在进行密码破解任务时，我遇到了一个典型但容易被忽视的问题：不同操作系统间的换行符差异。在这篇博客中，我将分享我的经验和解决方案，希望能帮助那些可能面临同样挑战的人。
在 Windows 系统上生成了一个用于密码破解的字典文件，文件中的换行符遵循 Windows 的标准，即 CRLF ( \r\n )。然而，我的破解工具运行在 WSL 环境中，该环境以及大多数 Linux 工具期望的换行符是 LF ( \n )。
我确定字典中有正确密码。当使用 VSCode 的 WSL 终端运行如下 fcrackzip 命令时，破解尝试失败了
fcrackzip -D -p ./vspro/passwords.txt -u flag.zip |
通过 file 命令检查字典文件，确认了问题所在：
➜ code file ./vspro/passwords.txt | |
./vspro/passwords.txt: ASCII text, with CRLF line terminators |
这表明文件是用 CRLF 作为换行符的，而不是 WSL 和 Linux 工具期望的 LF
If conditions permit在 linux 环境中使用脚本生成字典。
Else 使用指令转换换行符为了解决这个问题，我需要将字典文件中的 CRLF 换行符转换为 LF 。 Linux 和 WSL 提供了一个非常方便的工具 dos2unix ，它可以实现这种转换。
sudo apt update && sudo apt install dos2unix |
安装完成后，使用 dos2unix 命令转换文件：
dos2unix ./vspro/passwords.txt |
转换完成后，再次使用 file 命令验证文件的换行符：
➜ code file ./vspro/passwords.txt | |
./vspro/passwords.txt: ASCII text |
这次，文件描述不再提到 CRLF 换行符，说明转换成功。
转换换行符后，我再次运行了 fcrackzip 命令，这次成功破解了 ZIP 文件的密码。
This experience highlights that, when working across different platforms, even minor details like line breaks can lead to significant obstacles. Despite their seeming insignificance, these differences can greatly impact how files are processed and texts are parsed. Thankfully, with the use of straightforward tools and commands, these issues can be easily overcome, allowing for a seamless workflow.
I hope this blog post assists those facing similar challenges in cross-platform tasks, such as password cracking or any activity involving text file processing. Remember, when you come across unusual issues, it's worth starting with the basics, like the seemingly trivial matter of line breaks.
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
2021 年放弃第一次机会，依然得到了多到无法适从的东西
\n2022、23 年放弃半分又巧合般取回半分
\n2024 年将来到的第二次机会，是属于我的 dilemma 的 last flag
\n现实和游戏的差异之一是没人会在斯特拉斯堡情不自禁
\n而差异之二在于我会去你的音乐会
\nvkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
vkkkv
