关于火山平台零基础入门教程_火山软件开发平台

关于本教程

作者：创世魂

概述：本篇教程主要以火山视窗为视角、少量安卓视角，来介绍火山软件开发平台基本语法和基本操作，从而能够快速的掌握火山软件开发。

点击开始阅读

关于火山软件开发平台

火山软件开发平台是一种目的硬件设备无关、目的软件环境无关、易学易用实用、完全本地化的软件快速开发平台。

火山平台采用独创的“语言之上的语言”（LOL）技术，成功屏蔽了火山程序对特定目标环境的依赖。用户只需要学习掌握火山程序语言，就可以针对各种目的环境进行软件开发。同时由于火山程序编译器所编译出来的是目标语言的源代码，因此能够最大限度地提升火山程序员与第三方的合作和资源共享效率， 以及所开发火山程序被社会的认可程度。

以下为火山软件开发平台的架构图：

火山平台用户源程序
支持对应目标环境的火山类库
支持对应目标环境的火山编译器
Assembly / C / C++ / C# ...... | Java | Objective C / Swift | HTML5 + JavaScript + CSS | PHP | 其它 .....
本地语言编译器 | 本地语言编译器 | 本地语言编译器 | 本地语言解释器 | 本地语言解释器
Windows桌面、Linux/Unix服务器端、嵌入式设备、单片机 ...... | 安卓移动端、安卓嵌入式设备、服务器 ...... | ios应用 | 网站前端展示、HTML5跨平台应用。 | WEB服务器端


第一章 火山平台概述及常用操作

一、火山平台概述

1. 火山平台介绍

2. 火山平台特点

3. 火山平台差异

二、火山编译环境配置

1. 安卓平台

2. 视窗平台

三、火山工作界面介绍

1. 主窗口

2. 系统设置

3. 视窗设计器

4. 安卓设计器

四、解决方案及项目介绍

1. 解决方案

1.1 概述

1.2 创建项目

1.3 解决方案目录结构概述

2. 项目管理

2.1 多文件管理

2.2 多项目管理

3. 项目模块

3.1 模块配置

3.2 模块安装

3.3 模块卸载

五、火山基本编辑环境

1. 代码输入方式

2. 代码语句体操作

3. 按需编译

六、火山程序帮助系统

1. 帮助页

1.1 概述

1.2 类库帮助页

1.3 项目帮助页

2. 悬浮提示

3. 书签

4. 例程库


一、火山平台概述

[下一章]

一、火山软件开发平台概述

1、火山开发平台介绍

火山软件开发平台是完全拥有自主知识产权、一种目的硬件设备无关、目的软件环境无关、易学易用实用、完全本地化的中文软件快速开发平台。

火山平台采用独创的“语言之上的语言”（LOL）技术，成功屏蔽了火山程序对特定目标环境的依赖。用户只需要学习掌握火山程序语言，就可以针对各种目的环境进行软件开发。同时由于火山程序编译器所编译出来的是目标语言的源代码，因此能够最大限度地提升火山程序员与第三方的合作和资源共享效率， 以及所开发火山程序被社会的认可程度。

本地化编程语言具有极其重要的价值及社会意义。

以下为火山软件开发平台的架构图：

火山平台用户源程序
支持对应目标环境的火山类库
支持对应目标环境的火山编译器
Assembly / C / C++ / C# ...... | Java | Objective C / Swift | HTML5 + JavaScript + CSS | PHP | 其它 .....
本地语言编译器 | 本地语言编译器 | 本地语言编译器 | 本地语言解释器 | 本地语言解释器
Windows桌面、Linux/Unix服务器端、嵌入式设备、单片机 ...... | 安卓移动端、安卓嵌入式设备、服务器 ...... | ios应用 | 网站前端展示、HTML5跨平台应用。 | WEB服务器端

2、火山开发特点

2.1 全中文支持

对普通用户而言，火山软件开发平台实现了彻底的中文化开发，用户无需掌握太多的专业知识、无需学习英文，即可快速开发高效实用的各类应用软件。目前具有火山安卓软件开发平台和火山视窗软件开发平台两个子平台，用作分别支持用户开发基于安卓和Windows视窗操作系统的应用程序。

如下图为火山视窗程序部分演示代码：

如下图为火山安卓程序部分演示代码：

2.2 可视化编程

(1) 界面可视化

火山视窗平台支持界面可视化，设计的程序界面所见即所得，如下图所示：

最终运行后：

(2) 代码可视化

火山平台中类、变量、常量、方法均采用表格可视化设计，可节省关键词记忆、提高程序开发效率。

2.3 语句快速录入

火山平台内置了“首/全拼输入法”，可快速使用中文名称首拼或全拼进行程序代码输入。

譬如：信息框() 只需要输入“xxk”即可。

除了“首/全拼输入法”外，火山中对于很多符号的输入也都进行了智能处理。

譬如：进行条件比较时需要双等号，但在火山中仅需要输入一个等号即可，火山会自动补充。

又譬如：在调用某方法时，使用了中文状态下的括号和逗号，火山会自动转换成英文符号。

对于“&&”(且)和“||”(或)这两个关系运算符，可通过拼音快速输入。

2.4 代码即文档

在火山中只要不刻意使用奇奇怪怪的名称进行命名，基本可以实现代码即文档，即使是没有注释、或者说非常少量的注释也可以轻松的阅读源代码，非常便于代码传播与交流，这是其它编程语言所不具备的特性。

2.5 参数引导

通过参数引导，可减少用户记忆量，减少出错的可能性。

火山中每个方法都有各自的参数，想要记住所有方法有哪些参数以及使用方法显然是不太现实。在程序实际开发过程中，通常都需要利用火山即时帮助系统或官方图文教程来学习使用这个方法，而参数引导技术就即时帮助中的一种功能。

如下图所示：

当输入参数分隔符时，注意观察悬浮提示颜色变化，会智能提示当前正在输入哪个参数。

2.6 跨平台实现语法统一

如“2.1 全中文支持”中的例图可知，即使是开发平台不同，但程序语法几乎是一致的。

最终可以达到，学会其中任意一个开发平台后，都可以轻松实现火山软件开发一通百通，快速开发各类应用软件。

3、火山平台差异

3.1 关于火山安卓软件开发平台

火山安卓软件开发平台由“火山软件开发基础平台”+“支持安卓目标环境的火山类库”+“支持安卓目标环境的编译器/调试器插件及相关工具”三部分组成，能够将用户开发的火山源程序编译为可以在安卓系统下运行的Java源程序。

3.2 关于火山视窗软件开发平台

火山视窗软件开发平台由“火山软件开发基础平台”+“支持windows视窗系统目标环境的火山类库”+“支持windows视窗系统目标环境的编译器/调试器插件及相关工具”三部分组成，能够将用户开发的火山源程序编译为可以在windows视窗系统下运行的C++源程序。

火山视窗支持编译“32/64位”的exe可执行文件和dll动态链接库，并全面支持Unicode(统一码）字符集。

[下一章]


火山软件SDK编译环境配置_火山平台语法手册

二、火山软件编译环境配置

在火山官网下载并安卓火山平台后并不能直接进行软件调试编译等工作，需要配置对应编译环境的sdk才能可以。

注：火山官网中的火山为免费版，个人版用户在购买火山后，收到加密狗后会附带一个卡片，在卡片的背面印有个人版的下载地址。

如下图所示：

在官网中，可以看到“相关附属资源下载”栏目，此栏目中提供了火山视窗和火山安卓编译所需要的sdk包，下载自己所需要的即可。

如下图为64位sdk下载后：

1、安卓平台

打开安卓平台所提供的sdk压缩包，会在压缩包中看到一个“sdk.rar”的文件夹，继续打开此压缩包会看到一个“plugins”文件夹，将这个文件夹解压到火山平台的安装路径即可。

解压完成后火山就可以正常的进行程序调试和编译发布版工作。

如果是自行下载的安卓和java的sdk，点击“工具->选项”菜单进入系统设置，选择“安卓项目管理器”分别设置“java sdk安装根目录”和“安卓sdk安装根目录”即可进行程序调试和编译发布版。

2、视窗平台

视窗平台的配置和安卓基本一致，打开下载好的sdk压缩包后，会看到一个“vs_sdk.rar”的压缩包，继续打开此压缩包会看到一个“plugins”文件夹，将这个文件夹解压到火山平台的安装路径即可。

如果是自行下载的vs编译器，点击“工具->选项”菜单进入系统设置，选择“视窗项目管理器”，设置“本地编译器”版本，如果未能识别到，可以直接提供VS编译器路径。


火山软件开发平台工作界面介绍_火山平台语法手册

三、火山软件开发平台工作界面概述

1、主窗口

主窗口界面共分为五大部分：

(1) 菜单栏

(2) 工具栏

(3) 工作夹

(4) 输出夹

(5) 代码编辑器

如下图所示：

1.1 菜单栏

(1) 文件

用于提供项目文件的创建、打开、保存、关闭等相关操作。

(2) 编辑

用于操作代码编辑器复制、粘贴、撤销、书签、代码只读、代码注释等相关代码编辑操作。

(3) 视图

用于操作火山主窗口界面的部分功能栏是否显示。

(4) 生成

用于编译程序发布版。

(5) 调试

用于调试当前项目程序。

(6) 工具

用于提供火山系统设置、模块相关操作、目标开发平台相关小工具等。

(7) 窗口

用于操作已经打开的火山程序源文件。

(8) 帮助

提供火山系统帮助，提高程序开发效率。

1.2 工具栏

提供了常用功能的快捷操作图标，譬如：新建、保存、代码编辑相关操作、项目调试/发布、项目设置等。

图标的具体作用，可通过鼠标在图标上悬停，查看提示信息，如下图所示：

1.3 工作夹

在工作夹中又分三个子工作夹：

(1) 解决方案

用于提供展示当前解决方案，便于操作解决方案及项目。

(2) 查找替换

用于提供项目代码查找、替换等功能，其结果将显示在输出夹中。

(3) 类库

类库夹中，第一个图标点击：用于查看火山系统类库模块和已安装的第三方类库。

第三个图标点击：用于刷新类库。

第二个图标点击：用于提供类库内容搜索功能，可以指定搜索视窗类库还是安卓类库。

1.4 输出夹

用于显示火山软件的相关输出信息。

当软件进行调试时，还会显示“调用栈”和“监视表”。

1.5 代码编辑器

用于编写程序代码，当需要编写同一文件不同位置的代码时，可进行拆分操作。

如下图所示：

代码编辑器的右上角可点击拖拽，拖拽后会将当前源码文件拆分成上下两部分，可用于编写不同位置的代码，提高代码编写效率。

如果需要同时操作多个源码文件，也可以进行拆分。

如下图所示：

点击源码文件名可进行拖拽拆分。

2、系统设置

提供火山平台系统设置操作。

通过“工具 -> 选项”菜单即可打开火山设置。

根据自己的需求进行相关设置操作即可，譬如：想要调整火山代码颜色，就去“火山程序管理器 -> 文档”中进行设置。

注：如果使用的是火山全平台，才会同时显示“安卓”和“视窗”的项目管理器设置。

3、视窗设计器

在创建窗口程序项目后，就可以在窗口类的代码区域右键打开窗口设计器，或使用快捷键“Ctrl + U”。

视窗界面设计器分为五个区域，如下所示：

(1) 工具栏

用于调整组件布局样式，如下图所示，选中两个组件后可以批量对齐。

(2) 窗口界面设计区

进行界面设计相关工作，依赖组件栏和属性栏。

在火山视窗中的界面设计采用的是绝对布局模式，即精确指定某个组件在窗口中所处的位置和尺寸。

(3) 组件栏

选中指定组件后可以将其在“窗口界面设计区”进行界面设计，如下图所示：

(4) 提示栏

用于显示提示信息，无论是选择组件还是选择组件的某个属性，都会在提示栏中进行相关提示。

(5) 属性栏

用于设置组件常用属性，譬如：修改按钮标题。

在属性栏中，点击“布局内容”可以查看组件布局结构，便于了解组件层次。

视窗软件中的组件焦点：

在视窗软件进行界面设计时，每个组件都可以获得焦点，按下Tab键也可以进行切换焦点。

如下以编辑框组件举例，按下tab键后光标可以在多个编辑框直接进行切换：

但是有时候会遇到这样的问题，组件切换焦点的顺序是错乱的，譬如：软件运行时输入焦点在账号编辑框中，但是按下tab键后，焦点转移到了验证码编辑框中，这显然是不正常的。

如下所示：

解决这个问题很简单，在布局内容中即可调整焦点顺序。

如下图所示，将密码编辑框和验证码编辑框对调位置，焦点切换即可恢复正常。

除此之外，如果软件运行时并不是账号编辑框获得输入焦点，也可以采取同样的办法，将账号编辑框调整到顶部位置即可。

4、安卓设计器

安卓界面设计器打开方式同视窗设计器一致。

如下图所示：

安卓界面设计器与视窗界面设计器基本一致，有以下几处不同：

(1) 没有布局工具栏，但有一个“布局预览尺寸”，用于调整设计器的预览尺寸。

注：预览尺寸仅仅提供预览，并不会影响软件最终运行尺寸。

(2) 在“布局内容”中，增加了一个“布局栏”，用于对当前窗口设置多种布局。

譬如：在此可以复制并建立一个英文系统下的布局内容。具体可看“如何设计安卓界面布局”文章中“9. 已有布局列表框”。

(3) 安卓采用的是相对布局模式：

火山视窗采用的是绝对布局模式(即精确指定某个组件在窗口中所处的位置和尺寸)，但这种方式在安卓系统下是行不通的，这是为什么呢？

道理很简单：Windows程序界面的显示设备只有一种：电脑屏幕，并且各种屏幕的DPI(每英寸像素数)和物理尺寸相差无几，而安卓程序界面的显示设备却是千千万万，其设备显示屏的DPI和物理尺寸可能相差很大，譬如电视机上可以运行安卓程序，手机上可以运行安卓程序，甚至只有很小屏幕的随声听/运动手环上也可以运行安卓程序，此时使用绝对布局方式将是一个噩梦，你根本无法设计出可以同时在各种安卓设备上正常显示的窗口界面。

由于以上原因，安卓程序采用的是相对布局方式，也就是说，某个组件的实际位置和尺寸是与其周边组件相关的。

注：虽然无法使用以前开发Windows程序所习惯的绝对布局方式会让您觉得有点麻烦，但是相对程序的环境可适应性及后续维护工作量，您最终会觉得这点麻烦是很值得的，而且您很快就能发现，相对布局方式也很容易学习。

具体可看“如何设计安卓界面布局”文章中的“4. 线性布局器”，学习如何进行安卓界面设计。

(4) 因设备环境不同，安卓设计器暂不支持实时界面预览，实际效果以安卓系统运行后的效果为准。

界面设计效果和最终运行效果，分别如下图所示：

(5) 设计方式不同

在安卓设计器中，需要鼠标点击组件后（不松开鼠标左键），直接拖拽到设计器后再松开鼠标。

如下图所示：


火山平台解决方案及项目介绍_火山平台语法手册

四、火山平台解决方案及项目介绍

1、解决方案

1.1 概述

多个项目建立在一起的集合被称为解决方案，火山软件开发平台采用的是多项目多文件管理模式，一个解决方案内可以放N个项目，一个项目内可以有N个火山源码文件。

例如：要开发一个软件，预计升级多个版本，你想保留历史版本的源代码，那么就可以都把这些历史版本的源代码放在一个解决方案中便于管理。

1.2 创建项目

创建一个新的项目时会自动依赖一个解决方案，如下图所示进行创建：

(1) 可通过“文件 -> 新建 -> 项目”或直接点击欢迎页中的“新建项目”都可以实现创建项目。

(2) 根据自己的需求选择平台及目标平台的项目模板，并依次填写项目名称、选择所处(保存)位置、解决方案名称，最后点击确定即可。

(3) 如果“所处位置”不存在会提示进行创建，点击“是”进行创建即可。

(4) 最后创建成功后如下图，其中解决方案/项目/源文件名称都可以通过双击进行修改。

1.3 解决方案目录结构概述

在创建了一个项目后，会在“所处位置”目录中生成“解决方案文件”和“项目文件夹”。

注：这些生成的项目文件或文件夹不允许随意修改其名称，否则会导致项目无法打开。

(1) 解决方法文件后缀名为“vsln”，启动火山项目时，双击此文件即可打开。

(2) 项目文件夹中存储有当前项目源码数据。

打开项目文件夹，可以看到一个“src”的文件夹和后缀名为“vprj”的项目配置文件。

(1) 项目配置文件中存储有当前项目所有配置信息。

(2) 自动生成的主程序模板文件，位于src文件夹中。

打开src文件夹就可以看到自动生成的主程序模板文件。

当程序进行调试或编译发布版时，会自动在解决方案所处目录中，生成一个“_int”文件夹，用于输出目标平台的源码文件和项目程序文件。

安卓平台和视窗平台的程序输出路径分别如下：

(1) 安卓平台程序默认输出路径：

调试版程序默认输出在：“_int\项目文件名\debug\linker”目录中。

发布版程序默认输出在：“_int\项目文件名\release\linker”目录中。

(2) 视窗平台程序默认输出路径：

调试版程序默认输出在：“_int\项目文件名\debug\x64(或win32)\linker”目录中。

发布版程序默认输出在：“_int\项目文件名\release\x64(或win32)\linker”目录中。

注：x64指64位程序，win32指32位程序。

“_int”文件夹可以自定义其保存位置，通过右键解决方案选择属性菜单，通过设置“编译中间数据目录”即可自定义位置。

2、项目管理

2.1 多文件管理

火山平台中的项目是支持多文件管理的。

例如：软件中有多个窗口，可以建立多个火山源码文件，一个文件中存放一个窗口类，可便于后期软件维护。

注：跨文件调用程序代码可看“包”或“类”中的介绍。

(1) 鼠标右键项目选择“添加 -> 新建文件”。

(2) 在新建文档窗口中，填写文件名，选择所处位置(默认为当前项目目录，建议保持原样)。

(3) 文件创建完毕后如下图：

(4) 如果软件有多个功能模块或窗口，可以创建多个源码文件来管理。

(5) 创建完毕后的火山源码文件会出现在“所处位置”的目录中。

(6) 如果项目文件过多，还可以通过建立筛选器来进行二次分类。

右键项目选择“添加 -> 新建筛选器”。

(7) 建立后可以通过右键进行重命名。

(8) 筛选器建立完成后，可以通过点击鼠标左键拖拽火山源码文件到目标筛选器中。

2.2 多项目管理

火山平台支持在解决方案中建立多个项目进行管理，不同平台之间也可以混合建立。

如下所示：

(1) 右键解决方案选择“添加 -> 新建项目”，就可以进行项目建立。

(2) 在新建项目窗口中，选择一个平台和项目模板，输入项目名称后点击确定即可建立一个新的项目。

注：所处位置默认会填写当前解决方案路径，建议保持原样即可。

(3) 项目建立成功后，会自动设置新项目为活动项目。

活动项目：即当前操作项目。

(4) 切换活动项目，通过项目的右键菜单中可以直接切换。

注：活动项目切换后，项目文本颜色会发生变化。

如果打开了很多火山源文件，也可以通过文件名右键设置活动项目，如下所示：

(5) 项目建立后，可在“所处位置”指定的路径中看到新项目文件夹，每个项目都会依赖一个文件夹。

3、项目模块

3.1 模块配置

在火山中每个项目都可以独立配置进行模块(即火山类库)配置，模块不可以跨平台配置，例如：安卓项目无法配置视窗模块。

模块配置方法如下：

(1) 右键项目配置

如果某项目想要配置模块，可通过右键此项目进行配置模块。

在弹出的模块配置窗口中，勾选要配置的模块点击“确定”即可。

注：如果想要删除某些模块，取消勾选即可。

会提示正在添加哪些模块，确认无误后直接点击“确定”即可。

添加成功后，可在项目的“模块”分类下看到被添加的模块。

(2) 类库夹中右键配置

右键要配置的模块，选择“将此模块加入项目XX”，这里会自动选择当前活动项目进行模块配置。

配置成功后可以在当前活动项目中看到此模块。

(3) 在帮助页中配置

例如：在进行类库功能搜索时，双击搜索结果打开帮助页，可以在帮助页中将此类所处的模块添加到当前活动项目中。

添加成功后可以在项目中看到此模块。

删除模块配置方法如下：

右键要删除的模块，选择“删除”即可。

3.2 模块安装

火山平台模块的后缀名为vcip，模块安装时火山平台会自动识别安装到视窗模块中还是安卓模块中，安装后将会出现在类库夹中。

模块安装方式如下：

双击模块文件即可安装。

也可以通过“工具->安装模块”进行模块安装。

3.3 模块卸载

选择“工具-卸载模块”即可卸载第三方模块。

(1) 选择要卸载的平台。

(2) 勾选要卸载的模块，点击“卸载”即可。


火山软件平台基本编辑环境介绍_火山平台语法手册

五、火山软件开发平台基本编辑环境

1、代码输入方式

在火山平台中支持首拼、全拼和汉字智能提示输入，并且按下空格或回车键可将首个提示内容输入到代码编辑框中。

如下所示：

输入方式演示如下：

(1) 首拼输入

如下所示，输入“jbbl”就可以表示“局部变量”。

(2) 全拼输入

如下所示，输入“jubu”加空格就可以快速输入“局部变量”。

(3) 汉字输入

如下所示，输入“局部”也可以将“局部变量”完整的提示并输入。

2、代码语句体操作

在火山平台中代码都是语句体形式，具体可看“方法语句”中的介绍。

代码的表现形式都是一层一层，如下：

可以清晰的看出类位于一层，成员变量和方法位于同一层，方法内的局部变量和方法语句调用，又是一层。

除了类和方法的层级是固定的无法调整外，其它变量、常量、方法语句等都可以进行层级调整。

例如：局部变量也可通过调整层级变为成员变量，也可以重新修改为局部变量。

如下所示：

选中局部变量右键选择“块操作 -> 向内缩进”或者使用快捷键“ctrl + [”。

就可以将局部变量改为成员变量。

同理使用“向外缩进”或快捷键“ctrl + ]”，可以重新将成员变量改为局部变量。

如果在方法中输入代码时，发现代码为绿色，证明代码输入到了注释层，此时可通过快捷键“ctrl + ]”进行向外缩进，就可以让代码重新恢复正常。

如下所示：

另外还有几个使用较多的快捷键为“Ctrl + Insert”和“Shift + Insert”，用作向前/向后插入行，部分电脑需要配合“Fn”键使用。

其中，在方法的参数/常量/变量定义表格上按下“Shift + Insert”快捷键，将固定在其下方插入一条空白语句行，如图：

在“变量1”的定义行上按下“Shift + Insert”快捷键后的结果如下：

3、按需编译

火山编译器实行的是按需编译模式，也就是说，凡是不可能被执行到的代码，一概不进行编译。具体为：

从程序的启动位置开始，所有未在程序执行流程中的代码都将不会被编译。

以火山安卓开发平台举例，譬如下图：


火山软件开发平台程序帮助系统_火山平台语法手册

六、火山软件开发平台程序帮助系统

1、帮助页

1.1 概述

帮助页是火山平台提供的即时帮助系统，可用于查看类、方法、变量、常量等数据的帮助信息。

便于在遇到一些陌生方法时，能够掌握如何使用。具体使用方式可看：第二章第九节：火山类库方法识别与调用。

1.2 类库帮助页

如下图为方法帮助页的效果，其它类型的帮助页效果大同小异，只是所显示的数据不同。

下面介绍类库帮助页中最常用的几个功能：

(1) 打开

本功能用于定位源代码，便于在一些方法存在问题时方便自己修改。

(2) 选择

用于在类库夹中定位所处位置。

(3) 例程

用于在火山系统例程库中搜索当前方法是否有对应案例，如果有将会打开“例程查找结果”窗口。

(4) 添加模块到项目

用于配置当前类/方法/变量/常量等数据所处的模块添加到当前活动项目中。

类库帮助页有以下打开方式：

(1) 类库夹中首次打开需要双击，随后可单击进行切换。

(2) 利用类库搜索打开

(3) 光标定位关键词，使用快捷键F1打开，部分电脑可能需要Fn + F1。

1.3 项目帮助

通过右键项目选择“查看程序结构”或使用快捷键“Shift + F1”即可打开当前项目的帮助窗口。

项目帮助窗口效果如下图：

2、悬浮提示

鼠标在代码语句上停留大约1秒，会提示当前方法的参数等信息，便于不打开帮助页时也可查看帮助信息。

3、书签

书签用于标记某行代码，设置额外注释信息，多个书签之间可通过快捷键“F2”进行跳转。

其功能位于“编辑 -> 书签”菜单中。

加入书签后会在代码行左侧出现一个小图标：

书签编辑窗口：

书签提示信息：

使用快捷键F2可进行书签切换：

4、例程库

火山平台提供了非常丰富的例程库，内置了大量的案例，并在逐步完善。

可通过“文件->打开->样例解决方案”或欢迎页中的“打开样例-XX项目”进行打开系统例程库。


第二章 火山平台基本语法

一、相关术语

1. 面向对象

2. 名称

3. 立即数

4. 数据类型

二、火山程序面向对象设计

三、火山程序结构详解

1. 包

2. 注释

3. 类

3.1 类的构成

3.2 启动类的定义

3.3 自定义类

3.4 类的注意事项

3.4 类的基本属性表

4. 变量

4.1 什么是变量？

4.2 变量的定义

4.3 变量分类

4.3.1 成员变量

4.3.2 局部变量

4.3.3 公开变量

4.3.4 静态变量

4.3.4 参考变量

4.4 变量的初始值

5. 常量

4.1 什么是常量？

4.2 常量的定义

4.3 常量的分类

4.3.1 成员常量

4.3.2 局部常量

4.3.3 公开常量

4.4 常量的初始值

6. 方法

6.1 什么是方法？

6.2 定义通常方法

6.3 方法的参数与数据传递

6.4 方法的返回值

6.5 方法的嵌套调用

6.6 方法的递归调用

6.7 定义静态方法

6.8 定义支持以动态格式调用的静态方法

6.9 定义属性方法

6.10 定义事件方法

6.11 定义全局静态方法

6.12 定义虚拟方法

7. 方法语句

7.1 表达式语句

7.2 嵌入式语句

四、火山平台中的符号

1. 操作符

1.1 点（ . ）

1.2 方法符小括号 ( )

1.3 参数分隔符逗号（ , ）

1.4 数组符号（ [] ）

1.5 注释符（ // ）

1.6 双引号（ " ）

1.7 单引号（ ' ）

1.8 转义符（ \ ）

2. 运算符

2.1 四则运算符（ +-*/ ）

2.2 取反符（-）

2.3 强制类型转换（）

2.4 求余符（%）

2.5 关系运算且（&&）

2.6 关系运算或（||）

2.7 关系运算小于等于（<=）

2.8 关系运算大于等于（>=）

2.9关系运算小于（<）

2.10关系运算大于（>）

2.11 关系运算不等号（!=）

2.12 关系运算双等号（==）

2.13 赋值运算符（=）

五、数据类型

1. 数据类型

1.1 了解数据类型

1.2 数据类型使用

2. 基本数据类型

2.1 字节

2.2 短整数

2.3 整数

2.4 长整数

2.5 变整数

2.6 小数

2.7 逻辑型

2.8 字符

2.9 文本型

2.10 模板类型1~8

3. 基本数据类型扩展类与对象类

3.1 字节集类与字节[]

3.2 基本数据类型包装类

3.3 对象类

六、关键字与常用方法

1. 名称关键字

1.1 返回

1.2 属于

1.3 逻辑值

1.4 空对象

1.5 父对象

1.6 本对象

2. 方法关键字

2.1 事件方法

2.1.1 挂接事件

2.1.2 取消事件挂接

2.2 运算方法

2.2.1 取反

2.3 位运算方法

2.3.1 了解位运算

2.3.2 常用进制

2.3.3 位取反

2.3.4 位与

2.3.5 位或

2.3.6 位异或

2.3.7 位左移

2.3.8 位右移

3. 常用基础方法

3.1 赋值方法

3.1.1 连续赋值

3.1.2 连续清零

3.1.3 连续清空

3.2 运算方法

3.2.1 选择

七、流程控制语句

1. 概述

2. 如果语句

2.1 如果

2.2 如果否则

3. 如果真语句

4. 分支判断语句

4.1 分支判断与分支

4.2 默认分支

4.2 跳出分支

八、循环结构语句

1. 概述

2. 循环

3. 计次循环

4. 逆向计次循环

5. 取循环索引

6. 循环判断首和循环判断尾

7. 判断循环

8. 跳出循环

9. 到循环尾

九、火山类库方法识别与调用

1. 概述

2. 通常方法的识别与调用

3. 静态方法的识别与调用

3.1 普通静态方法

3.2 动态格式调用的静态方法

3.3 全局静态方法

4. 属性写的识别与调用

5. 属性读的识别与调用

6. 事件方法的识别与调用

7. 虚拟方法的识别与添加


火山软件相关术语_火山平台语法手册

一、火山软件开发平台相关术语

1、面向对象

面向对象是一种程序设计理念，被绝大多数程序语言所使用，熟悉的C++，java等都可以使用面向对象来进行程序设计。使用它进行程序设计，可以最大限度地提高程序代码的可复用性和可维护性，如果您想学习程序设计，那么这种设计方法是必须需要掌握的。

为了降低用户的学习门槛，火山对这套理念进行了最大限度的精简，只保留了其精华部分，因此学习起来并不难，只需要跟着本书一步一步的学习很容易就可以掌握。

关于面向对象的详细解说可看“第二节”的内容。

2、名称

火山平台中的名称共有两个，分别为“单名称”和“全名称”。

2.1 单名称:

单名称必须以“英文字母/下划线字符/汉字字符”开头，后面跟随“英文字母/下划线字符/数字/汉字字符”。如未特殊标注，本文档中所提出的所有“名称”均为单名称。

如下图所示：一个变量，一个方法名或一个类名，均可以叫“单名称”。

2.2 全名称:

多个单名称以句点符合组合在一起的名称称为“全名称”，例如火山代码中的包名“火山.程序”。

并且目前只有“包名”属于全名称。

注意: 火山中的名称对英文字母的大小写敏感,譬如“abc”和“ABC”是两个不同的名称。

2.3 名称来源:

火山中的名称来源共有两种:

1. 系统中预先定义的名称，主要是“关键字”和“系统类库”中的名称。

2. 用户程序中自行定义的名称，(如：类/方法/常量/变量/参数)的名称。

这些名称均可以通过系统内置的首拼或全拼输入法进行输入。

如下图所示：自定义的名称“变量1”，可通过“bl1”或“bianliang1”进行输入。

3、立即数

立即数用于直接表达某个基本数据类型的数据值，共有以下四类：

3.1 数值立即数:

（1） 十进制整数或小数，小数支持使用科学计数法，如“1.32e3”。

如果要表达这个立即数也很简单，如下图所示直接在变量的初始值中填写即可。

或者下图中的等于号赋值的形式。

（2） 十六进制整数: “0x”后跟数字0-9或字母A-F(大小写无关)， 如“0x12AC3F”。

十六进制整数表达与整数和小数一致，如下图所示：

（3） 字符立即数值: 使用单引号括住的字符，如'火'，'山'用于“字符”类型的立即数。

字符立即数表达如下图所示：

注：在字符立即数中也支持转义符操作，例如:'\t','\n'等，如下图所示：

（4） 立即数之间的强制转换：譬如“1”整数立即数使用“强制类型转换”操作符可以转换成“长整数”类型。

如下图所示，“(长整数)1”提供了一个数据类型为长整数的数值立即数：

注意：强制转换操作不能在初始值中填写，下图写法是错误的。

如果某整数的数值超出了整数的最大有效范围，将自动被设定为长整数数据类型。

如: “0x123456789A”将被自动认为是长整数数据类型，使用的时候需要“长整数”。

3.2 逻辑型立即数：
为真/假，只能给“逻辑型”使用。

3.3 字符串立即数：

为用双引号（必须是英文引号""）括住的一段文本，只能提供给“文本型”使用，如下图所示：

在字符串立即数中支持以下转义符操作：

转义符 | 解释
\b | 退格符
\f | 换页符
\r | 回车符
\n | 换行符
\t | 水平制表符
\' 单引号
\" 双引号
\\ 反斜杠
\x | 后跟1-3个十六进制字符,为所对应字符的代码值.

如在火山视窗平台中：“您好!\r\n祖国”在“您好!”和“祖国”之间通过使用转义符插入了一个回车和换行符。

最终会出现换行效果。

注意: 在火山安卓平台里面，如果欲达到换行效果,需要插入“\n”即可，如下图所示：

最终会出现换行效果。

3.4 数组立即数
（只能在提供常量/变量数组初始值时使用）

为使用花括号括住的立即数的组合,如: { 1, 2 }, 多维数组可以嵌套,如: { { 1, 2 }, { 3, 4 }, { 5, 6 } }

注意: 多维数组的同一维内成员数目必须相等,譬如如下格式的数组立即数是不允许的: { { 1, 2 }, { 3 } } ,因为其第2个维中的成员数目不相等。

正确的数组立即数表达如下图所示：

注意：火山中不支持等于号赋值数组立即数，如下图所示的写法是错误的。

4、 数据类型

数据类型可以为以下几种:

4.1 基本数据类型，软件开发过程中必备的基本类型。

4.2 用户程序中自定义的类，称为“类数据类型”。

4.3 数组数据类型

数组数据类型为基本或类数据类型后面跟随一个或多个数组维定义组成。

每个数组维定义由左右中括号(“[]”)组成,如果应用在变量或常量定义上，可以在中括号内部置入具体成员数目，表示生成具有对应维数的数组变量实例，可参考数组立即数中的定义。

数据类型可以在定义常量/变量/参数/方法返回值时使用，也可以在程序语句中使用。

火山视窗示例：

注意：在火山视窗中不支持数组类型作为参数和返回值，以下写法是错误的。

火山安卓示例：


火山软件面向对象程序设计_火山平台语法手册

二、火山软件开发平台面向对象的程序设计方法

以火山视窗为例介绍：

● 假设有一家工厂，所生成的产品是电水壶，这种电水壶有这些主要特点：

1、由壶体和壶盖组成；

2、颜色是银白色的；

3、有一个开关可以控制启动烧水；

4、水烧开后会发出鸣叫声音报警。

按照面向对象的设计方法，我们把这个电水壶称为这个工厂的一“类”产品，简称为“电水壶类”，它具有同样的4个特点：

1、有两个成员变量：壶体和壶盖；

2、有一个成员属性：颜色，它的值等于银白色；

3、有一个成员方法：烧水（即按下开关就开始烧水）；

5、有一个成员事件：水已经烧开警报。

变量用来存储类中的数据，属性用来表达或修改类的特征，方法用作执行类的功能，事件用来对外发送通知，类就是记录有一系列变量、属性、方法、事件成员的集合，所有具有这些特征成员的具体产品就叫做这个类的对象，这就是面向对象的程序设计理念来由。

用前面的例子来讲，“电水壶类”就是电水壶的产品设计规范，而具体的单个电水壶产品就是“电水壶类”的对象（有时也叫对象实例）。

这就是类的封装，我们根据上述描述可以得出如下图所示代码：

假设火山可以驱动这个电水壶操作，那么上述类在火山中的一步一步的调用示例如下图所示：

(1) 首先要定义一个类型为“电水壶类”的变量。

(2) 添加我的主窗口“创建完毕”事件。

(3) 在窗口创建完毕事件下调用“电水壶变量.烧水()”

(4) 添加“水烧开警告”事件。

(5) 添加事件后显示一个信息框，提示水烧开了。

(6) 最终当火山程序运行时，会弹出水烧开的信息框，证明整个程序的执行流程是没有任何问题的。

上述案例下载：安卓平台，视窗平台。

● 假设有一天，工厂想生产一种具有自动保温功能的电水壶，有两种方案：一是完全重新设计一个新的电水壶，二是在现有电水壶的基础上增加一个保温开关。很显然，第二种方式更经济实惠，工厂把这种新的电水壶称为保温电水壶，它增加了一个特点：

1、增加了一个开关： 保温，按下开关后可以对已经烧开的水进行自动保温。

按照前面的设计方法，由于新电水壶增加了一个成员，所以我们不能把它归纳到已有的“电水壶类”里面，但是我们可以建立一个新的类：“保温电水壶类”，它在“电水壶类”的基础上同样增加了一个新成员：

1、成员方法：保温（即按下开关就开始保温）

通过上述我们可以得出如下代码：

由于它基于“电水壶类”设计而来，因此我们把“电水壶类”称为“保温电水壶类”的基础类或父类，把“保温电水壶类”称为“电水壶类”的继承类或子类，它们之间是继承与被继承的关系，继承类自动具有基础类的所有特征成员。

由于继承类包括了基础类的所有成员，因此继承类也可以认为是基础类的一种。这个也很容易理解：我们可以把“保温电水壶”称为“电水壶”，但是不能把“电水壶”称为“保温电水壶”。假设客户要买1000个“电水壶”，现有产品数量不够时我们可以用“保温电水壶”来充数，但是客户要买1000个“保温电水壶”就绝对不能用“电水壶”来充数，是不是这个道理？

从程序设计的角度来讲，就是我可以把一个数据类型为“保温电水壶类”的对象赋值到一个数据类型为“电水壶”的变量，但是不允许把一个数据类型为“电水壶”的对象赋值到一个数据类型为“保温电水壶类”的变量。

如下图所示：

需要注意的是：如果把一个数据类型为“保温电水壶类”的对象赋值到一个数据类型为“电水壶”的变量，那么这个变量里面实际存储的还是一个“保温电水壶类”对象，并不会因为变量的数据类型为“电水壶”存储进去的对象的数据类型就也为“电水壶”了。这个也很好理解：工厂用“保温电水壶”充作“电水壶”交付给了客户，不会因为这个充数行为就导致“保温电水壶”产品变成“电水壶”产品了。

这就是类的继承，可以如下所示调用“保温电水壶类”：

(1) 首先定义“保温电水壶类”的成员变量。

(2) 在窗口创建完毕后调用“烧水”方法。

(3) 当水烧开后执行“保温”。

(4) 最终会弹出信息框提示，证明保温执行成功。

上述案例下载：安卓平台，视窗平台。

● 让我们继续假设，假设有一天工厂发现电茶壶的销路要比电水壶好，同样有两种方案：一是完全重新设计一个新的电茶壶，二是修改现有电水壶的烧水功能，将其改为烧茶。同样很显然，第二种方式更经济实惠。那么这种电茶壶的特点为：

1、修改了电水壶的烧水功能，使其改去烧茶。

同样，我们需要定义一个名为“电茶壶类”的类，然后定义一个同样名为“烧水”的方法，该方法覆盖了“电水壶类”中的原有名为“烧水”的方法，然后将“电水壶类”中的“烧水”方法标记为虚拟方法（虚拟方法仅是一个标记，用作标记“烧水”方法可以被继承类覆盖），这样以后调用“电茶壶类”类的“烧水”方法时，就会改去烧茶，而不会去烧水。

(1) 如上所描，首先对“电水壶类”进行一些细微的修改。

(2) 定义“电茶壶类”并继承电水壶类，添加“烧水”的虚拟方法。

(3) 在“烧水”虚拟方法下调用“水烧开警告(假)”，用于发送茶烧开完毕。

(4) 首先在主窗口中声明“电茶壶类”变量。

(5) 窗口创建完毕后调用“烧水”方法，本方法因设置了虚拟方法进行了修改，实际上是烧茶。

(6) 最后添加“水烧开警告”事件，判断茶是否烧开。

(7) 最终茶被烧开。

需要注意的是：如果把一个数据类型为“电茶壶类”的对象赋值到一个数据类型为“电水壶”的变量，据前所述，这个变量里面实际存放的还是一个“电茶壶类”的对象，因此如果调用该变量的“烧水”方法，实际上调用的还是“电茶壶类”的烧茶功能。

这就是类的多态，在“虚拟方法” 中的也有相应的操作案例可以学习。

上述案例下载：安卓平台，视窗平台。

● 以上就是火山中所使用的面向对象程序设计的全部内容了，最后一点其实与面向对象设计无关：

假设甲公司和乙公司都生产电水壶，商店如果同时进货了这两种电水壶，就必须在电水壶上分别贴上标签：“甲公司的电水壶”、“乙公司的电水壶”，以免引起混淆。

在程序设计里面，就对应为“甲公司.电水壶类”、“乙公司.电水壶类”，前面的“甲公司”和“乙公司”分别定义了一个命名空间，也叫做“包”。包用作避免名称混淆，在同一个名称的包内，不允许存在相同名称的类，在不同名称的包内，可以存在相同名称的类。

所有在包中定义的类，其名称前被自动加上包名，“包名.类名”称为类的绝对名称。如果该类的名称在程序的所有包中均唯一或者在该类所处包内部引用此类,可以省略掉其包名来引用此类。

譬如，假设程序中不存在“乙公司.电水壶类”或者在“甲公司”包自身的代码内部，就可以直接使用“电水壶类”来引用“甲公司.电水壶类”。

注意：包名中间也可以包括句点，譬如“湖北.武汉.甲公司”或“湖南.长沙.乙公司”，这样的命名空间更明确清晰一些，也更具有唯一性。

上述内容可参考关于“包”中的介绍案例。


火山软件程序结构详解_火山平台语法手册

三、火山软件开发平台程序结构详解

在观看本节之前，务必看下第二节中的面向对象程序设计

一个火山程序的构成结构如下:

1. 包定义

1. 文档嵌入行(知道即可无需了解)

2. 文档注释行

3. 类定义

1. 类嵌入行(知道即可无需了解)

2. 类注释行

3. 类成员常量

4. 类成员变量

5. 类成员方法

1. 方法参数

2. 方法局部常量

3. 方法局部变量

4. 语句注释行

5. 语句行

6. 语句嵌入行(知道即可无需了解)

火山视窗程序结构演示：

火山安卓程序结构演示：

1、包

包名为“全名称”，通常名字为“公司名称+软件名称+功能分类”进行命名。例如：“递归.火山软件.主程序”或者“火山软件.文本操作模块”等，只要方便自己后期维护任何命名都可以，但是包名中必须保证至少有一个小数点。

在火山程序中每个源文件都会有一个包名，无法删除且固定于程序首行位置，并且一个源文件只能存在一个包名。

不同源文件的包名可重复，程序会自动将两个文件归位一个包内，相同包名的文件即使不公开类也可以实现跨文件调用。

如果两个火山源文件的包名不一致，则需要公开类才能被其它包的程序访问。

务必注意：在火山安卓程序中“启动类”所处位置的包名，填写后会编译为程序包名，安卓中的程序包名一旦填写后将不能修改，因为随便修改将会导致程序无法正常的升级安装，务必慎重填写。

安卓项目中的“启动类”所处文件的包名填写要尽量复杂，建议最少使用两个小数点，防止和其它第三方软件冲突，因为包名冲突后安卓程序会出现无法正常安装的情况。

例如：腾讯QQ的包名为“com.tencent.mobileqq”，则你的软件程序不能使用此包名作为你的程序包名，因为腾讯QQ已经使用。

2、注释

火山的注释有以下几种形式：

2.1 以双斜杠“//”字符串引导，说明其处于被注释状态，其以及其中的所有内容(包括直接/间接子成员)在编译时都将被忽略。

2.2 在类外部的程序行，被称为文档注释行。文档注释行的添加，只需要光标定位类名一栏，然后按键盘上的“ins/insert”键就可以插入文档注释行，部分电脑需要按下组合键“Fn+ins”键才可以插入。

2.3 在类内部但是在类方法外部的程序行，被称为类注释行。类注释行的添加同文档注释行一致，光标定位方法名按“ins”键即可。

2.4 在火山代码表格的备注栏输入，也属于注释文本，此注释文本可以在火山代码中被悬浮提示。除了类备注外，方法/变量/常量等备注信息都可以通过提示框显示出来。

2.5 在注释文本中如果以一个或多个减号/等号字符结束，火山将会自动在其后绘制对应长度的单/双分隔线，如下图所示：

3、类

3.1 类的构成

类名为“单名称”，用作定义一个可以具有各种子成员的复合数据类型，各个子成员如下：

(1) 类名。

(2) 类注释行。

(3) 类嵌入行(普通用户无需掌握)。

(4) 成员变量。

(5) 成员常量。

(6) 方法(通常方法/属性读或写方法/事件定义或接收方法/虚拟方法)。

3.2 启动类的定义

“启动类”的类被用作指定用户程序的启动入口类，用户程序将从此处开始执行，启动类在整个用户程序中只能存在一个，并且不允许修改其名称。

不同火山程序的启动类的样式不同，并不是固定的，是由新建项目时模板程序自动生成的，如下所示：

(1) 创建火山视窗“MFC窗口程序”项目时：

会自动生成“启动类”和对应的“主窗口”类，用于视窗程序的启动。

(2) 在创建火山安卓“空窗口”项目时：

会自动生成“启动类”用于安卓程序的启动。

3.3 自定义类

自定义类可使用“ctrl+D”快捷键进行定义，或者鼠标右键选择“插入->插入新类”进行定义类操作。

3.4 注意事项

(1) 同一个包中不允许出现相同的类名，如下图所示是错误的。

同项目下，只要包名一致不同文件下也不允许类名重复，如下图所示的写法是错误的。

(2) 类名为“单名称”(即其中不允许使用小数点)，如下图所示是错误的。

(3) 引用类名时可以直接使用类名称，或者使用“包名.类名”进行引用，此格式被称为类的“全名称”。

注意：如果调用其它火山源文件的类，注意观察两个源文件包名是否一致，如果不一致要注意公开类才可以被访问到。

(4) 在需要访问类实例对象的成员时，在类对象实例名称和欲访问的子成员名称之间使用小数点分隔即可，前面指定具体访问哪一个对象实例，后面指定访问这个对象实例的具体哪个子成员。

如下图所示：分别访问了“测试类”的实例对象“测试”的“测试变量”和“测试类方法”两个子成员。

3.5 基本属性表

(1) 基础类

指定本类的基础类名称，可以是“单名称/全名称”，也可以是空文本(表示无基础类)。

如果定义了非空基础类，当前类将自动继承所有来自该基础类的内容，如果该基础类还有基础类，将一并继承过来，此时本类称为这些类的“继承类”。

注: 有一些编程语言也称“继承类”为“子类”，“基础类”为“父类”，意思是一样的。

继承类访问其直接/间接基础类中的成员不需要其为公开状态。

(2) 公开

指定本类是否对外公开。

公开类可以在所处包外部被访问，而非公开类只能在所处包内部被访问。

如下图所示：文件1的包名和文件2的包名不一致，文件1想要使用文件2中的类，必须公开文件2中的类。

而文件2中未公开的类，只能在“火山.软件”的包中使用。

4、变量

4.1 什么是变量？

变量相当于一个容器，可以随意的将任何数据放进去并且取出来。如一个杯子，可以在杯子中放任何口味的饮品，甚至也可以泡茶喝。只是变量中存放的是可变的数据。

变量的名称为“单名称”，首字符不能为数字且不能使用任何标点符号（“_”下划线字符除外）。

4.2 变量的定义

变量的定义可通过组合快捷键“Ctrl+L”进行创建，或者使用右键菜单中的“插入->插入新成员/局部变量”来进行定义变量操作。

在类中插入的变量为成员变量，在方法中插入的变量为局部变量。

定义变量后输入名称并在“类型”一栏填写自己需要的类型即可。

如下图所示，在测试类中定义了一个类型为“整数”的“成员变量1”。

如果想要新增变量还可以在已有变量的基础上，按“Enter”(回车键)增加新的变量。

4.3 变量的分类

变量有几种类型，每种类型都有不同的作用，并且变量存在作用域，并不是随意定义一个变量就可以在程序的任意位置被访问到。

根据作用范围的不同，变量可以分为“成员变量”和“局部变量”。

如下图所示：

“成员变量”位于类的子语句体内并且可以看到和方法语句位于同级。而“局部变量”只能位于方法的子语句体内。

4.3.1 成员变量

成员变量可以在当前类的所有非静态方法中调用，如果某个方法勾选了静态将不能使用这个非静态变量。

如果想要在静态方法中使用这个变量，必须也将变量设置为静态变量才可以。

如下图所示：当成员变量被勾选静态后，静态方法内输入“cyb”可以正常的提示“成员变量1”证明可以被正常使用。

4.3.2 局部变量

局部变量只能在当前方法中被调用，其它方法无法使用，并且只能在变量定义表下方被使用。

如下图所示，定义的两个局部变量只能在变量定义表下调用。

温馨提示：局部变量只有在当前方法被调用的时候才会去向系统申请内存，当方法执行结束后，变量会被系统回收释放，因此局部变量是非常节省系统内存的。建议在程序开发过程中，能使用局部变量的就不要去定义成员变量。

变量根据属性不同，还可以分为“公开变量”、“静态变量”和“参考变量”。

4.3.3 公开变量

当变量公开后可以被其它类访问。

注：仅针对成员变量，局部变量无此属性。

而非公开变量只能在本类或者其继承类中访问。

4.3.4 静态变量

静态变量即勾选“静态”后的变量称为静态变量，静态变量又分为成员静态变量和局部静态变量。

如下图所示：

成员静态变量有以下特点：

(1) 静态变量在所处类载入后即保持始终存在，并且未存放在类的对象实例中，而只存放在类信息本身中，所以无论定义多少类对象实例，静态成员变量都只存在一份。

(2) 由于静态成员变量存放在类本身中，所以在其所处类/继承类外部需要以“所处类名.静态成员变量名”的方式访问。

利用成员静态变量的特点可以实现类似全局变量的效果，如下图所示，定义了一个成员静态变量后在其它任何类中都可以访问。

如下图所示，如果定义了“测试类”的实例变量去访问“成员静态变量”，虽然代码能被编译器接受但是会提示警告信息，并且火山编译器会自动替换成对应的类去访问。

除此之外，无论定义了几个“测试类”的对象变量，“测试类”的“静态成员变量”始终只存在一份，因此黄色箭头指向的代码所访问的“静态成员变量”，实际上都是同一个。

(3) 由于静态变量初始化时不存在所处类实例对象，因此所静态的变量如果存在“事件方法”将不会自动挂接其事件到其所处类，需要在必要的时候通过“挂接事件()”方法手动挂接事件。

如下图所示，假设“测试类”中存在事件方法，如果想要触发事件，需要通过“挂接事件()”方法手动挂接事件。

4.3.5 参考变量

注意：在火山视窗平台中不支持参考变量，勾选参考后将会如下图所示。

因此所有关于参考变量的介绍全部是基于火山安卓平台展开。

(1) 什么是参考变量？

想要了解什么是参考变量，首先要清楚什么是对象实例，定义一个变量即可理解为创建了这个类的对象实例，勾选参考后等于取消了对这个对象实例的创建。

用更加通俗的解释来说，比如手机中的联系人就相当于“对象实例”，而联系人条目就相当于“参考变量”。

(2) 参考变量的特点

参考变量不会创建对象实例，而是用作保存到其它对象实例的指向性信息(即参考)，如果想要访问参考变量中的数据，必须首先赋值（创建其对象实例）。

例如：通过手机联系人条目(参考变量)是无法进行拨打电话(访问对象数据)操作的，必须获取到联系人条目中存储的电话号码(创建对象实例)才能进行拨打电话操作。

如下图所示，“对象2”因为是参考变量因此不能直接访问其中的方法，必须进行赋值操作后才可以访问。

需要注意的是，对象之间的赋值必须保证数据类型一致，或者被赋值的对象是赋值对象的继承类。

如下图所示，因为“类2”是“类1”的继承类，因此即使是数据类型不同的情况下也可以进行赋值操作。

(3) 对象实例的获取办法

1. 如上述“参考变量的特点”中所示的直接赋值形式。

2. 通过所提供的类方法创建：

例如：在安卓类库中的“屏幕度量信息类”声明了属性禁止创建对象，如果遇到这种类在定义变量的时候就需要勾选参考。

如果不勾选参考直接使用，编译器会报错，如果在日常开发过程中遇到类似的错误，就证明定义的变量需要勾选参考。

如果指定类不允许非参考变量，通常在此类中都有相关的创建实例对象的方法，例如：屏幕度量信息类中就有“获取()”方法，可用于获取屏幕度量信息类的对象实例。

屏幕度量信息类的正确使用方式如下所示：

总结: 如果某个类指定了不能直接定义其对象实例变量，那么肯定可以通过调用某个方法获得其对象实例。绝大多数情况下该方法由此类自行提供，名称中一般包括“创建/从XX创建/新建/获取”之类的字样，并且该方法一般为静态方法。

如下图所示为创建“可绘制对象类”的实例方法：

如下图所示“可绘制对象类”的用法：

3. 常见错误：

(1) 被遗漏的参考属性：

在日常开发过程中，自定义的类实例对象进行赋值操作时，不勾选参考编译器也不会报错，也可以正常编译通过。

但是这样的用法会导致编译器重复创建对象实例，从而导致程序执行效率降低，占用不必要的内存空间。

所以在进行对象赋值操作时，即便编译器没有报错也要检查是设置了“参考”属性。

注意：整数、小数等基本数据类型不需要勾选参考。

(2) 使用了空参考变量：

如下图所示，虽然对“局部变量”进行了赋值操作，但是依然是错误的写法，因为“成员变量”也是参考变量，必须保证“成员变量”是非参考变量才可以进行如下操作。

如果你不确定“成员变量”是否拥有实例对象，可以通过如下图所示的方法进行操作，避免程序出现闪退等异常问题。

4.4 变量的初始值

变量的初始值设置大致分为以下三种类型，“基本数据类型”、“类数据类型”和“数组数据类型”，每种类型的初始值都是不同的。

4.4.1 基本数据类型变量

在基本数据类型中，数值型(整数/小数/长整数/短整数)变量的初始值为0，逻辑型变量的初始值为假，文本型变量的初始值为""(即空文本)

如果不想使用默认初始值，也可以如下图所示在表格中设置初始值或者通过代码设置初始值。

变量初始值的设置除了直接使用立即数外，还可以使用“类名.常量名”进行设置。

使用“类名.常量名”，优点是便于记忆防止输入错误。

如果常量在当前类中，也可以省略类名直接输入常量名字，如下图所示：

如果要设置的文本型数据为多行文本，可以打开“初始值编辑器”设置内容。

在打开的初始值编辑器中输入想要设置的内容即可。

安卓平台将自动生成“\n”换行符。

视窗平台将自动生成“\r\n”对文本数据进行换行。

4.4.2 类数据类型变量

(1) 对于类数据类型的变量，除资源类外其它任何类数据类型都不支持在初始化表格中设置初始数据。

对于火山平台中的资源类型，设置的初始值最终会被火山编译器处理打包到软件程序内部。

注：火山中所引用的外部资源，火山源文件只是引用其文件路径，因此外部文件不能删除，删除后将无法正常编译通过。当程序编译完成后，引用的文件会打包到程序内部，因此不会再依赖引用的外部文件。

火山安卓平台资源类型演示：

火山视窗平台资源类型演示：

(2) 对于火山安卓平台，参考变量其默认值为空对象，非参考变量则为对应的对象实例。

(3) 对于火山视窗平台，由于不支持定义参考型数据，因此所有非基本数据类型变量均为对应的对象。

4.4.3 数组类型变量

(1) 基本数据类型数组的初始值如下所示，大括号开始大括号结束的形式，每个成员之间用英文的逗号分隔。

(2) 如果基本数据类型数组未指定初始值，但指定了成员数(如下图所示)，则数值型数组变量的每个成员初始值为0，逻辑型数组变量的每个成员初始值为假。

(3) 其它所有数据类型(包括文本型)数组变量的每个成员初始值：如果为火山安卓平台则为空对象，为火山视窗平台则为对应的对象实例。

因此在火山安卓平台中，对于非数值和逻辑型的数组，其每个成员在使用前必须首先被单独赋值，如:

5、常量

5.1 什么是常量？

常量和变量一样，都是存放数据的容器，不同之处如下：

(1) 常量只能在定义时被赋予初始值，不能在程序运行后进行修改，如下图所示的写法是错误的。

(2) 常量设置初始值时，只能提供立即数，如下图所示提供一个其它常量作为初始值是错误的。

(3) 常量的数据类型只能为基本数据类型或资源数据类型（例如：安卓中的可绘制资源，视窗中的视窗文件资源）。

(4) 常量的“静态”固定为真不可修改，即:常量并未存放在类的对象实例中，而只存放在类信息本身中，所以无论定义多少类对象实例，常量都只存在一份。因此常量的访问方式与静态成员变量的访问方式是一样的，在其所处类/继承类外部需要以“所处类名.常量名”的方式访问，如下图所示：

5.2 常量的定义

常量的定义可通过组合快捷键“Ctrl+B”进行创建，或者使用右键菜单中的“插入->插入新常量”来进行定义常量操作。

在类中插入的常量为成员常量，在方法中插入的常量为局部常量。

定义常量后输入名称并在“类型”一栏填写自己需要的类型即可。

如下图所示，在常量类中定义了一个类型为“整数”的“成员常量1”。

如果想要新增常量还可以在已有常量的基础上，按“Enter”(回车键)增加新的常量。

5.3 常量的分类

常量和变量一样都存在作用域，根据作用范围的不同，可以分为“成员常量”和“局部常量”。

如下图所示：

“成员常量”位于类的子语句体内并且可以看到和方法语句位于同级。而“局部常量”只能位于方法的子语句体内。

5.3.1 成员常量

成员常量可以在当前类的所有方法中调用，包括静态方法。

5.3.2 局部常量

局部常量只能在当前方法中被调用，其它方法无法使用，并且只能在常量定义表下方被使用。

如下图所示，定义的两个局部常量只能在常量定义表下调用。

5.3.3 公开常量

当常量公开后可以被其它类访问。

注：仅针对成员常量，局部常量无此属性。

而非公开常量只能在本类或者其继承类中访问。

5.4 常量的初始值

常量的初始值设置大致分为以下两个类型，“基本数据类型”和“资源数据类型”。

在基本数据类型中，直接在“初始值”一栏提供对应的数据类型即可，如下所示：

如果为资源数据类型，需要提供对应资源的立即数，火山平台会自动处理所引用的资源数据。

如下图所示，火山视窗平台中的“视窗文件资源”需要提供一个文本型的文件相对路径或绝对路径，可直接在初始值输入或者通过下拉按钮浏览选择。

如下图所示，火山安卓平台中的“可绘制资源”也需要提供一个文件路径的立即数。

如果要设置的文本型数据为多行文本，和变量一样设置初始值一样，也可以打开“初始值编辑器”设置内容。

在打开的初始值编辑器中输入想要设置的内容即可。

安卓平台将自动生成“\n”换行符。

视窗平台将自动生成“\r\n”对文本进行换行。

如果常量是数组类型，其数组符号内可以提供成员数也可以不提供，需要注意的是如果提供了成员数则务必保证初始值设置的数量和提供的成员数一致。

6、方法

6.1 什么是方法？

一个完整的程序中可能有成千上万个类，每个类中可能有成千上万个语句，为了方便程序编写和设计，火山将程序的类分割成一个一个较小的单元，这些单元被称为“方法”。

方法可以用作一系列命令的封装，可以让复杂的代码简单化，提高代码复用性、可读性，更加有利于程序的模块化开发。

(1) 方法的定义

火山方法的定义可以使用“Ctrl+M”快捷键进行创建，或者使用右键菜单“插入 -> 插入新方法”进行定义。

(2) 方法的分类

在火山中方法根据用途的不同，分成以下几类：

1. 通常方法

2. 静态方法

3. 支持以动态格式调用的静态方法

4. 属性方法

5. 事件方法

6. 全局静态方法

7. 虚拟方法

除了以上类型外，火山中还存在两个固定方法“类_初始化”和“类_清理”，用于对象的初始化和清理数据操作。

类_初始化方法

此方法会在类对象被创建时自动调用，该方法不携带任何参数并且不返回值，对是否需要公开没有任何要求，如下图所示：

如果你想在对象被创建的时候初始化一些数据，可以在此方法下操作,如下图所示：

类_清理方法

此方法会在类对象被销毁时自动调用，该方法不携带任何参数并且不返回值，对是否需要公开没有任何要求。

注意：本方法在火山安卓平台中不被支持，因此下面演示火山视窗平台。

如果你想在对象被销毁的时候清理一些数据，可以在此方法下操作,如下图所示：

提示: “类_初始化”和“类_清理”方法在火山中可以通过按下“Ctrl+I”组合键调用对应对话框自动插入对应空方法，或者直接使用“Ctrl+M”新建方法后手动填写方法名。

(3) 注意事项

注意：在同一个类中方法名称不允许重复，如下图所示是错误的。

但是有一个情况是例外的，读写属性方法名可以重复，但是也只能重复一次，如下图所示：

6.2 定义通常方法

如下图所示，即表示定义了一个通常方法：

新建一个类，在类中新建一个方法，并且方法的类别选择“通常”，所定义出来的方法就叫通常方法。

调用通常方法代码如下图：

1. 在外部其他类中调用这个方法首先需要公开此方法。

2. 调用方法的时候需要定义变量，例如：在窗口被首次激活的时候定义“测试类”变量并调用这个方法。

运行结果如下图：

最终按下F5键当程序窗口出现后，会显示一个信息框，证明通常方法被调用成功。

6.3 方法的参数与数据传递

在火山平台中所有方法类型都可以添加多个参数，进行数据的传递操作。

注：读属性方法不支持填写参数，写属性方法可提供一个参数。

6.3.1 参数的添加

光标定位“返回值类型”一栏，按下“Enter”(回车键)即可实现参数的添加。

也可以右键菜单“插入 -> 插入新参数”或使用组合快捷键“Ctrl+R”进行添加参数。

6.3.2 参数的结构

如下图示，参数结构为参数名、类型、属性名、属性值和备注信息。

其中“参数名”和“类型”为必填项，属性和备注可根据自己的需求决定是否填写。

6.3.3 参数的数据传递

在火山中的参数的数据传递大致以下几种方式：

(1) 立即数值传递；

(2) 对象传递；

(3) 文本型的参考传递

1. 立即数值传递

代码编写如下图：

(1) 给通常方法增加两个参数，并将两个参数进行结合起来显示在信息框中。

(2) 在主窗口被创建完毕后，调用此方法并传递两个文本立即数过去。

运行效果如下图：

最终可看到两个提供的文本立即数被结合起来显示在了信息框中，证明参数传递成功。

这就是立即数值的数据传递，传递后直接使用即可。

2. 对象传递

代码编写如下图：

(1) 首先定义一个“测试类”，用来模拟一个对象数据。

(2) 定义一个通常方法，插入一个测试类参数，并在方法中取出参数数据。

(3) 在窗口创建完毕后调用这个通常方法，实现对象数据传递。

运行效果如下图：

最终可以看到信息框中会显示对象中存储的文本数据，证明对象数据传递成功。

当使用对象传递数据时，会自动进行参考传递，即参数会拥有原数据的内存地址，从而可以通过参数来返回数据。对象的参考传递在火山安卓和火山视窗中均适用。

如下图所示：

(1) 在通常方法中修改参数数据。

(2) 在窗口创建完毕下，调用通常方法传递测试类对象，并在此方法后取出对象中的数据。

运行效果如下图：

最终可以看到信息框中会显示参数设置的数据，证明数据传递成功。

3. 文本型的参考传递

在火山视窗平台中除文本型外，其它基本数据类型都不支持参考传递。

注：在火山安卓平台中，所有基本数据类型都不支持参考传递。

下面来演示一下文本型的参考传递，代码编写如下图：

(1) 在通常方法中修改文本型参数数据。

(2) 在窗口创建完毕下，定义一个文本型变量，经过参数传递后，取出变量中的数据。

运行效果如下图：

最终可以看到信息框中会显示经过参数修改的数据，证明文本型可以进行参考传递。

6.3.4 参数的默认值属性

提供了“@默认值”属性后，证明此参数可以在调用的时候被省略，火山会自动处理“属性值”为参数数据进行传递。

注意：如果参数类型为实例对象，则“@默认值”属性的属性值只能为“空对象”。

代码编写如下图：

1. 给通常方法增加两个参数，并将两个参数进行结合起来显示在信息框中，给其中一个参数设置默认值。

2. 在主窗口被激活后，调用此方法忽略“参数1”只给“参数2”传递文本数据。

运行效果如下图：

最终可看到“默认值”也显示在了信息框中，证明默认值设置成功。

6.4 方法的返回值

方法是一个独立完成某个功能的程序块，在需要返回值的时候可以提供返回值进行操作，如果不需要也可以不提供。

如果方法需要返回值，则需要在方法的“返回值类型”一栏进行填写即可，如下图所示返回一个整数类型。

如果该方法提供了返回值类型，则必须使用“返回()”方法返回对应的类型数据。

如下图所示，返回值类型为整数，就必须返回一个整数类型，可以提供变量，常量或者立即数，只要是整数类型就可以。

不提供返回值或者返回值类型不匹配都是错误的，如下图：

返回值是对象则需要返回对应对象实例，如下图：

如下图所示，如果返回值为父类，则可以提供对应的子类实例对象。

6.5 方法的嵌套调用

方法与方法之间的交互是通过参数和返回值来联系的，一个方法可以有多个参数，参数值除了提供变量、常量、立即数外，如果指定方法有返回值并且和方法参数类型匹配也可以把方法作为参数写入。

如下图所示：

运行结果如下图：

6.6 方法的递归调用

方法的调用一般情况下都是一个方法调用另外一个方法，如果方法自己调用自己这种情况被称为递归调用，又称递归算法。需要注意的是，使用递归算法时，必须要保证有一个结束条件，否则会陷入死循环中，导致程序卡死闪退等问题。

例如：数学运算中的求阶乘问题就可以利用递归算法实现，下面来实现一个简单的求阶乘的递归算法。

(1) 定义一个求阶乘的方法，提供一个要计算阶乘的正整数参数以及长整数返回值。

(2) 在方法的语句内首先对参数进行判断是否大于0，满足条件后在进行递归调用，否则程序会陷入死循环导致软件异常卡死等问题。

(3) 满足条件后进行乘法计算，乘数为方法参数，被乘数为方法本身，这样就满足了递归调用。

(4) 如果没有满足条件就让方法返回1，方便最后与正整数参数相乘得出最终结果。

在窗口被首次激活时调用一下这个方法，来计算一下5的阶乘。

最终成功拿到了计算结果，以上就是一个简单的递归算法实现的全部过程。

6.7 定义静态方法

(1) 静态方法与通常方法的区别在于，设置静态方法后，可以省去定义变量取调用方法的步骤，静态方法只需要通过“类名+方法名”的形式就可以调用。

如下图所示：

凡是勾选静态的方法，都可以称呼为静态方法。

(2) 在静态方法内部，只能访问其所处类或者其所处类的基础类中的成员常量或者静态成员变量。

如下图所示：

6.8 定义 支持以动态格式调用的静态方法

本方法其实也是静态方法的一种，如果静态方法所定义的第一个参数是类本身，那么这样的方法就可以称为是“支持以动态格式调用的静态方法”。

本方法有两种调用形式，既可以通过类名去访问这个方法，又可以定义变量访问这个方法。

如下图所示：

在“测试类”中定义了一个名为“动态方法”的静态方法，第一个参数提供了“测试类”自身，那么在程序中调用这个方法时，就会有两种形式。

(1) 第一种方式是标准的静态方法访问方式。

(2) 第二种就是优化后的方式，其第一个参数被移动到方法访问对象上，这种方式在编译时将被自动转换为第一种方式。

6.9 定义属性

在火山中的属性大致分为三个类别：可读属性，可写属性，可读写属性。可读写属性又分为方法属性和变量属性。

6.9.1 定义可读属性

读属性用于读取当前类中的某些数据值进行返回，其格式必须满足以下条件：

(1) 插入的方法必须公开，且类别需要选择“属性读”。

(2) 不能为静态方法(实际上静态方法也可以用作定义属性，通常情况下用不到，知道即可)。

(3) 不可以提供参数。

(4) 必须提供一个返回值。

如下图所示，在“测试类”中定义了一个返回值为“文本型”的读属性方法，并返回了一个成员变量。

需要注意的是“属性读”虽然是以方法的形式定义，但是在调用这个属性的时候不能使用“变量1.属性读()”的形式访问，正确的访问如下图所示，不需要提供括号。

6.9.2 定义可写属性

写属性用于设置当前类中的某些数据，其格式必须满足以下条件：

(1) 插入的方法必须公开，且类别需要选择“属性写”。

(2) 不能为静态方法(实际上静态方法也可以用作定义属性，普通用户无需掌握，知道即可)。

(3) 必须提供一个参数，提供的这个参数被称为属性值。

(4) 不允许提供返回值。

如下图所示，在“测试类”中定义了一个属性值为“文本型”的写属性方法，并将属性值赋值给了一个成员变量。

虽然“属性写”也是以方法来定义，但是在调用这个属性的时候不能使用“变量1.属性写()”的形式访问，正确的访问如下图所示，属性名和属性值之间用等于号连接。

除上述访问方式外，写属性还可以直接在属性表中访问，如下图所示：

写属性除了直接提供对应值外还支持备选列表，通过备选列表设置常用属性值。

视窗平台设置如下图所示，在方法的属性栏使用“@列表选择项”属性值可打开编辑器进行设置。

多条备选值用换行分隔，如果属性值为文本型注意需要提供英文状态下的双引号。

最终设置完成后如下所示，会自动添加\r\n换行，双引号也会自动转义。

如果在安卓平台下，设置完成后会自动使用\n分隔。

无论是安卓还是视窗，最终在使用时效果是一样的，可以通过下拉列表选择属性值，如下图所示：

属性表中的备选列表，除了上述的备选列表形式外，还支持“常量类”形式的备选列表。

“常量类”与“@列表选择项”不同之处在于，常量类的内容是固定的，一旦设置常量类将不支持自定义内容（只能去常量类扩充，但软件需要重新编译），而“@列表选择项”不受此限制。

常量类的定义如下图所示：

注：当前类设置“@常量类”属性后，当前类中只能提供常量，不可以提供变量、方法。

常量类的使用：

(1) 写属性中使用常量类也很简单，首先需要将参数类型设置成对应的常量类的类名。

(2) 然后通过参数名来判断是否为指定常量，从而进行相应的代码操作。

(3) 调用本属性的时候就可以在属性栏下拉选择，如果通过代码设置就需要通过“类名+常量名”的形式设置。

6.9.1 定义可读写属性

可读写属性分为“方法读写属性”和“变量读写属性”，这两个的不同之处在于，方法属性可以在方法中编写代码，对属性值进行一些其它操作，而变量属性不支持。

(1) 方法读写属性

方法读写属性其实就是将“属性写”和“属性读”两个方法配合使用，从而实现同一个属性名既可以读又可以写的效果。

如下图所示，当读写属性配套使用时，方法名可以一致。

注意：读写属性配套使用时，两者的名称必须完全一致，而且读属性方法的返回值数据类型必须与写属性方法的参数数据类型一致，如下图所示的写法是错误的：

只要读写属性按照规范编写，就可以如下图所示进行调用：

(1) 在窗口被首次激活时定义“测试类”变量。

(2) 定义后就可以在属性表中调用“属性方法”写属性用于设置属性值。

(3) 写属性设置后就可以通过同名读属性取出设置的属性值。

当程序运行后，设置的属性内容可以被成功读取。

(2) 变量属性

变量属性即通过成员变量来当属性使用，如下图所示，只要在成员变量的属性表中设置“@属性变量”属性值设置为“真”，就可以在此类变量的属性表中使用这个成员变量设置数据。

当程序运行后，设置的属性内容可以被成功读取。

6.10 定义事件方法

事件方法是用来对外发送通知时使用。

例如：用作“按钮”的类在用户单击按钮时会向外部发送“被单击”事件，用作“时钟”的类会向外部定时发送“时钟周期”事件等等。

6.10.1 定义事件需要满足以下条件：

(1) 插入的方法“类别”必须设置为“定义事件”。

(2) 访问权限必须为公开。

(3) 不允许设置静态。

(4) 必须填写返回值，并且返回值只能是整数。

(5) 方法内不允许有任何代码。

(6) 事件方法的参数没有要求，根据自己的需求决定是否提供。

如下图所示，在“测试类”中定义了一个名为“测试事件”的事件。因为事件不能平白无故触发，必须要有一个条件，因此这里还定义了一个“触发事件”的通常方法来调用这个事件。

6.10.2 自定义事件的调用与触发：

以火山视窗为例，在窗口类中定义“测试类”的成员变量，光标定位“类型”会出现一个小按钮，点击可出现事件列表选择后可添加添加“测试事件”的事件接收方法。

如下图所示，为对应“接收事件”添加完成后的效果。

当然也可以通过手动插入方法实现“接收事件”方法，只要满足以下要求：

(1) 方法名必须为“类名_事件方法名字”。

(2) 类别选择“接收事件”。

(3) 方法不允许设置静态。

(4) 返回值类型固定为整数

(5) 方法的第一个参数必须为固定的“来源对象”参数，其数据类型为发送事件的类，用作提供具体是哪个对象发送过来的事件。

(6) 方法的第二个参数必须为固定的“标记值”参数，其数据类型为整数，用作动态挂接事件时使用。

(7) 方法后续的参数表必须和“事件定义方法”的参数表一致，用于获取传递过来的参数数据。

(8) 最后方法的返回值将被传递回在事件定义方法所处类中调用该事件定义方法的调用方（如上述6.10.1 所示，会传递给“触发事件”方法中的“测试事件”的调用方）。

事件都是存在触发条件的，因此还需要如下图所示，手动调用“变量1.触发事件()”方法，才会触发“测试类_测试事件”方法。

需要注意的是，由于同一类的同一事件均被发送到同一个事件接收方法，因此需要使用“来源对象”和“标记值”两个参数进行区分。

如下：利用“来源对象”参数来区分事件。

通过“标记值”参数判断通常用于，对象是局部变量的情况，不过因在火山视窗中局部变量用完会立刻释放导致事件无法触发，因此在火山视窗中如果该对象存在事件则不建议设置为局部变量。

如下所示为火山安卓平台中，利用“标记值”来区分事件来源，需要使用“挂接事件()”方法。

6.11 定义全局静态方法

所谓全局静态方法就是，此方法调用的时候不需要输入类名，也不用定义类变量，直接输入方法名即可调用，并且可以无视包名，可以随意的跨包调用。

定义方法如下图所示：

(1) 在方法所处类的属性栏设置“@全局类”，属性值设置为“真”。

(2) 插入的方法需要同时勾选公开和静态，对于返回值类型和参数表没有特殊要求，根据自己的需求填写即可。

定义完成后，就可以在火山程序的任何方法下调用（定义事件方法除外），如下图所示：

6.12 定义虚拟方法

6.12.1 什么是虚拟方法？

如果在火山中，某个类中的某个方法不能满足使用需求，但是我们又不想重新定义一个方法来操作，这个时候就可以利用火山的“虚拟方法”来实现对这个方法进行重写，这样的重写操作在火山中就称为虚拟方法。

例如：一家销售公司每个人都有底薪2000元，每个人的业绩不同提成也不同最终得到的工资也不是不同的。那么这个底薪2000元就可以理解为是虚拟方法，员工A和员工B的提成不同，只需要重写这个2000元底薪加上各自的销售业绩就是实际工资，不需要额外建立员工A方法和员工B方法来单独计算。

6.12.2 虚拟方法的定义和调用

(1) 虚拟方法的定义

定义虚拟方法很简单，只需要在一个通常方法的属性名上填写“@虚拟方法”属性值提供“可覆盖”即可。

(2) 虚拟方法的调用

光标定位类名会出现一个按钮，点击可添加基础类的虚拟方法。

添加完成后如下图所示：

6.12.3 虚拟方法实例

下面以火山视窗为例实现一个简单的虚拟方法的实际应用案例：

(1) 假设有一家销售公司，他们公司的工资都是底薪+提成的形式，因此可以首先定义一个“基本工资类”并新增一个虚拟方法，将实际工资计算出来并返回。

(2) 但是某些员工是新员工，假设为“员工A”，他的工资需要在原薪资的结构上单独计算，因此需要继承一下“基本工资类”并添加“基本工资”虚拟方法。

(3) 假设财务忘记扣税，那么此时可以在此方法下重写本方法进行扣税，并返回扣税后的薪资。也可以进行其它操作，譬如员工迟到从提成里面扣除一些工资，这个就需要根据自己的需求来编写代码。

(4) 假设有一个十年的老员工，为“员工B”，老员工的提成为双倍提成，就可以在“基本工资”的虚拟方法下重写工资计算公式。

(5) 最后在窗口中插入一个“工资计算”方法用于计算最终工资，参数提供“基本工资类”和“提成”，并返回实际工资。

(6) 在主窗口创建完毕事件下，对员工A、B的工资进行计算，因为“员工A、B”都继承了基本工资类，因此其对象实例可以填写到“工资计算”方法中。

(7) 最终可以得出两个员工的真正工资。

员工A的实际工资为：1000(底薪) + 100(提成)-100(税) = 1000元

员工B的实际工资为：1000(底薪) + 100*2(提成) - 100(税) = 1100元

以上就是火山视窗中虚拟方法的实际应用案例，安卓虚拟方法例程下载，视窗虚拟方法例程下载

7、方法语句

7.1 表达式语句

在火山中所有的非嵌入式语句都可以称为表达式语句，表达式语句只能在方法中使用，用作提供具体方法的实现代码。

表达式由使用操作符组合在一起的语句单元组成，分为以下几类:

(1) 一元表达式，如: -变量1 、 (长整数)1

(2) 二元或多元表达式，如: 变量1 + 变量2、 变量1 * 123 * 变量2

(3) 命令或方法调用表达式，如: 方法1 (123)、 如果 (变量1)

(4) 表达式可以嵌套，如: -(变量1 + 变量2)、 如果 (方法1(变量1) == 真)

表达式中的语句单元可以是: 数据类型/变量/常量/参数/方法/名称类关键字/立即数等。

注意：在火山中的代码语句生成的线条只是样式，并非流程线，火山程序中只有子语句体的，即:

(1) 任何程序语句都可以拥有一条或多条下属语句，这些下属语句称为该语句的子语句体，该语句称为这些下属语句的父语句。

(2) 子语句体可以嵌套，也就是说子语句可以继续拥有子语句体。

如图:

语句行12-16是语句行11的子语句体;

语句行15-16是语句行14的子语句体;

语句行19-26是语句行18的子语句体;

语句行22-23是语句行21的子语句体;

语句行25-26是语句行24的子语句体.

在使用虚线标注子语句体的时候，系统对“如果”和“否则”语句进行了特殊处理，将两者的子语句体线连接起来了，这样看起来结构更清晰一些。

7.2 嵌入式语句

在火山视窗中以@字符开始嵌入的C++代码被称为嵌入式语句，详见视窗程序结构展示

在火山安卓中以@字符开始嵌入的java代码被称为嵌入式语句，详见安卓程序结构展示


火山软件中的符号介绍_火山平台语法手册

四、火山软件开发平台中的符号介绍

1、操作符

1.1 点

点即〝 . 〞此符号有两个作用，一是用于建立包/类的全名称，二是用来作为分隔类/类对象与其成员名称。

如下图所示：

在输入句点时会激活火山代码提示，可以更方便的访问其成员名称。

1.2 方法符小括号

方法符即〝 ( ) 〞 ，必须是英文状态下的小括号。其作用是提供调用方法时所需要的参数表。

注：无论方法是否有参数表，都需要输入括号，如下所示。

1.3 参数分隔符

参数分隔符即〝 , 〞，必须是英文状态下的逗号。本符号用于分隔参数表中的各个参数。

如下图所示：

“通常方法2”存在三个参数就需要输入两个逗号。

参数分隔符也是可以省略的，假如最后一个参数存在默认值，如果你不需要输入这个参数可以省略。

如下图所示：

“通常方法2”的第三个参数存在默认值，如果调用此方法时，不需要输入这个参数，可以省略一个逗号的输入。

需要注意的是，如果被调用的方法是“支持以动态格式调用的静态方法”，那么参数逗号数量则根据调用方式动态选择。

如下图所示：

通过变量调用需要输入三个参数，通过类名调用需要输入四个参数。

如果你不太确定到底需要输入几个逗号来分隔参数，可以如下图所示：

在方法中输入逗号时，注意观察参数名称的颜色变化，当参数名称颜色非白色时，证明当前要输入的参数为此参数，从而可以判定要输入几个逗号。

1.4 数组符号

数组符号即〝 [] 〞，用于表示数组类型。

数组：即相同数据类型变量的一个集合，访问数组内的成员变量时，需要使用“数组名[下标]”的方式。

如下图所示，表示一个整数数组变量：

下标：即数组成员索引，索引值从0开始，有效范围为从0到数组成员数-1，分别对应数组的第一个和最后一个成员。

如下图所示：

“数组变量[0]”最终值将为“1”，如果下标提供1则此数组变量的最终值将返回2，以此类推。

下标除了用于访问成员外还可以替换成员，如下所示：

数组符号中还可以提前设置数组成员数量，如下所示：

多维数组定义及赋值：

注：在火山视窗暂不支持参数和返回值使用数组。

1.5 注释符

注释符即〝 // 〞用于表达注释信息，注释后的代码在程序编译发布版时不会被编译到程序中。它可用于类名、变量、常量、方法名、参数和方法语句的注释。

如下图所示：

1.6 双引号

双引号即 〝 "" 〞 ，必须是英文状态下的双引号。用于表达字符串立即数，可用于变量、常量的初始值以及变量的赋值中。

如下图所示：

字符串立即数中也支持转义符操作。

1.7 单引号

单引号即 〝 '' 〞 ，用于表达字符立即数，可用于变量、常量的初始值以及变量的赋值中。

如下图所示：

字符立即数中支持转义符操作。

1.8 转义符

转义符即〝 \ 〞，用于转义文本操作，例如：“\r\n” 用来表示常见的那些不能显示的字符。

如下图所示：

字符串立即数表达需要使用英文状态下的双引号，如果需要在字符串立即数中表达同样的双引号文本就需要进行转义操作，便于程序编译器识别信息。

转义字符表：

转义符 | 解释
\b | 退格符
\f | 换页符
\r | 回车符
\n | 换行符
\t | 水平制表符
\' 单引号
\" 双引号
\\ 反斜杠
\x | 后跟1-3个十六进制字符,为所对应字符的代码值.

2、运算符

2.1 四则运算符

四则运算符即加(+)、减(-)、乘(*)、除(/)，这四个符号和数学运算一致，支持混合运算，并且也会按照数学运算规则：先算乘除后算加减，先算括号内后算括号外。

在火山平台中只要是数值类型的数据都可以进行运算。

如下所示：

最终结果：

在上述计算中，最终值应当为3 * 3 / 2 = 4.5，但是为什么显示为4呢？这是因为在火山平台中，其最终的计算结果数据类型由表达式中参与运算的各个数值的最大精度决定，譬如计算过程中所有数值均为整数，则最终结果值也将被剪切到整数(不管计算结果是否存在小数)，如果表达式中存在一个是小数类型，则最终结果值将为小数。

因此上述计算公式想要得到正确的结果，只需要将其中任意一个数值声明小数即可。

声明方式有两种分别如下：

可以直接将某个数值改成小数类型。

如果为整数变量，可以采取强制转换的方式，强制转换成小数。

最终正确结果如下：

对于加号符，除了进行数学运算外，还可以用于连接文本数据，如下所示：

最终结果：

注：除文本和数值类型数据外，其它类型均不支持相加。

2.2 取反运算符

算术取反操作符即〝 - 〞，用作返回将指定数值进行符号翻转后的结果值。

如下图所示：

2.3 强制类型转换符

强制类型转换符即〝 () 〞，用作将数据强行转换到所指定的数据类型。

调用格式为: (欲强行转换到的数据类型)欲转换类型的数据。

允许以下数据类型之间进行强制转换：

(1) “空对象”可以强制转换到任何非常量类的类数据类型或文本型：

(2) 数值数据类型之间可以强行转换。

注意: 当从容量大的数值数据类型强制转换到容量小的数值数据类型时，其中数值精度将会存在被丢失的风险。譬如，将小数数值强行转换到整数数值将丢失所有小数点后面的数值部分。

(3) 常量类可以强制转换到其所对应的基本数据类型(普通用户知道一下即可,无需过多了解)。

(4) 类数据类型只能强制转换到其直接/间接基础类或继承类。

注意: 用户必须确保对象实例的运行时数据类型匹配该被强行转换到的数据类型，否则将导致程序运行时出错。

2.4 求余运算符

求余运算符即〝 % 〞，用于用于取出一个数和另一个数相除的余数。

如下所示：5 % 4 = 1

2.5 关系运算符且

且即〝 && 〞，用于并且逻辑操作，当左侧参数和右侧参数均为逻辑值真时，最终整个表达式的结果返回真。

如下图所示：

上述例子的最终运行结果并不会执行信息框，因变量1不等于100并且变量2也不等于20。

输入字：

除了直接输入字符外，还可以输入“qie”来输入此符号。

2.6 关系运算符或

或即〝 || 〞，用于或者逻辑操作，当左侧参数或右侧参数其中任意一个的逻辑值为真，最终整个表达式的结果返回真。

如下图所示：

上述例子的最终运行结果并不会执行信息框，因变量1不等于100也不等于20。

输入字：

除了直接输入字符外，还可以输入“huo”来输入此符号。

2.7 关系运算符小于等于

小于等于即〝 <= 〞，当左侧参数小于等于右侧参数时返回真。

如下图所示：

上述例子的最终运行结果会执行信息框，因变量1默认值为0，满足小于等于100的条件。

2.8 关系运算符大于等于

大于等于即〝 >= 〞，当左侧参数大于等于右侧参数时返回真。

如下图所示：

上述例子的最终运行结果不会执行信息框，因变量1默认值为0，不满足大于等于100的条件。

2.9 关系运算符小于

小于即〝 < 〞，当左侧参数小于右侧参数时返回真。

如下图所示：

上述例子的最终运行结果会执行信息框，因变量1默认值为0，满足小于100的条件。

2.10 关系运算符大于

大于即〝 > 〞，当左侧参数大于右侧参数时返回真。

如下图所示：

上述例子的最终运行结果不会执行信息框，因变量1默认值为0，不满足大于100的条件。

2.11 关系运算符不等号

不等号即〝 != 〞，当左侧参数不等于右侧参数时返回真。

注意：

(1) 对于数组对象，唯一能够与其进行比较的是“空对象”；

(2) 对于文本数据，将比较两者实际文本内容是否相同(区分字母大小写)，也可以将文本数据与“空对象”进行比较；

(3) 类对象比较仅比较两者是否指向同一个对象实例，而不会去对比两者所指向对象实例中存放的数据内容是否相同(火山安卓平台比较两个对象是否参考到同一对象实例，火山视窗平台比较两个对象的所处内存地址是否相同)。

在火山视窗平台中：

(1) 如欲比较两个对象的数据内容是否相同，可以使用系统类库中所提供的“对象内容是否相同()”全局静态方法；

(2) “字节集类”是一个特例，该类的对象之间进行比较将比较两者的实际数据内容是否相同。

如下图所示：

2.12 关系运算符双等号

双等号即〝 == 〞，用于比较左侧参数与右侧参数是否相等。其使用方式和注意事项与“不等号”相同，将上述图中的“!=”换成“==”即可。

2.13 赋值运算符

赋值符即〝 = 〞，用于将右侧的参数值赋予给左侧参数内容，可用于变量、写属性等。

如下图所示：


火山软件基本数据类型介绍_火山平台语法手册

五、火山软件开发平台数据类型介绍

1、数据类型

1.1 了解数据类型

数据：是指能够输入到计算机中，并能够被计算机识别和加工处理的符号的集合，是程序处理的最小对象。如：数值、字符、图像和声音等都是数据。数据在程序中通常以变量或常量的方式被引用，不同的数据特点有不同的存储要求和处理方法。

在火山中数据类型可以分为两种：基本数据类型和对象类。

基本数据类型共有10种： 字节、 短整数、 整数、 长整数、 变整数、 小数、 逻辑型、 字符、 文本型、

其中字节、短整数、字符、整数、长整数、小数、变整数这七种类型又统称为数值数据类型。

数值数据类型按照所能容纳数值范围的大小(也称为精度)从小到大顺序排列为：字节 < 短整数 < 字符 < 整数 < 长整数 < 小数

注：精度小的数值类型在需要时可以被自动转换为精度大的数值类型，而精度大的数值类型必须使用“强制转换”操作符才能转换为精度小的数值类型。

如下图所示：

对象类：在火山中是所有类的最基础类(父类)。

1.2 数据类型的使用

1.2.1 使用方式

数据类型可以在类定义表的“基础类”中使用，也可以在变量、常量、参数定义表的“类型”中和方法中的“返回值类型”一栏中使用，如下图所示：

类型在填写时有以下注意事项：

1. 基础类中不允许提供基本数据类型。

2. 常量的类型只能为基本数据类型。

1.2.2 基本数据类型的输入字

在火山中基本数据类型除了使用全拼、首拼进行输入外，还提供了额外的输入字，如下所示：

字节：sbyte；

短整数：short；

字符：wchar；

整数：int；

变整数：vint；

长整数：long；

小数：double；

逻辑型：bool；

文本型：string。

如文本型的“string”输入“st”就可以将文本型提示出来。

2、基本数据类型

2.1 字节

字节(有符号)是二进制数据的单位，在火山中基本数据类型之一，有效值范围从-128到127，占用1个字节空间。

如下图所示写法是错误的：

如果按照上图所写进行调试程序，最终会在火山输出栏提示如下错误：

2.2 短整数

短整数用于表达较短的整数值，有效值范围从-32768到32767，占用2个字节空间。

如果想要让短整数转换成整数或长整数，直接赋值即可，如下图：

2.3 整数

整数的有效值范围从-2147483648到2147483647，占用4个字节空间。

整数是处理和存储效率最高的数值数据类型，如果所欲处理的数值不包含小数部分，一般都使用本数据类型。

如果想要让整数转换成短整数需要进行强制转换操作，需要注意整数值的范围是否在短整数的范围之内，如下图所示：

整数想要转换成长整数，直接赋值即可：

2.4 长整数

长整数有效值范围从-9223372036854775808到9223372036854775807，占用8个字节空间。

在软件开发过程中，如果数值超过了整数范围，那就必须使用长整数类型。如果在你不确定数值范围是否会超过整数，例如：两个较大整数的相乘，结果可以使用长整数类型来表达。

长整数转换成整数或短整数需要进行强制转换，且必须保证在目标类型的范围值之内，如下图所示：

2.5 变整数

变整数主要提供给火山视窗平台使用，在编译64位程序时等效于长整数类型，编译32位程序时等效于整数类型。在火山安卓平台中固定等效于整数类型。

通常用作表达地址指针或句柄之类的本地数据，普通用户一般无需使用。

如下图所示：

在视窗平台中“取窗口句柄()”方法会返回变整数。

然后就可以定义变整数变量，去使用这个类型。

2.6 小数

双精度小数有效值范围从2.2250738585072014e-308到1.7976931348623158e+308（最长小数点后15位），占用8个字节空间。

小数数值也可以通过强制转换，转换成整数、短整数或长整数，但是会丢失精度，如下图所示：

将一个初始值为1.6小数变量强制转换成整数。

最终可以看到结果为1，小数部分的内容会全部丢失。

2.7 逻辑型

逻辑型是逻辑立即数的基本类型，也就是说有效值为“真”或“假”

在火山中，逻辑值也可以转换为文本格式，不同的平台表现方式不同，但都是使用“到文本()”进行转换。

2.7.1 火山视窗平台

当逻辑值以文本格式展示时：其中“1”表示“真”，“0”表示“假”，如下图所示，使用“到文本()”方法转换：

运行结果：

如果想要重新转换为逻辑值，可以使用“文本到逻辑值()”方法转换。

在“文本到逻辑值()”方法的帮助页中可以看到，只要参数提供“真”、“true”、“1”结果值都会返回真，其它任意文本都会返回假。

因此想要结果返回真，正确的方式就是从如下三个方法中选择其中一个即可。

2.7.2 火山安卓平台

当逻辑值以文本格式展示时：其中“true”表示“真”，“false”表示“假”，如下图所示，使用“到文本()”方法转换：

运行结果：

如果想要重新转换为逻辑值，使用“文本到逻辑值()”方法转换，本方法只能转换“true”为真，其它任意文本都会返回假。

如下图所示：

2.8 字符

宽字符有效值范围从0到65535，占用2个字节空间。字符主要指包括汉字、英文字母、英文数字、运标点符号等。

在火山中想要表达立即数字符，需要使用单引号''来操作，例如：'火'、'山'，字符也支持转义符，譬如'\n'。

注：火山平台使用Unicode-16(即双字节统一码)字符编码格式。

2.8.1 字符转整数

无论安卓还是视窗，都可以通过强制转换实现将字符转换成对应的整数值。

(1) 火山安卓平台

代码编写如下图：

运行结果如下图：

(2) 火山视窗平台

代码编写如下图：

运行结果如下图：

无论是视窗还是安卓平台的字符，它们的编码格式都是Unicode-16编码格式，因此转换成整数后都是一致的，不会存在任何差异问题。

2.8.2 整数转字符

当字符被转换成整数后，如果想要重新转换成字符也可通过强制转换进行操作。

(1) 火山安卓平台

代码编写如下图：

运行结果如下图：

(2) 火山视窗平台

代码编写如下图：

运行结果如下图：

2.8.3 文本取字符

如果想要在一串文本中取出指定字符，火山安卓和火山视窗的处理方案不同，但原理基本一致。

(1) 火山安卓平台

在安卓中处理这个问题需要使用两个方法“文本到字符串()”和“取字符()”。

帮助文档如下图：

文本到字符串方法可以将文本转换成“字符串类”对象。

转换后的字符串类对象中，会有一个方法叫“取字符()”，通过此方法就可以将指定索引位置的文本取出转换成字符。

注意：字符位置从0开始，0代表第一个字符。

代码编写如下图：

因“文本到字符串()”方法返回的就是字符串对象，而“取字符()”方法又是字符串类中的方法。

因此可以将这两个方法直接结合起来使用，在代码中调用“文本到字符串().取字符()”就可以取出文本中指定位置的字符。

运行结果如下图：

最终可以看到指定位置的字符被取出。

(2) 火山视窗平台

在火山视窗平台中就比较简单，直接调用“取字符()”方法就可以取出一串文本中指定位置的字符。

帮助文档如下图：

方法中提供了两个参数。

参数1：用于提供要取字符的文本。

参数2：提供索引位置值即可，位置从0开始。

代码编写如下图：

直接调用本方法提供对应参数就可以获取指定位置字符。

运行结果如下图：

最终可以看到指定位置的字符被取出。

2.9 文本型

文本型用作记录一段字符串文本，使用立即数表达时需要在文本的左右两边使用英文双引号括起来。

如下图所示：

文本型中支持\n、\t等转义符操作，具体可参考“字符串立即数”中的介绍。

如果需要将数值型数据转换成文本型，可以直接使用“到文本()”方法即可，重新转换会目标数值型则需要对应的“文本到XX()”系列方法。

如下图所示：

2.10 模板类型1~模板类型8

注意: 本类型普通用户知道即可，无需深入了解。

模板数据类型，只能在模板基础类中使用。

模板数据类型本身并不是真实存在的数据类型，所对应的真实数据类型需要由模板实现类来提供。

我们举个例子，假设我们需要开发一个数组操作类，用作支持对各种数组类型进行操作，如果不使用模板类型，那么我们需要写很多类似的类：

整数数组操作类、小数数组操作类、文本数组操作类等等……

而这些类的处理代码是完全一样的,唯一不同之处就是其所操作的数据类型不同，使用模板类型，我们可以把所有代码都放到模板基础类里面，然后定义对应的模板实现类即可。 如:

这样能大大减少工作量，也能让程序具有更好的可维护性(只需维护一处即可)。

对于火山普通用户而言，不需要深入了解如何具体定义这些模板类型，掌握如何使用已有模板类型即可。

假设有下面这段代码：

当你右键单击末语句行上的“插入”方法，然后选择查看其帮助菜单项后，看到帮助页面中参数部分为以下内容：

你一定会感到困惑，“模板类型1”和“模板类型2”所对应的真实数据类型到底是什么呢？

很简单，请继续单击该“模板类型1”/“模板类型2”链接，譬如点击前者将看到如下页面：

根据“变量1”的当前数据类型“整数到文本哈希表”，就可以得知，“模板类型1”当前所对应的真实数据类型为“整数”，这就是“插入”方法第一个参数提供的真实数据类型。

利用同样的方法，可以得知“插入”方法的第二个参数的实际类型为“文本型”。

由此可得出如下正确的调用代码：

3、基本数据类型扩展类与对象类

3.1 字节集类与字节数组

“字节集类”和“字节[]”都是“字节”基本数据类型的集合，用于表达二进制数据，不同之处为前者用于火山视窗平台，是火山类库中提供的一个数据类，后者用于火山安卓平台、是基本数据类型数组。

虽然名称不同，但本质上是一样的，例如将一个文件读入到火山程序中：

火山安卓平台：

火山视窗平台：

需要注意的是，如果将文本数据转换成二进制数据需要注意文本编码问题。

火山视窗中使用“文本到字节集()”转换出来的文本编码是“UTF-16LE”(也就是常说的Unicode编码，万国码)，火山安卓中使用“文本到字节数组()”转换出来的文本编码则是“UTF-8”编码。

例如：你的程序需要让安卓平台和视窗平台进行通讯，这个时候就需要注意文本编码问题，否则可能会乱码，如果没有特殊需求的话，推荐统一使用“UTF-8编码”。

即：

在火山安卓平台中，可以使用“文本到字节数组()”或“文本到指定编码字节数组()”转换成UTF8编码。

在火山视窗平台中，使用“文本到UTF8()”方法即可，注意第二个参数要设置为假。

如果想让火山安卓和视窗统一使用Unicode编码，可以如下操作：

在火山安卓平台中，可以使用“文本到指定编码字节数组()”转换，第二个参数提供“文本编码.小端UTF16”即可和火山视窗平台的默认编码一致。

在火山视窗平台中，直接使用“文本到字节集()”方法即可。

常用字符集编码转换总结：

火山安卓平台：

1. 文本转换成字节数组：

(1) 文本到字节数组 ("")，将文本转换成UTF-8编码的字节数组。

(2) 文本到指定编码字节数组 ("", 文本编码.GBK)，将文本转换成GBK编码的字节数组。

(3) 文本到指定编码字节数组 ("", 文本编码.小端UTF16)，将文本转换成Unicode编码的字节数组。

2. 字节数组转换成文本：

(1) 字节数组到文本 (数组内容)，将UTF-8编码的字节数组重新转换成文本。

(2) 指定编码字节数组到文本 (数组内容, 文本编码.GBK)，将GBK编码的字节数组重新转换成文本，如果编码是GB2312，ANSI等多字节编码都可以使用GBK进行转换。

(3) 指定编码字节数组到文本 (数组内容, 文本编码.小端UTF16)，将Unicode编码的字节数组重新转换成文本。

火山视窗平台：

1. 文本转换成字节集类：

(1) 文本到UTF8 ("", 假)，将文本转换成UTF-8编码的字节集，如果要和火山安卓通讯参数2要设置为假。

(2) 文本到多字节 ("")，将文本转换成多字节编码字节集，常见的GBK，ANSI编码等都是多字节编码。

(3) 文本到字节集 ("")，将文本转换成Unicode编码的字节集。

2. 字节集类转换成文本：

(1) UTF8到文本 (字节集内容)，将UTF-8编码的字节集重新转换成文本。

(2) 多字节到文本 (字节集内容)，将多字节编码字节集重新转换成文本。

(3) 字节集到文本 (字节集内容)，将Unicode编码的字节集重新转换成文本。

3.2 基本数据类型包装类

所有基本类型包装类如下：

1. 字节类；

2. 短整数类；

3. 整数类；

4. 长整数类；

5. 变整数类(安卓平台无此类型)；

6. 小数类；

7. 字符类；

8. 逻辑型类；

9. 文本型类(视窗平台无此类型)；

这些包装类，在火山安卓平台中主要提供一些常用的基本类型操作方法，例如“取文本左边()”这个全局静态方法就是“文本型类”中的一个方法。

在火山视窗平台中，基本数据类型数据不支持以参考的方式传递到方法参数上，从而导致在被调用方法中不能以修改参数值的方式来对外返回基本数据类型数据。

这些包装类的作用就是为了方便上述操作。

如下所示：

打开“整数类”的帮助页，可以看到会存在一个名叫“值”的成员变量，而这个变量的类型就是“整数”。

如果你使用的是“长整数类”，那么这个变量的类型就是长整数。

“Ctrl+D”插入一个方法后，设置一个“整数类”的参数并赋值。

在窗口“创建完毕”事件下调用这个方法，定义“整数类”变量并传参，最后取出整数类中的值。

最终可以看到值被取出，也就间接实现了基本数据类型参数返回数据。

3.3 对象类

对象类是火山中所有类的最底层基础类，无论是自定义的类，还是火山系统库中的类，都会继承对象类。

安卓平台和视窗平台不同之处为对象类中的方法不一样，具体可看火山帮助页中的列出方法名称：

如下所示：

视窗平台：

安卓平台：

如果在实际开发过程中，遇到某个方法的参数是“对象类”，并且没有特别的注释，就代表这个参数可以提供任意的对象类数据进去。

例如：在火山视窗平台“对象数组类”的“加入成员()”方法就需要提供对象类的数据，本类为最基本的对象类数组。

如下所示：

如果想从对象数组类中取出对象，取出的数据是对象类，需要使用强制转换操作。

如下所示，必须保证强制转换的类型与添加时的类型一致：


火山软件关键字和方法关键字_火山平台语法手册

六、火山软件开发平台关键字和常用方法

1、名称关键字

1.1 返回

帮助提示如下：

通过“返回”的帮助提示可知，调用后当前方法会执行结束，并且会返回到调用语句处。如果有返回值，则会返回一个值到执行语句处。

也就是如下图所示，当“测试方法()”被“返回()”方法返回后，会返回到当前方法调用的位置，如果此位置定义了变量来接收返回值，则首先会执行这个赋值操作，然后才会执行下一行的“信息框()”方法。

本方法的参数可以提供任意类型数据，但必须保证能够匹配“返回值类型”一栏中所提供的数据类型。

如下图所示：

如果某方法的没有提供返回值类型，也可以使用“返回”，此时的“返回”不需要输入括号。

一个方法只能拥有一个返回值，如果重复返回多次，则以一次的返回值为主。

如下图所示：

最终程序运行后可看到返回了“火山”。

如果“返回”写到流程语句或者循环语句中，则流程或循环会提前结束并返回。

如下图所示：

流程语句：

循环语句：

返回的额外输入字：

除了使用全、首拼输入外，还可以使用“return”来输入。

1.2 属于

本关键字是一种判断关键字，关键字的左侧参数提供实例对象、右侧参数提供数据类名。用于返回左侧的对象是否为右侧类或者其直接/间接继承类的实例对象。

最终判断结果会返回逻辑型，如果符合返回真，即表示左侧对象能安全转换到右侧类数据类型。

注意: 左侧对象的数据类型必须为类，而且必须与右侧类之间存在继承/被继承关系或者等于右侧类本身才会符合条件。

如下图所示：

利用“属于”来判断“测试2对象”是否属于“测试类1”，此处必然返回真。

因为“测试类2”继承了“测试类1”，既然继承了测试类1，那么必然存在测试类1，因此这个属于条件必然是成立的。

最终结果也证明“测试2对象”是属于“测试类1”的。

除了继承关系相等外，如果类型相等本条件也会返回真。

如下图所示：

用“测试2对象”和“测试类1”进行判断，其结果也必然是会返回真，因为类型是完全一致的。

最终结果也证实了这一点。

全部比较结果如下图：

如果符合条件就可以进行强制转换操作，让左侧对象强制转换为右侧类型。

如下图所示：

属于的额外输入字：

除了使用全、首拼输入外，还可以使用“instanceof”来输入。

1.3 逻辑值

逻辑值只有“真”和“假”，主要用于表示逻辑型。

例如：上述中的“属于”关键字，其判断结果就是逻辑型，就可以使用真或假来判断其结果。

使用方式如下，用于变量、常量、赋值以及条件判断操作。

真/假的额外输入字：

除了使用全、首拼输入外，“真”还可以使用“ture”来输入，“假”还可以使用“false”来输入。

1.4 空对象

用作代表空对象，可以匹配所有非常量类的类数据类型以及文本型。

需要注意的是，当对象实例为空对象时，这个对象将不能进行任何操作。

如下图所示：

假设某个方法提供了一个“测试类”的参数，并且默认值为空对象，此时如果想要操作这个参数数据，首先需要判断其是否为空对象，然后在执行相应的方法操作。

空对象除了用于判断之外，还可以用于赋值，传参如下图所示：

空对象的额外输入字：

可以使用“null”输入空对象。

1.5 父对象

用于表示在类成员方法中代表所处类的父类(基础类)对象。

父对象主要是用作当基础类中存在与本类中相同名称的方法(譬如虚拟方法)时强制调用基础类的方法。

如下图所示：

也可用于调用父类中的通常方法，如下图所示：

在“测试类2”的基础类为“测试类1”，然后就可以通过“父对象”调用“方法1()”。

在窗口被创建完毕时调用“测试类2”的通常方法。

最终会执行“测试类1”中的“方法1”，并弹出一个信息框。

当然在实际开发过程中，“父类”(基础类)的方法支持直接输入调用，可以省略“父对象”的关键词。

如下图所示：

注意: 如果语句所处方法为静态方法，由于此时根本不存在当前类的实例对象，所以不能使用本关键字。

如下图所示：

父对象的额外输入字：

可以使用“super”输入父对象。

1.6 本对象

本对象表示当前代码语句所处类的对象本身。

如下图所示：

例如，在“测试类1”中使用本对象就表示是“测试类1”的对象本身。同理，如果有一个类叫“测试类2”，并且在测试类2中使用本对象，那么此时的本对象就表示的是“测试类2”的对象本身。

由此可以得出，如果某个方法的参数是当前类对象的时候就可以提供“本对象”进行传递参数。

如下图所示：

火山视窗的通用对话框的“打开()”方法，需要提供一个“窗口”对象。

在使用这个方法时，如果当前类是“窗口”或者其基础类是“窗口”时都可以使用“本对象”进行进行传递参数。

如果在其它类中调用这个“通用对话框”的“打开()”方法，就不能使用“本对象”进行传递参数。

如下图所示的写法是错误的：

正确的写法如下，可通过传递“窗口”参数来解决，其它类中使用的问题。

需要注意的是，如果在使用本对象时当前方法是静态方法，则不支持使用本对象关键字，因为静态方法中不存在当前对象实例。

本对象的额外输入字：

可以使用“this”输入本对象。

2、方法关键字

2.1 事件方法

2.1.1 挂接事件

本方法用于动态挂接指定对象的事件，共有两个参数，如下：

参数1：提供要挂接的对象名称。

参数2：提供整数标记值，当多个类型相同的对象同时挂接时，可以在事件接收方法的“标记值”参数中获取到此标记，从而用于区分对象来源。

1. 如何挂接事件？

如果想要指定对象进行“挂接事件”操作，必须满足以下条件：

(1) 其对象必须拥有“事件定义方法”。

如下图所示的“测试类”想要进行挂接事件的写法是错误的，因为“测试类”中并没有任何事件。

(2) 使用本方法后必须添加指定对象的接收事件方法。

如下图所示，使用“挂接事件()”方法后，必须添加“测试类”的接收事件方法，用于接收事件。

注意：如果存在多个相同数据类型的对象需要挂接事件，可以通过填写挂接事件的参数2，来判断事件来源。

2. 什么时候需要挂接事件？

安卓平台挂接事件：

(1) 当对象为非参考成员变量时会自动挂接事件，如下图所示：

注意：在使用火山系统库中的某个类时，即使是非参考成员变量，可能也需要通过某个属性或方法来开启事件，名称中一般包括“支持/允许”之类的字样。

如下图所示，轮播图组件需要设置“支持页面改变监听”属性为真，才可以触发“页面被选择”事件。

(2) 当对象为参考变量时需要挂接事件，如下图所示：

(3) 当对象为局部变量时需要挂接事件，如下图所示：

(4) 当对象事件需要发送到其它类中使用时，需要挂接事件。

如下所示“组件布局类”中的按钮组件事件想要在窗口中触发事件，就需要进行挂接事件操作。

视窗平台挂接事件：

(1) 当对象为非参考成员变量时会自动挂接事件，如下图所示：

(2) 局部变量不可以进行挂接事件，因为其对象实例会立刻销毁，因此如果某类中存在事件应定义为成员变量。

(3) 动态创建对象需要手动挂接事件。

如下图所示，动态创建一个按钮时需要挂接事件：

运行后可看到动态创建的按钮也可以正常点击：

(4) 当对象事件需要发送到其它类中使用时，需要挂接事件。

如下所示“组件布局器”中的按钮组件事件想要在窗口中触发事件，就需要进行挂接事件操作。

2.1.2 取消事件挂接

不再将指定对象所支持的事件挂接到当前类对象中的对应事件接收方法上。

无论是自动挂接事件的类成员对象变量，还是手动调用挂接事件关键字挂接的对象，均可以调用本关键字取消其事件挂接。事件挂接一旦取消，该对象的事件将不会再被接收到，谨慎使用。

如下图所示调用即可取消所有事件：

2.2 运算方法

2.2.1 取反

本方法可对逻辑值进行取反。

如下图:

本方法只有一个逻辑型参数，如果参数中提供真，则返回值会返回假，用于取出反转的逻辑值。

如下图进行调用即可：

本方法的参数可以提供逻辑立即数，变量，方法等，只要其数据类型为逻辑型即可。

2.3 位运算方法

2.3.1 了解位运算

位运算是指对数值进行二进制的逐位运算。我们知道现代电子计算机内部采用的都是二进制方式存储和处理数据的，输入到计算机的数组、字母、汉字等信息都以二进制的形式存储。在计算机内部用“比特(bit)”这个单位来表示一个二进制，其状态只有0或1两种，位运算命令就是直接改变这些“比特”来达到改变数据的效果。想要了解位运算，首先来需要简单了解一下计算机中的常用进制。

注意：在火山中所有的位运算都是针对“整数”类型操作，而整数的长度固定为4个字节=32比特(位)，也就是一组32位长度的二进制数。

2.3.2 常用进制

在计算机内部运算中，常用的进制有四种。

(1) 二进制：逢2进1，由数字0和1组成，例如：1010110，数值都限制在0和1之间。

(2) 八进制：逢8进1，由数字0到7组成，例如：21270，数值都限制在0到7之间。

(3) 十进制：逢10进1，有数字0到9组成，例如：1230569，数值都限制在0到9之间。

(4) 十六进制：逢16进1，有数字0到9和字母A到F组成，例如：309F7B，其内容都限制在0到9和A到F之间。

所谓二进制就是“逢2进1、借1当2”为原则，对数值进行计数的进位制。它和我们日常使用的十进制类似，只不过十进制是“逢10进1、借1当10”。

进制之间是可以相互转换的，可以使用一些第三方工具来进行操作：https://tool.lu/hexconvert/

2.3.3 位取反

如下图：

本方法可以将一个整数值的二进制中的每一位进行取反，即0变1、1变0，返回反转后的结果值。

示例如下：

对5进行位取反运算操作。

最终结果返回-6。

运算过程解析：

“5”的二进制表达式为：0000 0000 0000 0000 0000 0000 0000 0101。

在执行位取反运算后，返回：1111 1111 1111 1111 1111 1111 1111 1010，但是如果你直接用这个二进制去转换十进制是得不到“-6”这个结果的。

那么为什么结果最终是-6呢？那么首先需要了解负数的二进制表达方式。

现在计算机普遍使用补码表示负数。知道一个数的补码，要求其值的方法是：首先看符号位（最左一位），如果是1代表是负数(-)如果是0代表是正数(+)，然后对该值取反再+1，得到其结果值。

例如本例中得到的 1111 1111 1111 1111 1111 1111 1111 1010，其符号位（最左一位）是1，表明它表示的是负数，欲求其结果值，需先对其取反，然后再加1：0000 0000 0000 0000 0000 0000 0000 0101 + 1 = 0000 0000 0000 0000 0000 0000 0000 0110，然后在得到的结果值前加一个负号，即-0000 0000 0000 0000 0000 0000 0000 0110 = -6。

由此可以总结出“位取反()”的计算结论是：位取反(n)=-(n+1)。

例如本例中：位取反(5) = -(5+1)，即位取反(5) = -6

2.3.4 位与

如下图：

本方法用于将两个整数数据的二进制值中的同比特位进行“与”运算，返回运算后的结果值。

与运算：如果两个数值的共同位均为1，则返回值的对应位也为1，否则为0。

注：对多个整数值进行连续运算可以使用火山系统库中的“连续位与()”方法。

例如：

一个二进制数的第四位为1，另一个二进制数的第四位为1，则返回值的第四位为1。

一个二进制数的第四位为0，另一个二进制数的第四位为1，则返回值的第四位为0。

一个二进制数的第四位为1，另一个二进制数的第四位为0，则返回值的第四位为0。

一个二进制数的第四位为0，另一个二进制数的第四位为0，则返回值的第四位为0。

示例如下：

对56和89进行位与运算。

最终结果为24。

运算过程解析：

56和89分别转换成二进制为：0011 1000和0101 1001，进行与的运算后即会得出结果0001 1000转换成十进制即“24”。

2.3.5 位或

如下图：

本方法用于将两个整数数据的二进制值进行“或”运算，返回运算后的结果值。

或运算：如果两个数值的共同位中有一个为1，则返回值的对应位也为1，否则为0。

注：对多个整数值进行连续计算可以使用火山系统库中的“连续位或()”方法。

例如：

一个二进制数的第四位为1，另一个二进制数的第四位为1，则返回值的第四位为1。

一个二进制数的第四位为0，另一个二进制数的第四位为1，则返回值的第四位为1。

一个二进制数的第四位为1，另一个二进制数的第四位为0，则返回值的第四位为1。

一个二进制数的第四位为0，另一个二进制数的第四位为0，则返回值的第四位为0。

示例如下：

对56和89两位十进制整数进行位或运算。

最终结果为121。

运算过程解析：

56和89分别转换成二进制为：0011 1000和0101 1001，进行与的运算后即会得出结果0111 1001转换成十进制即“121”。

2.3.6 位异或

如下图：

本方法用于对二进制数值的共同比特位进行“异或”运算，返回运算后的结果值。

异或运算：如果两个数值的共同位相等（均为0或均为1），则返回值的对应位就是0，否则为1。

注：对多个整数值进行连续计算可以使用火山系统库中的“连续位异或()”方法。

例如：

一个二进制数的第四位为1，另一个二进制数的第四位为1，则返回值的第四位为0。

一个二进制数的第四位为0，另一个二进制数的第四位为1，则返回值的第四位为1。

一个二进制数的第四位为1，另一个二进制数的第四位为0，则返回值的第四位为1。

一个二进制数的第四位为0，另一个二进制数的第四位为0，则返回值的第四位为0。

示例如下：

对56和89两位十进制整数进行位异或运算。

最终结果为97。

运算过程解析：

56和89分别转换成二进制为：0011 1000和0101 1001，进行与的运算后即会得出结果0110 0001转换成十进制即“97”。

如果一个数值连续异或两个相同的数值，将返回该数值本身。如：连续位异或 (1, 2, 2) 最终结果会返回最初的值1，利用此特性可以进行简单的数值加解密操作。

如下图所示：

将数值2作为用来位异或加密的密钥值，将数值1进行位异或加密，在需要解密的时候对加密结果再次进行位异或即可恢复原值。

最终恢复原值：

2.3.7 位左移

如下图：

本方法用于将一个整数值的所有二进制比特位向左移动所指定位数，最右侧使用0补位，最左侧被移出的比特位将被抛弃。

例如：

二进制: 1010 0000 0000 0000 0000 0000 0000 1111，向左移动两位后返回 1000 0000 0000 0000 0000 0000 0011 1100，最左侧的10将被抛弃，最右侧自动补0。

示例如下：

对80十进制整数进行位左移2位运算。

最终结果为320。

运算过程解析：

80转换成二进制为：0101 0000，进行位左移两位后即会得出结果0001 0100 0000转换成十进制即“320”。

2.3.8 位右移

如下图：

本方法用于将一个整数值的所有二进制比特位向右移动所指定位数，最左侧使用0补位，最右侧被移出的比特位将被抛弃。

例如：

二进制: 1010 0000 0000 0000 0000 0000 0000 1111，向右移动两位后返回 0010 1000 0000 0000 0000 0000 0000 0011，最左侧将会补0，最右侧将被抛弃两位。

示例如下：

对80十进制整数进行位右移2位运算。

最终结果为20。

运算过程解析：

80转换成二进制为：0101 0000，进行位右移两位后即会得出结果0001 0100转换成十进制即“20”。

3、常用基础方法

3.1 赋值方法

3.1.1 连续赋值

本方法可用于同时对多个相同类型的变量进行赋值相同内容。

帮助页如下图所示：

参数1：可提供任意类型的数据，但必须保证和参数2提供的变量的数据类型相匹配。

参数2：提供可写入的变量，该变量的类型必须保证和参数1提供的类型匹配。

如下图进行调用即可：

其调用后的最终结果为，变量1和变量2同时会赋值“火山”。

3.1.2 连续清零

本方法可用于同时对多个相同数值型的变量进行赋值为0，在火山视窗中可以将逻辑型赋值为假（安卓中不支持逻辑型）。

本方法只提供了一个可扩展参数，直接提供要清零的变量即可。

火山安卓调用如下图：

直接提供要清零的数值类型的变量即可。

火山视窗调用如下图：

在火山视窗中支持逻辑型，逻辑值最终会设置为假。

3.1.3 连续清空

本方法可用于同时对多个文本型的变量进行赋值为空文本。

帮助页如下图所示：

本方法只有一个可扩展的文本型参数，用于清空所有的文本型变量。

如下图进行调用即可：

其调用后的最终结果为，三个变量都会设置为空文本。

3.2 运算方法

3.2.1 选择

本方法又称为三目运算，其作用是根据参数1提供的逻辑值，从而决定是返回参数2还是返回参数3。

帮助页如下图所示：

如果参数1提供真，则返回参数2，否则返回参数3。

如下图进行调用即可：

示例中的“文本变量”其内容最终为“文本1”，因为“选择()”方法的参数1提供的逻辑值为真。


火山软件流程控制语句介绍_火山平台语法手册

七、火山软件开发平台流程控制语句介绍

1、概述

流程控制语句是火山中非常重要的一类命令，可用于控制程序运行路线，在满足条件时执行一些程序语句，不满足条件时执行另外一些程序语句。

2、如果语句

2.1 如果

本命令根据所提供的逻辑参数的值，来决定是否改变程序的执行位置。如果所提供的逻辑参数值为真，则执行其下属子语句体中的代码，为假则跳过本命令的子语句体。

在如果语句末尾位置按下回车键，会自动进入其子语句体中，如下图：

示例：

利用如果语句比较两个整数变量是否相等，如果相等则执行信息框提示相等，否则就会跳过这个信息框。

最终会显示信息框提示相等。

根据上述演示，还可以实现以下效果：

根据如果语句的判定结果来决定信息框最终显示的内容。

最终信息框的内容会显示“软件”，如果条件不满足，则最终结果会显示“火山”。

注意：满足条件后执行的代码必须保证是位于子语句体中，如下图所示是错误的。

可通过右键菜单“块操作 -> 向外缩进”，让要执行的代码重新回到子语句体中。

2.2 如果否则

如果语句后面可以跟否则语句，当如果语句的逻辑参数为“假”时，将执行否则语句的子语句体。

示例如下：

如果语句后面可以跟多个否则语句，可用于判断多种可能的情况。

使用时需要注意以下几点：

(1) 如果语句后可以跟N个否则语句，但否则语句不能在如果语句之前。

(2) 一旦其中任意一个语句执行结果为真，将执行其子语句体的内容，剩余的所有“否则”语句将跳过。

示例如下：

如果判断两个相同的条件，则只会执行首次判断成功的条件。

示例如下：

只会执行第一个满足条件的子语句体，其它条件会跳过。

3、如果真语句

本语句同如果语句，本语句只能单独使用，无法配合“否则”语句来使用。

如下图所示：

当满足条件后执行子语句体的内容，否则执行“如果真”语句之外的其它代码。

4、分支判断语句

4.1 分支判断与分支

用于判断一个整数值与一系列整数值中某个值是否相等。

这其中要判断的整数值位于“分支判断”语句的参数中，而这一系列整数值则位于“分支”语句的参数中，每个值称为一个分支。

分支判断帮助如下图：

本语句需要提供一个整数类型的数据，用于“欲判断检查的值”，其要判断的值由“分支”语句提供。

注：本方法的子语句体内只能存在分支或默认分支，并且至少包含一个。

分支帮助如下图：

本语句只能位于“分支判断”的子语句体内，用于检查“分支判断”参数中提供的整数数据，是否等于本语句中的参数值。

如果相等，将去执行本语句的子语句体中的代码，并跳过后续所有其它判断检查分支，否则将跳过本语句的子语句体转去检查后续的下一分支是否满足要求。

注：本语句的参数只能提供立即数或常量。

示例如下：

(1) 分支判断语句提供欲判断检查的值。

(2) 分支语句提供欲检查是否相等的值。

如果分支判断语句的值和某个分支中的值相等，则执行对应分支子语句体的代码。

上图中的“变量”的值为1，则最终结果会弹出“满足条件1”的信息框。

4.2 默认分支

本语句需要在“分支判断”的子语句体中使用，用于指定“默认分支”，如果所有的“分支”都不满足时则执行本语句下的子语句体的内容。

示例如下：

最终结果会弹出“默认分支”下的信息框，因整数变量的初始值为0，并不满足前两个分支。

4.3 跳出分支

本语句只能在“分支”或“默认分支”的直接/间接的子语句中使用，用于跳出整个“分支判断”去执行下一条语句。

示例如下：


火山软件循环结构语句介绍_火山平台语法手册

八、火山软件开发平台循环结构语句介绍

1、概述

如果想要同样的程序语句被执行多次，就需要使用循环结构语句。

在火山中提供了如下循环结构：

(1) 循环

(2) 计次循环

(3) 逆向计次循环

(4) 判断循环首/尾

(5) 判断循环

在循环结构执行时，有时需要提前结束循环。

火山提供了如下的循环控制语句：

(1) 跳出循环

(2) 到循环尾

2、循环

本语句将利用变量对循环体(本语句的子语句体)内的命令进行循环执行。

第一次执行此语句时将使用“变量起始值”参数初始化“循环变量”参数所指定的变量，每次(包括第一次)执行到此语句处都将判断循环变量内的值是否已经到达“变量目标值”参数所指定的值，如已等于或超过，则跳转到循环体的下一条语句处，否则进入循环体。

本语句共有四个参数，分别如下：

(1) 变量起始值：

定义循环变量的起始数值。

如果被省略，默认为0。

(2) 变量目标值：

定义循环变量的目标数值，在循环首部如果发现循环变量值已到达此目标值时(递增值小于0时小于等于目标值，递增值大于0时大于等于目标值)将跳出循环而不再进入循环体。

如果被省略，默认值为1。

(3) 循环变量：

本整数型变量将用作控制循环执行次数，在循环尾部将自动递增或递减该变量内的数值(由变量递增值参数决定)，在循环体中的可以直接取用此变量中的值。

如果被省略，将自动使用内部临时变量。

(4) 变量递增值：

每次执行到循环尾部时都将把此值加入到循环变量中去，此值可为正数或负数，如为正数则递增，为负数则递减。

如果被省略，默认值为1。

注意: 必须为本参数提供非0整数立即值，以便编译器建立循环结束条件。

实现正向循环计数，示例如下：

循环语句的参数1、4忽略、参数2提供要循环的数量、参数3提供循环变量，然后在其子语句体内利用循环变量实现正向计数。

最终实现从0到9的计数。

实现逆向循环计数，示例如下：

循环语句的参数1提供要循环的数量、参数2提供0、参数3提供循环变量、参数4提供-1，然后在其子语句体内利用循环变量实现逆向从10到1进行输出。

最终实现了10到1的逆向计数。

利用其循环变量的特性，还可以实现循环正/逆向取出数组成员内容，如下：

(1) 实现正向遍历数组成员，示例如下：

循环语句的参数1、4忽略、参数2提供数组成员数、参数3提供循环变量，就可实现正向遍历输出数组成员。

最终数组所有成员将被输出到编辑框中显示。

(2) 实现逆向遍历数组成员，示例如下：

循环语句的参数1提供数组成员数、参数2提供0、参数3提供循环变量、参数4提供-1，就可实现逆向遍历输出数组成员。

最终数组所有成员将被逆向输出到编辑框中显示。

3、计次循环

本语句只有一个参数，用于提供子语句体要循环的次数。

本语句相当于“循环”语句的精简版，但只提供正向循环，在本语句的子语句体内利用“取循环索引()”方法就可以很方便的取出被循环的索引值。

利用本语句循环10次，取出循环索引到编辑框中。

最终循环索引会依次显示在编辑框中。

注：本语句在火山安卓中不支持嵌套使用，如下图所示：

4、逆向计次循环

本语句只有一个参数，用于提供子语句体要循环的次数。

本语句相当于“循环”语句的精简版，但只提供逆向循环，在本语句的子语句体内利用“取循环索引()”方法就可以很方便的取出被循环的索引值。

利用本语句逆向循环10次，取出循环索引到编辑框中。

最终循环索引会逆向依次显示在编辑框中。

注：本语句在火山安卓中不支持嵌套使用，如下图所示：

5、取循环索引

本方法只能用于“计次循环”或“逆向计次循环”的子语句体中使用，用于取出循环索引值。

注1：务必保证本方法位于子语句体内，如下图所示是错误的：

注2：如果有多层循环嵌套，本方法只能取出最近层循环的索引值，无法取出其它循环层的循环索引。

如下图所示的嵌套循环，其中“取循环索引()”方法取出的索引值为“计次循环(2)”的。

6、循环判断首和循环判断尾

“循环判断首”和“循环判断尾”语句必须配套使用，当“循环判断首”被执行后，首先会执行其子语句体的内容，然后会根据“循环判断尾”所提供的逻辑参数决定是否继续循环执行，如果参数为真则继续循环执行，否则跳出循环。

注：因本循环语句的判断条件是在循环语句的尾部，所以本循环在使用时会至少保证循环一次。

示例：

在本语句的子语句体内对“计数”变量进行累计+1，并输出计数结果，实现正向计数效果。

最终利用本语句实现了正向计数效果。

同理，也可以实现逆向计数如下所示：

最终实现了逆向计数。

7、判断循环

本语句是先对其逻辑参数进行判断，根据其结果值（真或假）来决定是否开始循环，和“循环判断首/尾”正好相反。

示例：

在本语句的子语句体内对“计数”变量进行累计+1，并输出计数结果，实现正向计数效果。

最终利用本语句实现了正向计数效果。

同理，也可以实现逆向计数如下所示：

最终实现了逆向计数。

8、跳出循环

本命令转移当前程序执行位置到当前所处循环体尾部的下一条语句处，可用于所有循环语句。

如下图所示，当循环索引为5时执行跳出循环。

最终循环提前结束。

9、到循环尾

本命令转移当前程序执行位置到当前所处循环体的尾部。

示例：

因循环体内对“整数变量”进行了一次判断，并执行了一次“到循环尾”相当于跳过了一个循环，所以最终会输出2、3。


火山软件类库方法的识别与调用_火山平台语法手册

九、火山软件开发平台类库方法的识别与调用

1、概述

在火山核心库中存在大量的类，每个类都有多个方法，这些方法在火山中又进行了分类，不同类型的方法其调用方式也不一样。

本节的内容主要利用火山帮助页，正确的识别不同类型的方法，以及如何正确的使用这些方法，从而快速掌握火山核心库的使用。

火山中的方法分类如下：

1. 通常方法

2. 静态方法

(1) 普通静态方法

(2) 支持动态方式调用的静态方法

(3) 全局静态方法

3. 属性写方法

4. 属性读方法

5. 事件方法

6. 虚拟方法

2、通常方法的识别与调用

识别：

打开某类的帮助页，如果此类拥有通常方法就可以在帮助页中看到“通常方法”的分类。

如下图所示为“编辑框”组件的部分通常方法：

点击帮助页中的某个方法，也可以在方法的类别处看到“通常方法”的关键字。

调用：

通常方法调用时通常需要通过类对象来访问。

如下图所示，通过编辑框组件的名称，就可以调用当前组件中的通常方法。

除了这种方式，如果某个方法返回一个类对象，也可以直接通过类对象来调用，如: 方法1 ().XX方法 ()

3、静态方法

在静态方法中，又分为“普通静态方法”、“支持动态格式调用的静态方法”和“全局静态方法”，其识别和调用方式均不相同，分别如下：

3.1 普通静态方法的识别与调用

识别：

打开某类的帮助页，如果此类拥有静态方法就可以在帮助页中看到“静态方法”的分类。

如下图所示为“加解密类”中的部分静态方法：

点击帮助页中的某个静态方法，也可以在方法的类别处看到“静态方法”的关键字，访问权限为“公开、静态”。

调用：

静态方法调用时可直接通过类名访问。

如下图所示，通过“加解密类”就可以直接访问“加密_RC4”方法。

3.2 支持动态格式调用的静态方法，如何识别与调用

识别：

本类型方法本质上也是静态方法，只是增加了“支持动态格式调用”的特性。

在帮助页中会全部归类为“静态方法”，至于是否支持“动态格式调用”则需要打开方法的帮助页进行查看。

如下图所示为“JSON对象类”中的部分静态方法：

如果在方法的帮助页中没有看到“支持以动态格式调用”关键字，就证明本方法为普通的静态方法。

调用：

本方法有两种调用方式：

(1) 通过类对象访问：其第一个参数被移动到方法访问对象上，这种方式在编译时将被自动转换为第一种方式。

(2) 通过类名访问：标准的静态方法访问方式。

3.3 全局静态方法的识别与调用

识别：

打开某类的帮助页，如果此类拥有全局静态方法就可以在帮助页中看到“全局静态方法”的分类。

如下图所示为“文本类”中的部分全局静态方法：

点击帮助页中的某个方法，也可以在方法的类别处看到“全局静态方法”的关键字。

调用：

全局静态方法可以直接通过方法名进行访问。

如下图所示，不需要输入类名、也不需要定义变量就可以直接调用“分割子文本()”方法。

4、属性写方法的识别与调用

识别：

打开某类的帮助页，如果此类拥有属性写方法就可以在帮助页中看到“属性写方法”的分类。

如下图所示为“编辑框”组件中的部分属性写方法：

点击帮助页中的某个属性写方法，也可以在方法的类别处看到“属性写方法”的关键字。

调用：

属性写方法有两种调用方式，如下图所示：

通过变量属性表或代码语句调用。

注：如果属性值为类数据类型(常量类除外)，不支持在表格中调用。

5、属性读方法的识别与调用

识别：

打开某类的帮助页，如果此类拥有属性读方法就可以在帮助页中看到“属性读方法”的分类。

如下图所示为“编辑框”组件中的部分属性读方法：

点击帮助页中的某个属性读方法，也可以在方法的类别处看到“属性读方法”的关键字。

调用：

通过类对象调用属性名即可。

6、事件方法的识别与调用

5.1 识别与调用

识别：

打开某类的帮助页，如果此类拥有事件方法就可以在帮助页中看到“事件定义方法”的分类。

如下图所示为“编辑框”组件中的部分事件方法：

点击帮助页中的某个事件方法，也可以在方法的类别处看到“事件定义方法”的关键字。

调用：

事件调用共有两种方式，如下：

(1) 通过变量“类型”的小按钮可以添加事件。

(2) 通过右键“类型”添加。

选择“添加XX的事件接受及虚拟方法”菜单后，会弹出一个事件选择窗口，选择自己要添加的事件进行添加即可。

5.2 事件不被触发时的处理方案

当事件不触发时可通过“挂接事件”解决。

7、虚拟方法的识别与调用

识别：

打开某类的帮助页，如果此类拥有虚拟方法就可以在帮助页中看到“虚拟方法”的分类。

如下图所示为“窗口”中的部分虚拟方法：

点击帮助页中的某个虚拟方法，也可以在方法的类别处看到“虚拟方法”的关键字。

调用：

虚拟方法调用共有两种方式，如下：

(1) 通过“类名”的小按钮可以添加虚拟方法。

(2) 通过右键添加。

选择“添加XX的事件接受及虚拟方法”菜单后，会弹出一个选择窗口，选择自己要添加的虚拟方法进行添加即可。

虚拟方法的作用：

如果在火山中，某个类中的某个方法不能满足使用需求，但是我们又不想重新定义一个方法来操作，这个时候就可以利用火山的“虚拟方法”来实现对这个方法进行重写，这样的重写操作在火山中就称为虚拟方法。

具体可看“定义虚拟方法”中的示例。


第三章 程序调试与发布

一、程序调试与异常处理

1. 程序调试

1.1 了解程序调试

1.2 程序调试命令

1.2.1 调试输出

1.2.2 调试输出当前语句位置

1.2.3 取当前语句位置

1.2.4 为调试版

1.2.5 调试检查

1.2.6 编译出错

1.3 调试器使用

2. 异常处理

二、编译发布版

1. 火山安卓

2. 火山视窗


火山软件程序调试和异常处理介绍_火山平台语法手册

一、火山软件开发平台程序调试与异常处理介绍

1、程序调试

1.1 了解程序调试

(1) 概述

所谓程序调试，是在开发的程序投入实际使用前进行相关测试工作，修正语法错误和逻辑错误的过程，这是保证程序正常执行必不可少的步骤。

每一个程序几乎都需要经过反复调试、修改，才能最终完成。本节内容将介绍火山平台是如何进行调试工作的。

(2) 如何调试？

使用快捷键F5(部分电脑需要Fn + F5)可以开始程序调试工作，也可以点击火山平台上的绿色按钮进行调试。

注意：安卓平台调试需要使用安卓模拟器，使用手机调试需要打开开发者选项、USB调试、USB安装等相关设置项。

(3) 程序错误分类

程序中的错误一般分为“语法错误”和“逻辑错误”。

语法错误：是指程序代码不符合火山语法规范，这种错误是最容易发现并修改的。在程序调试时，火山平台会首先进行基本语法检查，如果出现语法不规范的情况会立刻中断调试，并且光标会定位在错误位置并输出相关的错误信息，根据错误提示进行修改即可。

如下图所示：

当给整数变量赋值文本数据，进行程序调试时火山平台会直接报错，并告知错误位置和错误原因。

逻辑错误：是指程序执行流程上的错误，一般情况下程序可以正常运行，但是运行后的执行结果和预期不符，或者程序发生发生报错，闪退等情况。这种错误火山无法通过语法检查主动发现，需要程序开发者利用火山中相关的调试命令进行错误定位，最终解决这个问题。

1.2 程序调试命令

注：所有调试相关命令都会在编译程序发布版时被跳过。

1.2.1 调试输出

本命令用于在调试版中输出调试信息到火山平台的“调试”消息栏中，不同平台下可调试输出的类型不同，如下所示：

安卓平台：

如下图所示，在安卓平台中调试输出只能用于输出文本型数据或格式文本数据。

参数1：用于提供要输出的格式文本或普通文本。

参数2：当参数1提供格式文本时，本参数需要提供格式替换符对应的数据类型。

常用格式替换符如下：

常用格式替换符 | 解释
%n | 换行符
%% 百分号本身
%f | 小数
%d | 整数(十进制)
%o | 整数(八进制)
%b、%B | 逻辑型
%h、%H | 散列码
%s、%S | 文本型
%c、%C | 字符
%x、%X | 整数(十六进制)
%e、%E | 指数型小数
%a、%A | 十六进制小数型
%g、%G | 通用小数型(自动选择%f和%e类型中较短者)

示例：

在窗口“通知_被创建”虚拟方法下分别输出普通文本和格式文本信息。

当程序进行调试时，就可以在火山软件的调试栏中看到程序的调试信息。

注：因安卓系统的缘故，有时候调试信息可能会有延迟。

视窗平台：

如下图所示，在视窗平台中调试输出可输出多种数据类型，并且可以同时输出多条数据。

示例：

在窗口“创建完毕”事件下输出各种类型数据。

当程序进行调试时，就可以在火山软件的调试栏中看到程序的调试信息。

1.2.2 调试输出当前语句位置

本命令用于输出当前语句所处位置到火山软件的调试栏中，方便定位错误位置。

位置信息依次为：<所处源文件名>、所处源文件行号、 所处包名.所处类名、 所处方法名。

1.2.3 取当前语句位置

本命令可以直接取出当前语句位置文本，如下所示：

最终当软件进行调试时，会输出当前语句位置到信息框中。

1.2.4 为调试版

本命令用于判断当前软件是否为调试版，如果为调试版返回真。

本命令可用于在调试版时进行一些数据测试等操作。

当软件调试时会弹出信息框。

1.2.5 调试检查

本命令共有两个参数：

参数1：在调试版中，当此参数值为假时，程序将中断执行并报错。

参数2：指定当检查失败时(检查值参数为假)所输出的信息，如果被省略，则默认为空文本。

注：本关键字在增强程序可靠性方面非常有用，可以在程序中大量使用本关键字语句检查相关处理数据的合法性，又不用担心编译程序的发布版本时这些检查语句降低了程序执行效率。

如下图所示：

程序将会中断到当前语句的下一行位置，并在程序调试栏输出错误信息。

1.2.6 编译出错

本命令仅在编译程序时起作用，编译器一旦编译到具有本关键字的语句，就会报告发现了编译错误并停止编译。

本关键字普通用户无需深入了解。

1.3 调试器使用

调试器用于软件在调试时动态跟踪代码执行流程，可以进行查看、修改、监视变量等行为，其功能位于“调试”菜单中。

调试菜单说明如下：

(1) 运行：用于调试程序。

(2) 终止：用于终止被调试的程序。

(3) 查看/修改变量：在调试过程中，可以查看指定变量的值，并可以加入变量到监视表中。

(4) 单步跟踪：在程序现行运行位置单步执行一行程序，如果此程序行调用了其它方法，系统不会跟踪到此方法中。

(5) 单步跟踪进入：在程序现行运行位置单步执行一行程序，如果此程序行调用了其它方法，系统会跟踪到此方法中。

(6) 跟踪返回：在被调用的方法中设置断点，断点行被跟踪后，跳出当前方法，系统跟踪至上级方法调用当前方法语句的下一行代码。

(7) 执行到光标处：调试程序时会在光标位置所在行中断执行。

(8) 设置或清除断点：手动的在程序某一行设置或清除断点，如果有断点则清除，如果没有则会设置一个断点，程序执行到此位置时会中断执行。

(9) 清除所有断点：用于清除程序所有断点。

(10) 到现行执行位置：跳转到现行执行位置。

下面介绍具体如何使用：

1.3.1 执行到光标处

如下图所示：

执行程序时，到光标所在行时会中断执行。

程序中断后会在程序行最左侧位置显示一个换色箭头，此时就可以进行“查看/修改变量”或“单步跟踪”等操作。

1.3.2 断点调试

除了通过快捷键F9设置/清除断点外，还可以通过鼠标点击代码行最左侧空白位置设置/清除断点。

断点设置成功后会出现一个红色的实心圆。

注：只有方法的子语句体内可以设置断点。

当断点设置后，程序运行时会中断到断点位置(会出现黄色箭头提示)，此时就可以进行“查看/修改变量”或“单步跟踪”等操作。

1.3.3 查看变量

当程序被调试器中断后，可以通过鼠标悬浮变量名称查看变量值。

也可以通过光标定位变量名称，按Shift + F9进行查看变量值。

1.3.4 修改变量

在查看/修改变量窗口，可以通过双击变量所在行，进行修改变量值。

当变量被修改后也会影响程序最终执行结果，在实际程序调试过程中可以利用此特性动态进行一些数据测试。

1.3.5 监视变量

在查看/修改变量窗口，可以选择一个变量，并将其加入到监视表中，可用于监视变量变化。

按F5快捷键或点击运行按钮可继续执行程序，会发现被监视的变量也一直在更新，将变量加入检视表后，方便动态查看变量的数据值。

1.3.6 单步跟踪

每次按一次F8都会向下执行一行并中断执行，直到整个程序执行结束。

注：如果程序行存在方法调用，并不会跟踪到方法中。

1.3.7 单步跟踪进入

每次按一次Shift + F8都会向下执行一行并中断执行，直到整个程序执行结束。

注：如果程序行存在方法调用，会跟踪到方法中进行中。

1.3.8 跟踪返回

执行跟踪返回，会跳出当前方法，系统跟踪至上级方法调用当前方法语句的下一行代码。

如下图，22行位置被中断，会返回到17行的位置。

1.3.9 清除所有断点

如下图，用于清除所有断点。

2、异常处理

2.1 异常概述

异常是指程序在运行时产生的一些错误，譬如：程序发生闪退，就属于异常的一种。

异常发生的原因一般都是程序逻辑错误导致，很多异常也是可以避免的，譬如：在安卓平台中打开一个不存在的文件就会产生异常，因此打开文件之前可以首先判断文件是否存在，这样就可以避免打开文件时产生的异常。

示例：

2.2 如何俘获异常

安卓平台：

如下图为火山安卓平台中的异常处理方法。

使用“开始俘获异常()”方法并在其子语句体内提供要俘获异常的代码，并配合“俘获所有异常()”方法就可以俘获程序运行时产生的异常。

示例如下：

在“开始俘获异常()”的子语句体内模拟一个数组成员溢出的操作，并在“俘获所有溢出()”的子语句体内提供异常提示信息。

最终程序并不会因为数组成员溢出发生闪退，而会提示错误信息(此错误信息也可以不提供)。

利用“取被俘获异常对象 ().取异常文本 ()”还可以取出java异常描述，普通用户知道即可。

视窗平台：

如下图为火山视窗平台中的异常处理方法。

视窗中的使用方式和安卓中基本一致，除了使用“开始俘获异常()”和“俘获所有异常()”外，还需要配合“抛出异常()”方法使用。

示例如下：

利用“除法运算()”方法模拟一个除以零的异常，在该方法中进行抛出异常，只有抛出异常后才可以被“俘获所有异常()”方法进行俘获。

最终程序可以俘获到被除数为0的异常错误。


火山软件程序编译发布版_火山平台语法手册

二、火山软件编译发布版

1、火山安卓

(1) 填写程序包名

填写包名，必须保证有一个小数点，并且保证唯一性，不能与其它程序包名重复，以免造成无法安装的后果。

例如：腾讯QQ的包名为“com.tencent.mobileqq”，当前程序不可填写同样的包名，会造成包名冲突，从而无法安装程序。

注意：确定程序包名后不能更改，如果程序内有多个“.v”火山源文件，则每个文件都需要填写包名，包名可重复。

如下图所示：

(2) 建立密钥文件

在安卓系统中，安卓程序必须要拥有密钥文件才可以运行。

1. 选择“工具 -> 安卓密钥文件建立器”。

2. 建立器中只有两个必填项，密钥名称和文件保存位置。

3. 打开的密钥文件保存窗口，默认会选择当前项目路径，直接输入文件名点击保存即可。

4. 点击生成。

5. 最后会提示生成成功，如果失败可以尝试重新生成或者重启电脑后尝试。

(3) 设置软件信息

使用快捷键“Alt + F7”，打开项目设置窗口。并依次设置程序标题、程序版本号、程序版本名称、程序图标、目标安卓平台SDK的API级别以及生成的密钥文件，填写完毕后，点击“确定”即可。

注意：软件应用市场升级软件通常以“程序版本号”为准，在升级软件时需修改“程序版本号”。

(4) 编译发布版

通过菜单“生成 -> 生成活动项目”或使用快捷键F7，都可以编译当前活动项目为发布版。

如果发生报错提示XXX不为有效的英文名称。

打开项目属性，设置“所输出APK文件纯名称”随便提供一个英文字母名称即可。

最后编译成功后，可以看到发布版的APK文件路径。

编译完成后生成的temp文件夹可以删除。

2、火山视窗

视窗项目编译发布版流程和安卓大致一样，都需要填写包名和软件信息。

(1) 填写程序包名

视窗程序中的包名可随意填写，只要保证至少有一个小数点即可。

(2) 填写程序信息

使用快捷键“Alt + F7”，打开项目属性设置程序相关信息，完成后点击确定即可。

(3) 编译发布版

使用快捷键“F7”可以编译当前活动项目为发布版，编译完成后可以看到程序输出路径。

编译完成后生成的out文件夹可以删除，不会影响软件运行。

如果软件使用了一些模块，则编译出来的程序可能会附带一些DLL动态链接库文件，程序给用户使用时需要将dll一起打包给用户。

如下图为，编译视窗例程库中的Curl网络传输例程：

编译发布版也可通过右键选择。

发布此程序给用户使用时需要将这些dll文件一起打包发给用户。

注：如果不想依赖dll文件，可通过项目属性设置“火山模块链接方式”为静态编译，可解决部分模块附带dll的问题。


第四章 贯通软件开发流程

一、安卓项目

1. 你好祖国小程序

2. 简易计算器

二、视窗项目

1. 你好祖国小程序

2. 密码管理小程序

3. 飞机大战小游戏


火山安卓实现你好祖国例程_火山平台语法手册

一、火山安卓实现你好祖国小程序

1、程序分析

在正式开发之前，首先需要对程序进行简单的分析。只有合理的分析程序界面以及要实现的功能之外，才能更好的开发这个软件。

如下：

运行平台：安卓平台，安卓5.0及以上系统。

界面设计：在窗口正中心位置放置一个按钮，并起名“你好祖国！”，因本程序界面并不复杂，可不用出效果图。

具体功能：点击按钮后弹出一个信息框，内容显示“你好祖国！”。

2、程序开发

2.1 项目创建

利用快捷键“Ctrl + Shift + N”打开项目创建窗口，根据需求选择一个安卓平台下具有窗口的项目模板。

项目创建完毕：

2.2 界面设计

使用快捷键“Ctrl + U”打开界面设计器，拖放一个按钮到界面中，并选择启动类的界面布局，设置其“内容横/纵向对齐”模式为居中。

最终就可以让按钮1居中对齐。

2.3 代码编写

(1) 首先填写程序必备的软件包名。

(2) 按照程序开发需求，设置按钮标题。

(3) 添加按钮被点击事件。

(4) 添加事件后，利用如果语句判断按钮来源，并在其子语句体内输入“提示信息框()”命令，用于显示一个内容为“你好祖国！”的信息框。

至此，程序代码编写完毕。

2.4 调试运行

在程序正式编译发布版之前，首先需要对程序进行调试工作，验证程序是否能够正常执行。

打开一个安卓模拟器(推荐使用雷电模拟器)，在模拟器运行完毕后，按下快捷键“F5”进行程序调试。

3、案例下载

点击下载当前教程案例。


火山安卓开发简易计算器案例_火山平台语法手册

二、火山安卓开发简易计算器软件

1、程序分析

在正式开发之前，首先需要对程序进行简单的分析。只有合理的分析程序界面以及要实现的功能之外，才能更好的开发这个软件。

如下：

运行平台：安卓平台，安卓5.0及以上系统。

界面设计：共分两个区域，显示区域和计算区域，如下图所示：

显示区域：

在显示区域又分为上下两个部分，分别为“公式区”和“结果区”，用于分别显示计算公式和计算结果，可使用文本框组件显示。

计算区域：

计算区域的布局为4×5的宫格布局，可使用5个线性布局器和19个文本框，并利用权重布局实现效果。

注：计算区最后一行只有三个内容，因此需要单独设置权重布局。

具体功能：按下数字键和运算符键后，最终能够实现简单的数学运算。为防止在公式区出现无意义的计算公式，因此按下某键之前进行相关的判断工作，譬如：按下某运算符键后，需要首先判断一下在公式区是否已经输入了运算符，防止重复输入。

2、程序开发

2.1 项目创建

利用快捷键“Ctrl + Shift + N”打开项目创建窗口，根据需求选择一个安卓平台下具有窗口的项目模板。

项目创建完毕：

2.2 界面设计

使用快捷键“Ctrl + U”打开界面设计器，因界面较为复杂，需要进行逐步设计。

(1) 在界面中拖放两个文本框和五个线性布局器组件，并按“Ctrl”键依次将所有组件全部选中，并设置以下属性：

剩余空间权重：10；

组件宽度类型：匹配父组件宽度；

组件高度类型：直接指定，并设置高度值为0，只有设置高度为0后“剩余空间权重”才会按照比例进行分配尺寸。

(2) 因所有组件已经将剩余空间权重设置为10，为了能够让组件按照比例平均分配，因此需要选中启动类布局，将“剩余空间总权重”设置为70，这样所有组件就可以等比例的分配尺寸。

(3) 按“Ctrl”键，选中两个文本框组件，并分别设置以下属性：

内容横向对齐：右对齐；

内容纵向对齐：居中；

文本颜色：黑色；

字体尺寸：30，如果最终运行效果和软件效果图有偏差，可以自行调整；

右内边距：25；

(4) 单独选中“文本框2”组件，本组件最终会存放计算结果，因此可以将其文本尺寸修改大一些，方便和存放计算公式的文本框形成反差效果。

(5) 因考虑到两个文本框都是居中对齐，最终可能会导致两个文本内容直接间隙过大，因此可以选中“文本框1”组件，将其内容调整为“底对齐”。

那为什么不去调整文本框2的对齐方式呢？

其实很简单，因为调整文本框2的对齐方式，最终可能会导致文本框2的内容和计算区域直接间隙过大，影响软件的整体美观效果。

(6) 按“Ctrl”键选中所有的线性布局器，将其布局方向设置为“横向布局”。

(7) 在任意一个线性布局器内，拖放四个文本框组件，并按“Ctrl”键全部选中，然后设置以下属性：

内容横向对齐：居中；

内容纵向对齐：居中；

文本颜色：黑色；

文本字体尺寸：26；

剩余空间权重：25；

组件宽度：0；

组件高度：匹配父组件高度；

(8) 属性设置完毕后，选中四个文本框组件进行右键并选择复制。

(9) 复制后依次粘贴到其它线性布局器中，粘贴后的组件会自动拥有被复制组件的属性。

(10) 因最后一个线性布局器只有三个内容，因此需要删除一个文本框组件，并修改其中一个文本框的权重为50。

(11) 可以选中非数字区域的文本框，修改其颜色增加美观效果。

(12) 选中文本框3、4，因这两个文本框最终会存放汉字，在视觉上会比数字、运算符看起来稍微大一些，为了整体视觉效果可以适当的降低字体尺寸。

(13) 然后按照设计图效果，依次修改文本框名称设置文本框内容。

(14) 至此界面设计完毕，可以进行调试查看一下界面效果，效果不满意可以根据自己的需求进行调整。

2.3 代码编写

(1) 首先将所有需要操作的文本框设置“支持单击”和“支持触摸”属性为真，如果不设置将无法进行单击和触摸。

(2) 任意找一个文本框组件，添加触摸事件。

(3) 在触摸事件下判断触摸动作类型，当按下时修改背景色为0xCCCCCCCC(即半透明浅灰色)，抬起后修改为透明色。

(4) 最终可以实现如下效果：

(5) 在正式开始实现计算功能之前，我们首先需要封装三个常用方法出来，为后面的计算过程提供帮助。

是否为数值：

譬如：在按下“加号”键时，可用于验证公式文本框中，是否已经输入了整数或小数，从而决定是否在公式文本框中添加加号符。

其中本方法“参数2”的作用，是用于在按下小数点时，验证公式文本框中是否输入的为整数，从而决定是否在公式文本框中添加小数点。

注：正则表达式类需要配置“正则表达式支持”模块才能使用。

方法解析：

正则表达式类.是否完全匹配()

在本方法的作用，是用于验证提供的文本是否全部为数字，如果全是数字则返回真。

文本到小数()

在本方法中判断不等于0，用于验证提供的文本是否为数值。

清除尾部0：

因在计算过程中采用小数进行计算，即使最终结果值是整数，最后也会以“.0”结尾，本方法用于清除尾部的“.0”。

计算公式结果：

利用正则文本分割()方法，对公式文本框中的内容进行分割后计算结果。

注：相减运算不能使用正则文本分割，因为要考虑负数运算的问题。

(6) 任意使用一个文本框添加文本框被单击事件。

(7) 添加事件后将需要操作的文本框，使用如果否则语句进行判断其来源对象。

其中加减乘除运算符和所有的数字键统一进行判断。

(8) “文本框_清零”被单击：

直接将公式文本框设置为空文本，结果文本框设置为0即可。

(9) “文本框_删除”被单击：

当删除被单击时，首先验证公式文本框是否为空或其结尾文本为等于号，如果满足条件就执行清零操作。

当不满足条件时，就利用“取文本左边()”方法对公式文本框的内容进行删除一个字符，将删除后的内容重新赋值给公式文本框。

(10) “文本框_百分比”被单击：

在操作之前首先验证公式文本框的内容是否为空，当不等于空的时候在进行百分比的处理。

85-88行：

用于判断公式文本框是否只输入了数值，如果满足条件就进行百分比处理，并修改公式文本框显示的内容后返回。

89-93行：

用于验证当前是否已经进行过数学运算，如果满足条件则首先判断结果文本框是否不等于0，当条件满足时修改公式文本框的显示内容并对结果文本框进行百分比处理。

将处理结果重新赋值给结果文本框显示，最后执行返回。

95-98行：

当前面的两个条件都不满足时，证明输入了计算公式。

到这里可能会疑问，为什么没有判断是否存在运算符，就能证明已经输入计算公式了呢？

原因很简单，这是因为已经在“计算公式结果()”方法中进行了判断，因此无需额外的判断。

接下来将公式文本框的结果计算出来，并将结果显示在公式文本框中。

然后对计算结果进行百分比处理，将处理后的内容赋值给结果文本框显示。

(11) “文本框_加/减/乘/除” 被单击

因运算符的处理都是相同的，所以可以放在一起进行判断，减少代码重复使用。

100-103行：

用于判断公式文本框内容为空时，如果被单击的运算符为减号，则可以进行输入。

105-107行：

如果公式文本框的内容为数值，则直接输入运算符。

108-110行：

验证当前是否已经进行过计算，如果已经被计算过了，则将计算结果显示在公式文本框中，并输入对应的运算符。

111-112行：

当公式文本框以小数点结尾时，直接返回不输入任何运算符。

113-116行：

如果前面的添加都不满足，则证明已经输入了计算公式，但是还未进行计算。

首先取出计算结果，并将计算结果显示在公式文本框中，并输入运算符，最后需要将结果文本框设置为0。

(12) “文本框_等于”被单击

当公式文本框不等于空时，取出最右侧的文本，并判断其是否不等于任何符号。

如果满足条件则进行计算，将计算结果显示在结果文本框中。

注意给公式文本框添加等于号，方便其它文本框组件点击时验证是否被计算过。

(13) “文本框_点”被单击

首先要判断公式文本框的内容不等于可空，当满足条件后再进行相关处理。

126-138行：

本段代码的作用，是用运算符对公式文本框的内容进行分割，将分割的结果赋值给文本数组。

其作用是方便验证运算符右侧被运算的数值，是否为整数，从而来决定是否在公式文本框中输入小数。

139-142行：

如果任何运算符都没有找到，就证明还没有输入运算符，此时就直接验证公式文本框的内容是否为整数，满足条件后就在公式文本框中输入小数点，并返回。

143-146行：

最后这段代码就是用于验证运算符右侧被运算的数值是否已经输入过小数点，如果满足条件则输入小数点并返回。

(14) 数字键被单击

在这里可能会有疑问，因为并没有写条件，怎么就一定是所有的数字键？“文本框_公式”被点击，会不会在这里被执行？

这点可以放心，在火山安卓中除了按钮类型的组件外，其它类型的组件都需要设置“支持单击”属性为真，才可以触发被单击事件。

因“文本框_公式”并没有设置支持单击属性，因此“否则”子语句体中的代码只能是其它的所有数字键。

148-152行：

当公式文本框的内容为空时，首先判断输入数字是否为0，如果为0则自动补充小数点，否则直接输入数字。

154-156行：

当公式文本框不为空时，验证一下当前输入的公式是否已经进行过计算，如果被计算过，则直接将公式文本框的内容赋值为要输入的数字。

157-158行：

如果公式文本框的内容为0，按下的数字键也为0时，不进行输入直接返回。

159-166行：

本段代码的作用是防止，譬如：11+0的情况下继续输入数字。

这里可能会有疑问，明明已经处理过对0自动补充小数，为什么要需要验证？

这里不要忘记，计算器还提供有删除功能，所以这里依然需要验证一下，其计算公式的结尾是否满足：运算符 + 0的情况，如果满足条件则直接返回。

167-170行：

用于验证计算公式的结尾是否为运算符，当结尾为运算符时，判断点击的是否为数字键0，如果为0则自动补充小数点。

171行：

当公式文本框不为空时，且以上条件都不满足时，证明可以直接输入对应数字。

至此整个简易计算器编写完毕，在开发过程中要额外注意全角符号和半角符号的问题，譬如：“-”、“－”是不同的。

在程序编写过程中要么全部使用半角，要么全部使用全角，为减少计算过程中产生不必要的错误。

2.4 调试运行

在程序正式编译发布版之前，首先需要对程序进行调试工作。

打开一个安卓模拟器(推荐使用雷电模拟器)，在模拟器运行完毕后，按下快捷键“F5”进行程序调试。

调试时如果火山报以下错误，证明项目缺少模块，配置模块即可解决。

第二条错误提示缺少返回值，是因为火山在预编译时，没有找到正则表达式类，因此语句被忽略，从而会导致整个方法的返回语句不完整。

因此，只要将项目模块配置完善，火山编译器能检查到正则表达式类，第二条错误也就解决了。

计算测试：

如果在调试过程中如果遇到程序闪退，或者输入的计算公式存在问题的情况下，可以参考《程序调试和异常处理》章节中的内容，对程序进行详细的调试，找到问题并解决问题。

3、案例下载

点击下载当前教程案例。


火山视窗实现你好祖国例程_火山平台语法手册

一、火山视窗实现你好祖国小程序

1、程序分析

在正式开发之前，首先需要对程序进行简单的分析。只有合理的分析程序界面以及要实现的功能之外，才能更好的开发这个软件。

如下：

运行平台：视窗平台，win7及以上系统。

界面设计：在窗口正中心位置放置一个按钮，并起名“你好祖国”，因本程序界面并不复杂，可不用出效果图。

具体功能：点击按钮后弹出一个信息框，内容显示“你好祖国！”。

2、程序开发

2.1 项目创建

利用快捷键“Ctrl + Shift + N”打开项目创建窗口，根据需求选择一个视窗系统下具有窗口的项目模板。

项目创建完毕：

2.2 界面设计

使用快捷键“Ctrl + U”打开界面设计器，拖放一个按钮到界面中并选中，利用工具条中的两个按钮实现居中对齐，并在右侧设置按钮标题。

2.3 代码编写

(1) 添加按钮被点击事件。

(4) 添加事件后，利用如果语句判断按钮来源，并在其子语句体内输入“信息框()”命令，用于显示一个内容为“你好祖国！”的信息框。

至此，程序代码编写完毕。

2.4 调试运行

在程序正式编译发布版之前，首先需要对程序进行调试工作，验证程序是否能够正常执行。

按下快捷键“F5”进行程序调试。

3、案例下载

点击下载当前教程案例。


火山视窗开发密码管理小程序_火山平台语法手册

二、火山视窗开发密码管理小程序

1、程序分析

在正式开发之前，首先需要对程序进行简单的分析。只有合理的分析程序界面以及要实现的功能之外，才能更好的开发这个软件。

如下：

应用场景：随着互联网信息的高速发展，越来越多的网站诞生，每个网站可能都需要注册账号密码才能登陆，如果使用了重复的密码无疑是有风险的，但是使用不同的密码又会产生忘记密码的问题。因此根据此场景可以开发一个简易的密码管理软件，这样既可以规避风险，又能防止忘记密码。

运行平台：视窗平台，win7及以上系统。

界面设计：可能需要用到三个窗口，后续软件需要升级，再根据需求在决定是否增加或删除窗口。

分别如下所示：

主窗口：

主窗口由有四个按钮和一个超级列表框组成，超级列表框中用于显示已经保存过的账号密码等信息。

添加修改窗口：

在点击主窗口中“添加”或“修改”按钮后弹出的窗口，用于添加或修改信息。

因这两个功能类似，因此可以使用同一个窗口来解决，无需单独建立添加窗口和修改窗口。

至于按钮组件的标题，可通过载入窗口后，将其修改成“添加”或“修改”。

查找窗口：

在点击主窗口中的“查找”按钮后弹出的窗口，根据组合框和编辑框提供的条件信息，从而在已经保存的数据中搜索到想要的内容。

功能分析：

(1) 软件启动后连接SQLite数据库并从数据库获取已经保存的密码到超级列表框中显示。

(2) 点击添加按钮，弹出添加修改窗口，输入相关信息后执行sql语句添加数据到SQlite数据库中，并刷新列表框内容。

(3) 点击查找按钮，弹出查找窗口，输入条件后，根据条件在超级列表框中查询信息，并将查询结果高亮显示。

(4) 点击修改按钮之前，首先需要判断列表框有没有选中一个项目，如果有选中，则弹出添加修改窗口，并将列表框选中项的数据填充到添加修改窗口中，便于修改操作。

(5) 点击删除按钮，同样也需要判断列表框是否有选中项目，如果有的话取出唯一的ID，通过ID在SQlite数据库中删除数据。

2、程序开发

2.1 项目创建

利用快捷键“Ctrl + Shift + N”打开项目创建窗口，根据需求选择一个视窗平台下具有窗口的项目模板。

项目创建完毕：

注：如果已经在“主窗口对象”的属性栏中设置了窗口标题，则不可以在“我的主窗口”类的属性栏中设置标题。

2.2 主窗口界面设计

使用快捷键“Ctrl + U”打开主窗口界面设计器。

(1) 拖放四个按钮到窗口上，并分别修改名称和标题，规范化的名称可便于后续代码编写。

(2) 按钮如果分布不均匀，可以使用工具条中的“水平平均分布”进行平均操作。

(3) 首先需要配置“MFC扩展界面支持类库1”模块，配置模块后才能看到“超级列表框”组件，将此组件拖放到窗口中设置一个合适的大小，并调整以下属性：

类型：报表列表框；

整行选择：真；

(4) 点击“报表列”属性按钮，会弹出一个窗口，在此窗口中设置报表列数据：

(5) 最终界面效果

2.3 添加修改窗口界面设计

(1) 使用快捷键“Ctrl + D”新建一个类：

类名填写“添加修改窗口”，基础类填写“窗口”，并给此窗口设置“标题”属性。

(2) 使用快捷键“Ctrl + U”打开添加修改窗口的界面设计器。

按照需求拖放标签、编辑框和按钮组件实现如下效果。

除标签组件外，可以对其它组件进行名称修改，以便于后续的代码编写。

备注编辑框可以额外设置一个“是否允许多行”属性为真。

注：当程序运行时可能会遇到这样的问题，获得焦点的编辑框并不是网站名称所处编辑框，而是其它的编辑框，这是因为编辑框组件的焦点，会按照放置顺序进行操作。

譬如：在界面设计时，如果首先放置的是备注编辑框，那么软件运行后此编辑框会首先获得焦点，按下Tab键切换焦点，也是按组件的放置顺序进行，如果放置的顺序不对，最终切换焦点的顺序也会是错乱的。

想要让焦点顺序正常，可以通过“布局内容”进行拖动组件修改焦点顺序。

2.4 查找窗口界面设计

(1) 使用快捷键“Ctrl + D”新建一个类：

类名填写“查找窗口”，基础类填写“窗口”，并给此窗口设置“标题”属性。

(2) 使用快捷键“Ctrl + U”打开查找窗口的界面设计器。

按照需求拖放标签、组合框、编辑框和按钮组件实现如下效果。

(3) 选中组合框组件，并设置如下属性：

类型：不可编辑下拉式（因要筛选的类型数据都是固定的，并且只有四个，所以不需要编辑）；

现行选中项：0；

(4) 点击“列表项目”的属性按钮会弹出一个项目设置窗口，插入四个可选项目即可。

(5) 最终效果如下图：

2.5 SQlite数据库表设计

SQlite是一种轻量级的数据库，不需要服务器可以在任何设备上使用，数据库内容存储在一个文件中，操作SQlite数据库实际上就是操作一个文件，通常文件后缀名为db。

数据库文件可以通过代码动态创建，也可以使用第三方工具生成，为了便于理解这里我们采用Navicat for SQlite软件来生成数据库文件，然后将生成的文件交给火山视窗操作。

(1) 启动软件后，点击连接按钮。

(2) 填写一个名称，选择SQLite3版本，最后设置一下数据库文件保存路径。

(3) 双击密码管理，随后双击main，就可以点击“新建表”按钮。

(4) 如下图所示设置自增ID字段，其作用是为了保证数据库中存在唯一值，方便后续删除，修改等操作。

注：数据库的字段名建议使用英文字母，因数据库中对中文字段名支持不友好。

(5) 添加栏位即添加新字段，添加后输入名称选择文本类型。

(6) 按照字段需求，重复的点击“添加栏位”，所有字段设置完毕后，点击“保存”按钮。

(7) 填写一个表名，随后点击确定，就可以关闭表设计窗口。

注：表名建议使用英文字母。

(8) 创建完毕后就可以打开此表，看到数据库字段信息。

至此数据库字段设置完毕，可以关闭本软件。

(9) 在保存位置会生成一个数据库文件，火山视窗操作的就是此文件。

2.6 主窗口代码编写

(1) 首先在启动类的属性栏中使用“@视窗.附属文件”引用生成的数据库文件，最终此文件会在程序调试或者编译发布版时，将文件输出到软件目录中，从而方便程序调试和发布程序。

注意公开主窗口对象，便于在其它窗口中调用主窗口。

(2) 配置SQLite数据库模块，定义“SQLite数据库类”并公开，便于在其它窗口中调用数据库。

将另外两个窗口类也都定义成对象实例，便于后续创建窗口。

超级列表框组件也进行公开，便于在查找窗口中调用。

(3) 添加主窗口创建完毕事件，利用数据库对象打开程序运行目录下的数据库，打开成功后就调用“载入数据库内容()”方法载入内容，失败就弹出信息框并关闭窗口。

这里可能会有疑问，为什么要调用一个方法？而不是直接写载入内容的代码？

其实原因也很简单，载入内容在多个地方会用到，因此封装起来便于在操作。

方法解析：

数据库.打开()

顾名思义，就是打开一个数据库。

参数1：提供数据库文件路径.

参数2：提供数据库打开方式，此处务必使用SQLite打开方式.读写打开，否则数据库将无法正常操作。

取运行目录()

本方法可以取出当前程序的运行目录，在数据库.打开()方法中使用，用于表示数据库文件的完整路径。

(4) 载入数据库内容方法如下：

使用快捷键“Ctrl+M”新建方法，插入一个逻辑参数并公开此方法，便于在其它窗口中调用本命令刷新。

其参数的作用，是用于首次打开时不进行提示没有查询到任何内容。

27-28行：

利用select查询语句取出记录集对象。

记录集：即数据库内容集合。

SQL语句解析：

SELECT * FROM mima，查询名称为“mima”表下的所有字段内容。

29-30行：

判断记录集是否有效，如果记录集有效则执行列表框全部删除命令。

31-38行：

数据库中的数据都是一行一行的获取，没办法通过某个命令一次性获取全部数据，在SQLite数据库中只能使用“判断循环”来实现。。

利用“判断循环”语句，判断其“记录集.执行语句()”的结果是否为“SQLite执行结果.下一行就绪”。

注：“执行语句()”的作用是执行“取记录集()”方法中提供的SQL语句。

如果满足条件就证明下一行数据被获取到，就可以在其子语句体内向利用记录集的“读文本数据()”方法读取数据填充到列表框中。

列表框方法解析：

插入表项()

本方法共有6个参数，在此处只需要填写参数2，提供要插入的标题信息即可，返回当前插入的表项索引。

置标题()

本方法共有3个参数，分别提供表项索引，列索引，欲设置标题即可。

其中读文本数据()方法需要提供字段索引，从0开始。

0：表示id字段;

1：表示name字段;

2：表示url字段;

3：表示user字段;

4：表示pw字段;

5：表示beizhu字段。

39-41行：

首先将记录集释放，并判断“是否首次打开”参数是否为假且列表框的表项数是否为0，如果都满足条件才提示没有查询到任何内容。

(5) 添加主窗口将被销毁事件，并关闭数据库释放数据库资源。

(6) 添加按钮被单击事件，并实现如下效果：

因删除和修改按钮点击时需要判断有没有选中项，所以需要在判断是否有选中项后再进行操作。

为什么要判断选中项？因为要取出列表框中显示的唯一ID值，根据ID值才能更加方便的删除或修改数据。

(7) 找到添加修改窗口，将其所有可能会被操作的组件进行公开，便于接下来的代码编写。

(8) “按钮_添加”被单击：

弹出添加修改窗口后，并修改此窗口中的按钮标题为“添加”，毕竟此窗口有两个作用，修改按钮标题后也便于识别当前窗口是添加还是修改。

“按钮_查找”被单击：

利用“创建弹出子窗口()”方法弹出查找窗口，参数填写本对象即可。

(9) 当不满足添加/查找按钮点击时，执行如下代码：

首先判断列表框是否有选中项，如果没有选中项则弹出信息框提示。

否则就取出列表框中现行选中项“ID”列的数据内容(即数据库中的唯一ID)，便于删除或修改按钮的点击操作。

取标题()方法解析：

本方法共有两个参数，参数1提供要取标题的表项索引（此处提供现行选中项即可），参数2提供列索引（从0开始）。

(10) “按钮_删除” 被单击

调用“数据库.执行SQL语句()”命令执行删除语句，其删除条件为id=自增ID，因为此值在数据库中是唯一值，因此不需要担心误删其它数据。

SQL语句解析：

DELETE FROM mima WHERE id = 自增ID

删除名称为“mima”表下“id”字段的值为“自增ID”的数据。

当执行结果返回0表示删除成功，成功后删除列表框的现行选中项，否则将错误原因取出并显示在信息框中。

执行SQL语句()方法解析：

本方法共有两个参数，参数1提供要执行的SQL语句，参数2提供一个文本型的变量，当执行错误时刻通过此变量取出错误原因。

(11) “按钮_修改”被单击

弹出添加修改窗口后，修改按钮标题并给按钮的标记属性赋值自增ID，以便于后续在此窗口中进行执行修改数据库数据。

随后取出列表框现行选中项的数据，依次赋值给此窗口中的编辑框组件，便于识别修改的是哪条数据。

2.7 添加修改窗口代码编写

(1) 添加按钮被单击事件

因本窗口中只有一个按钮，因此可以不必判断来源对象参数。

因在弹出此窗口后都对按钮标题进行了修改，所以可通过判断按钮标题，根据不同的标题来执行不同的操作代码。

(2) 按钮内容为“添加”时执行：

102-103行：

首先判断所有编辑框的内容是否为空，如果为空就弹出信息框，提示用户进行输入内容。

105-113行：

106行：定义insert插入语句，其格式为“INSERT INTO 表名 (字段名1, 字段名2,...) VALUES ('值1', '值2',....)”

SQL语句解析：

在指定表的指定字段下，插入一行新的值。

108行：利用“取程序()”命令可取出启动类对象，然后就可以调用被公开的主窗口对象、调用数据库的执行SQL语句方法，执行定义好的插入语句.

如果执行结果返回0表示执行成功，继续利用“取程序()”，调用主窗口中的“载入数据内容()”方法来刷新列表显示，并关闭当前窗口。

当执行失败时，则取出错误原因。

(3) 按钮内容为“修改”时执行：

首先定义update更新语句，在更新语句中就利用到了赋值给按钮组件“标记”属性的ID值，取出ID值写到sql语句的where条件中。

SQL语句解析：

UPDATE 表名 SET 字段1 = '值1', 字段2 = '值2' WHERE 条件字段 = '条件值'

根据条件自动提供的条件值，在指定表中进行筛选，筛选后将“字段1”对应的值修改为“值1”，“字段2”对应的值修改为“值2”，如果存在多个字段则以此类推，多个字段之间需要用半角逗号分隔。

最后利用“取程序()”调用主窗口中数据库的执行SQL语句方法。

如果执行成功则调用“载入数据库内容()”方法来刷新列表框并关闭当前窗口，否则提示错误原因。

2.8 查找窗口代码编写

(1) 添加查找窗口创建完毕事件，在此窗口下让编辑框获得输入焦点。

(2) 添加按钮被单击事件，因本窗口中只有一个按钮，因此可以不判断来源对象。

首先判断编辑框的内容是否为空，并提示用户输入内容。

如果不为空，则利用“取程序()”方法取出主窗口中的列表框组件进行“查找表项()”操作。

查找表项()方法解析：

本方法共有4个参数。

参数1：提供要查找的内容；

参数2：提供起始查找位置，默认为0；

参数3：是否精确匹配，默认为真。

参数4：提供要查找的列索引。

当前情况下只需要填写参数1和参数4即可。

如果查找结果为-1，则表示没有找到，此时应弹出提示告知用户。

否则就让列表框组件获取焦点，并选中查找到的表项，最后关闭当前窗口。

2.9 调试运行

在程序正式编译发布版之前，首先需要对程序进行调试工作。

添加测试：

查找测试：

修改测试：

删除测试：

在调试时，可能会遇到一个问题，就是当关闭调试的程序后，重新调试时，会发现所有的数据都清空了？这是为什么？

其实很简单，这是因为“@视窗.附属文件”每次调试或编译发布版时，都会重新将数据库文件输出，这就导致原有的数据库文件已经被覆盖，所以重新调试时数据就没了，如果想要调试时保留数据也很简单，首次调试后，将附属文件屏蔽掉即可。

3、案例下载

点击下载当前教程案例。


火山视窗开发飞机大战小游戏_火山平台语法手册

[上一章]

三、火山视窗开发飞机大战小游戏

1、程序分析

在正式开发之前，首先需要对程序进行简单的分析。只有合理的分析程序界面以及要实现的功能之外，才能更好的开发这个软件。

如下：

运行平台： win7及以上系统。

素材准备：

需要准备以下图片素材：

背景图、操作飞机、敌机、子弹、爆炸效果。

需要准备以下声音素材：

子弹发射声、爆炸声。

这些素材可以自行在网上搜寻，或直接使用文章结尾飞机大战源码中提供的素材。

游戏流程：

进入游戏后，首先显示一个名称为“开始游戏”的按钮，点击按钮后隐藏鼠标后开始游戏。

背景图绘制：

背景图绘制时可以实时移动图片，实现简易的动画效果，让游戏的整体效果可以好看一些。

操作飞机绘制：

操作飞机在绘制时，让其跟随鼠标位置进行移动，实现控制操作飞机的目的，同时需要检测操作飞机是否与敌机发生碰撞，从而结束游戏。

敌机绘制：

随机位置绘制敌机并实时移动其位置，实现敌机飞行效果。

子弹绘制：

当处于游戏状态时，点击鼠标左键开始绘制子弹，同时播放子弹发射声音，并实时移动其位置检测是否与敌机发生碰撞，如果发生碰撞就开始绘制爆炸效果并删除敌机，同时需要播放爆炸声音。

当敌机被销毁后，在游戏的左上角绘制敌机销毁数量。

2、程序开发

2.1 项目创建

利用快捷键“Ctrl + Shift + N”打开项目创建窗口，根据需求选择一个视窗平台下具有窗口的项目模板。

项目创建完毕：

在项目创建完毕后，修改窗口标题包名等基本信息，随后将准备好的图片和声音资源复制到项目目录中，以便于管理。

2.2 界面设计

使用快捷键“Ctrl + U”打开主窗口的界面设计器，进行界面设计后才能开始编写游戏代码。

需要用到以下组件：两个画板和一个按钮，按钮用于控制游戏的开始，两个画板是为了防止游戏绘制时产生的闪屏现象。

(1) 首先将窗口尺寸设置为宽度400、高度640。

(2) 在窗口上拖放一个画板组件，并设置其尺寸和位置起名“备用画板”，所有的绘制操作均在此画板上进行。

注：其尺寸必须和窗口尺寸保持一致，左边属性值应设置为窗口宽度。

(3) 重新拖放一个画板组件，并设置其尺寸和位置，起名“主画板”。

本画板用于备用画板绘制游戏完毕后，最终其内容全部绘制到此画板上显示游戏界面，以规避快速绘制时画板产生的闪烁问题。

(4) 最后拖放一个按钮到窗口上，默认按钮会位于最底层，可通过快捷键“Ctrl + T”调整到顶层。

2.3 代码编写

1、 首先将两个画板增加“自动重画”属性，并设置属性值为真，如果不进行设置，画板可能会发生黑屏现象。

2、 使用快捷键“Ctrl+D”新增一个类(名称随意)，此类用于存放准备的素材，便于后期管理。

(1) 因素材都是固定不变的，定义成员常量来存放素材即可。

(2) 声音文件必须为wav格式，类型使用“WAV资源”即可。

(3) 图片文件使用“位图资源”类型，支持主流的图片格式。

注：最后将所有常量公开，便于在程序代码中访问这些资源。

3、 使用快捷键“Ctrl+D”新增一个类，设置成如下图效果，其中：

对象数组模板类：可以将“@模板实现类”对应的属性值中填写的类，变成对象数组。

位置类：可用于存放坐标。

最终位置类将变成位置类数组，其中的每个成员都是位置类对象。

注：本类的作用，用于存放敌机坐标和操作飞机发射的子弹坐标。

4、 在“我的主窗口”中，新增一个方法，用于取出鼠标相对于主画板左上角的位置。

(1) 首先利用“取鼠标位置()”方法取出鼠标相对于屏幕左上角所处的位置。

(2) 然后利用“主画板.用户区位置到屏幕()”方法取出画板组件相对于屏幕坐标。

(3) 最后将鼠标位置减去组件位置，得到的就是鼠标位置在画板组件中的位置。

注：本方法主要用于操作飞机发射子弹时，计算坐标使用。

5、 首先定义一个类型为“位置类”的成员变量，用于实时存储鼠标在画板中的位置，以便于控制操作飞机。

添加画板组件的“鼠标位置被移动”事件，判断来源对象是否为主画板，如果为主画板则将坐标位置存储到鼠标位置对象中。

6、 首先定义一个逻辑型的成员变量，用于控制游戏是否开始。

(1) 添加按钮被单击事件，因整个游戏窗口中只有一个按钮，可以不用判断来源对象是否为开始游戏按钮。

(2) 在事件中首先将鼠标隐藏。

(3) 设置“是否开始游戏”的逻辑变量为真。

(4) 隐藏开始游戏按钮组件。

(5) 最后调用开始游戏()方法进入游戏。

7、 使用快捷键“Ctrl+M”新建一个开始游戏方法，并在方法内将所有位图资源全部转换成位图对象类，以便于后续的绘制操作。

8、绘制背景图

8.1 在判断循环子语句体内绘制背景图

(1) 首先在判断循环外定义一个局部变量，用于存储背景图顶边位置，通过改变此变量值可以实现背景图移动动画。

(2) 利用判断循环语句判断“是否开始游戏”成员变量是否为真，如果为真则开始游戏绘制。

(3) 调用备用画板的画图片方法，绘制两个处于不同位置的背景图，以便于动画效果的实现。

(4) 将背景图顶边位置进行循环累加10像素距离，以实现背景图移动效果，移动的距离，不建议太大，如果移动距离太大动画效果会不流畅。

(5) 最后判断顶边距离是否即将超出屏幕画板尺寸，如果即将超出就将背景图顶边位置设置为0，从而实现循环播放动画。

画图片()方法解析：

本方法共有6个参数。

参数1：提供要绘制的位图对象；

参数2：提供左边画出位置；

参数3：提供右边画出位置；

参数4：提供要画出的宽度；

参数5：提供要画出的高度；

参数6：提供画出方法，可使用“图像复制方法”中的常量值，本参数也可以为一个颜色值，用作指定图片中的透明色(即具有此颜色的像素 将不会被绘制)，但必须使用其负值. 如: -取颜色 (255, 255, 255)，此参数 值即指定在画板上画出图片中除白色外的所有颜色。

当前绘制背景图时，最后一个参数无需填写。

8.2 将备用画板的游戏界面显示在主画板上，因为是一次性将画好的界面全部显示在主画板上，所以可以规避画板单独绘制时产生的闪烁现象。

(1) 利用备用画板的取图片方法取出画好的位图对象。

(2) 将取出的位图对象，完整的绘制到主画板上。

(3) 最后将备用画板清除，并进行延时和处理事件操作。

注：因为我们是直接在主线程利用“判断循环”语句进行绘制的，所以必须进行延时和处理事件操作，否则整个软件界面可能会卡死。

取图片()方法解析：

本方法共有3个参数。

参数1：提供要保存的位图对象，画板图片被取出后将会保存在此参数中；

参数2：提供输出宽度；

参数3：提供输出高度；

8.3 最后可以调试运行一下游戏，查看游戏背景图是否成功进行绘制。

9、 绘制操作飞机

9.1 在绘制背景图之后、主画板绘制之前，调用备用画板的“画图片()”方法绘制操作飞机。

其中“鼠标位置”是来源于“画板_鼠标位置被移动”事件下提供的位置信息，根据此位置信息就可以在鼠标位置处绘制操作飞机。

最后一个参数提供的负颜色值，其作用是用于不绘制指定颜色。因提供的素材是具有白色背景，因此需要填写本参数，让其不绘制白色。

如下，画图片方法帮助页中的注释：

9.2 最后调试游戏，移动鼠标即可实现控制操作飞机。

为什么移动鼠标时操作飞机也会进行移动？

(1) 主画板添加了“鼠标位置被移动”事件，只要鼠标位置在本组件上发生移动，那么其坐标就会被记录在“鼠标位置”变量中。

(2) 开始游戏后，判断循环会一直循环执行，不停的从“鼠标位置”中获取最新的鼠标位置，用于绘制操作飞机，从而也就实现了移动鼠标控制操作飞机的目的。

10、绘制敌机

10.1 首先定义一个类型为“位置数组类”的成员变量，用于存放敌机坐标。

10.2 可以在绘制操作飞机下方编写绘制敌机的相关代码。

53-54行：

利用取随机数()方法，创建一个生成敌机的条件，当生成的随机数等于19时进行敌机生成（也可以是其它数字）。

为什么要进行这样的限制？

其实原因很简单，因为所有游戏绘制代码均在判断循环中执行，其执行速度是非常快的，如果不限制敌机生成条件，那么最终会生成非常多的敌机。

55-58行：

当满足生成敌机的条件后，随机一个横坐标，纵坐标固定为-50，使生成的敌机隐藏在游戏区域外，并将坐标赋值给位置对象，最后将此位置对象加入到敌机位置数组中存储起来，便于后续使用。

10.3 遍历敌机位置数组，开始绘制敌机

59-60行：

将所有敌机数量取出，便于对敌机进行遍历。

61行：

定义类型为整数的计数变量，用于对游戏区域内的敌机数量进行计数。

62行：

利用“计次循环”对敌机数量进行循环，其目的是循环取出所有坐标，并在指定的坐标位置绘制敌机。

63-65行：

在正式绘制敌机之前，对计数进行累积+1的操作，并判断其数量是否大于敌机位置数组数量，如果超出范围就跳出循环，防止游戏出错。

66行：

取出位置数组所有成员的坐标，并在此坐标位置进行绘制敌机。

67行：

绘制的同时移动敌机纵向位置坐标，实现敌机飞行效果。

68-71行：

首先判断敌机位置是否超出显示范围，如果满足条件则在敌机位置数组中删除敌机，并将计数进行-1，防止因敌机数量问题导致程序错误。

循环结束后，将计数赋值为0，以便于下次使用。

10.4 调试游戏，最终可看到敌机被成功绘制。

11、 绘制子弹

11.1

(1) 首先定义一个位置数组对象，用于存放子弹位置。

(2) 添加画板组件的鼠标左键被按下事件，判断其来源对象是否为主画板，并且是否已经开始游戏。

(3) 如果两个条件都满足，则利用“播放WAV资源()”方法播放发射声音。

(4) 取出主画板鼠标位置，并偏移一些像素，使子弹能够从操作飞机的机头位置发射。

(5) 最后将此位置对象加入到子弹位置数组对象中存储起来。

11.2 在敌机计数归0后，开始编写子弹绘制代码。

72-74行：

从子弹位置数组中取出子弹数量，并利用“计次循环”语句进行循环。

75-77行：

利用计数变量对游戏区域内显示的子弹进行计数，并判断其数量是否超过所有子弹数量。

如果计数超过了所有子弹数量，则证明数据异常，执行跳出循环操作。

78行：

取出子弹位置数组中存储的子弹坐标，并开始绘制子弹。

79行：

对子弹的纵向位置进行偏移，使子弹拥有移动效果。

80-83行：

判断子弹位置是否超出屏幕显示区域，如果满足条件则在子弹位置数组中，删除此子弹，并将计数累积-1。

最后计次循环结束，将计数归0，以便于下次循环使用。

11.3 最终游戏运行后，点击鼠标左键可以进行发射子弹。

12、子弹与敌机碰撞

想要实现子弹与敌机的碰撞检测，必然需要在绘制子弹时进行操作。

因此，这段代码可以编写在子弹绘制完毕后立刻进行碰撞检测（下图黄框内）。

85行：

定义一个敌机索引的整数变量，用于对敌机进行计数，同时也可以利用本变量从敌机位置数组中取出此敌机的坐标。

86行：

利用判断循环语句，判断敌机位置数组的成员数是否大于敌机索引，如果大于则进入循环，用于循环取出所有敌机位置，并将其位置和子弹位置进行对比，从而检测子弹是否与敌机发生碰撞。

87-88行：

首先判断计数变量是否为0，如果为0则跳出循环，防止从子弹位置数组中获取子弹位置时产生错误。

89-92行：

从子弹位置数组中取出子弹坐标，从敌机位置数组中取出敌机坐标。

这里可能会产生疑问，为什么敌机索引不需要-1？这是因为敌机索引的累加是在循环末尾进行，首次循环时本变量值为0，因此不需要-1。

93行：

通过比对横向位置和纵向位置判断子弹是否已经进入敌机范围内。

首先：子弹位置.横向位置 >= 敌机位置.横向位置 && 子弹位置.横向位置 <= 敌机位置.横向位置 + 40，用于验证子弹的横向位置是否已经进入敌机的横向位置范围内，如果进入则开始判断纵向坐标是否进入。

然后：子弹位置.纵向位置 >= 敌机位置.纵向位置 && 子弹位置.纵向位置 <= 敌机位置.纵向位置 + 50，判断子弹的纵向位置是否进入敌机纵向位置范围内。

如果以上两个条件全部满足，则证明子弹和敌机发生了碰撞，然后执行如果真子语句体的内容。

94-98行：

首先播放爆炸声音，并在敌机位置绘制爆炸图片，随后删除敌机和子弹，最后执行跳出循环。

99-100行：

如果真语句结束后，对敌机索引进行累积+1。在判断循环语句结束后，对敌机索引进行归0，以便于下次循环使用。

运行测试：

最终可看到当子弹和敌机发生碰撞时，敌机和子弹会同时消失。

注：因gif截图工具的问题，导致爆炸效果没有被录制上。

13、销毁敌机计数

(1) 想要实现计算敌机销毁数量，必然需要定义一个整数类型的成员变量，并在开始游戏之前将其重置为0。

可能会有疑问，整数变量的默认值为0，为什么还要重置为0？

这是因为在游戏过程中，当敌机销毁时此变量会发生改变，为了防止重新开始游戏时，累积上次的敌机销毁数量，因此在游戏开始之前需要重置为0。

(2) 在子弹与敌机发生碰撞后，将击毁数量累积+1。

(3) 最后在主画板绘制游戏界面后，在主画板的左上角位置绘制敌机销毁数量。

(4) 最终可看到当游戏运行后，敌机销毁时可在左上角看到敌机销毁数量。

14、操作飞机与敌机碰撞

操作飞机与敌机的碰撞检测，其原理和子弹与敌机碰撞检测一致，都是通过判断其横纵坐标位置来验证是否碰撞。

碰撞检测过程可以在敌机绘制完毕后进行操作，如下图黄框中的代码。

70-71行：

首先取出敌机坐标，便于接下来的坐标判断操作。

72行：

通过比对鼠标位置(即操作飞机坐标)横向位置和纵向位置判断是否已经进入敌机范围内。

首先：鼠标位置.横向位置 >= 敌机位置.横向位置 && 鼠标位置.横向位置 <= 敌机位置.横向位置 + 40，用于验证操作飞机的横向位置是否已经进入敌机的横向位置范围内，如果进入则开始判断纵向坐标是否进入。

然后：鼠标位置.纵向位置 >= 敌机位置.纵向位置 && 鼠标位置.纵向位置 <= 敌机位置.纵向位置 + 50，判断操作飞机的纵向位置是否进入敌机纵向位置范围内。

如果以上两个条件全部满足，则证明操作飞机和敌机发生了碰撞，然后执行如果真子语句体的内容。

73-75行：

显示鼠标并弹出信息框，提示游戏结束以及被击毁的敌机数量。

76-80行：

根据按钮返回类型，如果不继续游戏则清除两个画板，并将是否开始游戏设置为假，同时将开始游戏按钮显示出来。

82行：

如果继续游戏，则隐藏鼠标。

83-86：

无论是否继续游戏，将击毁数量设置为0，并且删除所有敌机和子弹，同时跳出循环。

最终可以看到，当操作飞机与敌机发生碰撞后会触发游戏结束，并提示敌机销毁数量。

15、程序收尾

添加我的主窗口“窗口可否被关闭”事件，此事件的结果返回0表示允许关闭窗口，返回1表示不允许关闭窗口。

根据返回值特性，首先判断是否正在进行游戏，如果满足条件则显示鼠标，并弹出信息框提示用户是否结束游戏，根据用户选择的结果从而决定是接续游戏。

如果当前不处于游戏状态，则直接返回0，关闭当前窗口。

运行效果：

3、案例下载

点击下载当前教程案例。

[上一章]


火山软件开发入门教程目录_火山软件开发平台入门教程目录

关于本教程

联系方式


联系火山平台_火山软件开发平台

武汉递归软件开发有限公司

[官方网站] [软件购买] [用户论坛]

官方QQ群①: 496038411

官方QQ群②: 895033329

官方QQ群③: 1147071006

客服QQ: 378821858(请注明事由)

电子邮件: service@voldp.com

微信公众号:

鄂ICP备18029190号


火山软件开发平台

安卓程序开发手册

一. 如何使用安卓资源

1. 安卓资源及其种类:

安卓资源为直接打包进所编译的结果APK文件,在运行时可以直接取用的资源数据(类似于Windows EXE程序中的资源).

安卓资源分为很多种类,具体查看方法为: 打开任意一个火山安卓程序工程,然后双击打开"系统/基本类/安卓基本类"过滤器下的"a_res.v"源文件:

查看其中定义的相关类的继承结构,即可得知安卓资源的分类结构如下:

注: 对于普通用户来说,仅需要了解和使用最常用的"文本资源"以及"可绘制资源"中的"图片可绘制资源"即可,其它的可以忽略.

安卓资源:

文件资源: 通过文件来提供相关数据的资源.

1. 属性动画资源

2. 居间动画资源

3. 颜色表资源

4. 可绘制资源: 记录绘制图像时所使用数据的文件资源. 其子类别请在系统帮助中查看"系统库/火山.安卓.基本/可绘制对象"分类,具体这些资源的说明和用法如果感兴趣可以阅读该分类中对应类的注释.

图片可绘制资源: 记录图片数据的文件资源

颜色可绘制资源

动画可绘制资源

梯度可绘制资源

状态列表可绘制资源

裁剪可绘制资源

多层可绘制资源

级别列表可绘制资源

嵌入式可绘制资源

缩放可绘制资源

5. 菜单资源

6. 原始数据资源

7. XML数据资源

值资源: 使用值文本来提供相关数据的资源.

可设置值资源: 可以直接通过对应火山常量/变量的初始值来提供资源值文本的资源.

8. 文本资源: 记录一段文本的值资源

9. 逻辑值资源

10. 颜色值资源

11. 尺寸值资源

12. 整数值资源

13. ID值资源

14. 数组资源

其中带有数字系列标识的为真实存在的资源类别.

2. 如何定义和使用安卓资源:

● 定义安卓图片资源的方法为:

1. 在数据类型为"可绘制资源"类的常量/变量的初始值中提供相关图片文件名(见下面例图中的"图片资源常量1"和"图片资源变量1"定义);

2. 为数据类型匹配"可绘制资源"类的属性直接提供相关图片文件名属性值(见下面例图中"变量1"的"测试属性2"属性值,此处同时定义和使用了图片资源).

安卓编译器会自动收集所有被使用到的用户图片资源,并将其编译进目的APK文件中去.

● 使用安卓图片资源的方法为:

1. 在程序中任何可以匹配"可绘制资源"数据类型的位置均可使用,包括属性表和程序语句;

2. 可以通过"资源管理器"类中定义的"载入可绘制资源"全局方法来载入所指定的图片资源,获得载入后的"可绘制对象类"对象实例.

● 定义安卓文本资源的方法为:

1. 在数据类型为"文本资源"类的常量/变量的初始值中提供相关文本内容(见下面例图中的"文本资源常量1"和"文本资源变量1"定义);

2. 为数据类型匹配"文本资源"类的属性直接提供相关文本属性值(见下面例图中"变量1"的"测试属性1"属性值,此处同时定义和使用了文本资源).

安卓编译器会自动收集所有被使用到的用户文本资源,并将其编译进目的APK文件中去.

● 使用安卓文本资源的方法为:

1. 在程序中任何可以匹配"文本资源"数据类型的位置均可使用,包括属性表和程序语句;

2. 可以通过"资源管理器"类中定义的"取文本资源"全局方法来获取指定文本资源所对应的文本内容.

注: 以上对安卓图片资源的定义和使用方法适用于所有"文件资源",而对安卓文本资源的定义和使用方法适用于所有"可设置值资源".

例图:

3. 如何定义能够自适应设备环境的安卓资源:

本节内容普通用户稍微了解一下即可,无需深入.

安卓资源有个特点,就是能够根据当前程序所运行的设备环境自动提供相关的匹配数据.也就是说,一个安卓资源可以同时准备有多份数据,然后在运行时根据当前设备环境的具体情况来提供最合适的那一份.

1. 安卓修饰符:

我们首先需要了解"安卓修饰符"的概念:

安卓修饰符是一段文本,其用作指定一个特定的设备环境,为安卓资源提供数据时可以通过安卓修饰符来指定其将应用到的特定设备环境.

请执行系统中的"工具->安卓修饰符建立器"菜单项:

所弹出的对话框中提供了很多设备特性,随意选择几个,然后点击"生成安卓修饰符"按钮. 譬如:

此修饰符文本"en-large-land"就对应了语言类型为"英语",屏幕大小类型为"大",屏幕旋转方向为"横向"的设备环境.

我们可以利用此工具生成自己所需要的适用于任意指定设备环境的安卓修饰符文本.

2. 如何为一个安卓"文件资源"准备多份数据:

我们打开随系统附带的例程解决方案"samples\samples.vsln",在里面找到"其它/自适应_多语言"项目,双击打开其中的"main.v"源文件.

查看其中的以下代码:

由于"图片框"组件的"图片"属性的数据类型为"可绘制资源"(见下图), 根据我们前面的描述,"pic-zh.png"定义并使用了一个安卓图片资源,其图片文件名为"pic-zh.png".

"pic-zh.png"文件名为一个特殊格式,其中包含了指定该资源数据在哪种设备环境下使用的安卓修饰符"zh",具体格式为: "文件名前缀 + 减号 + 安卓修饰符 + 文件名后缀".

那么,安卓修饰符"zh"是什么意思呢? 我们再次打开"工具->安卓修饰符建立器"菜单项,然后选择语言种类为"中文",点击"生成安卓修饰符"按钮:

可以看到,安卓修饰符"zh"代表了语言种类为"中文"的设备环境,也就是说,所提供的"pic-zh.png"图片文件仅在设备的当前语言为"中文"时才会使用.

那么,该程序中是否还为此图片资源提供了其它的数据呢? 我们看一下"a_res.v"中"文件资源"类的注释:

其中的"条目1"详细阐述了如何搜寻文件资源其它数据的算法,我们将编辑光标移进"图片"属性的属性值列,然后点击其右边的按钮:

可以看到在同一目录下还有另外一个名为"pic-en.png"的文件:

对于"en"安卓修饰符,我们采用前面的方法同样可以知道: 安卓修饰符"en"代表了语言种类为"英文"的设备环境.

到此就很清楚了,我们为这个图片资源准备了两份数据,分别是在中文设备环境下使用的"pic-zh.png",及在英文设备环境下使用的"pic-en.png".

我们只需要指定资源数据所适用的设备环境即可,具体的运行时切换工作由安卓操作系统自动完成.也就是说,在中文设备下这个图片资源将自动使用"pic-zh.png",在英文设备下这个图片资源将自动使用"pic-en.png".

3. 如何为一个安卓"可设置值资源"准备多份数据:

我们查看"自适应_多语言"项目"main.v"源程序的以下部分:

由上图可以看到,"文件资源"是通过在文件名中附加安卓修饰符来指定其所应用到的设备,而"可设置值资源"是通过"@安卓.值资源"属性来指定其所应用到的设备(在"@安卓.值资源"属性名后 + 句点 + 所欲指定的修饰符文本),譬如上图中的"@安卓.值资源.en"即用作指定在英文设备下"程序标题"文本资源的文本内容.

可以同时提供多个"@安卓.值资源"属性来同时指定在不同设备下的值资源内容,如:

同上所述,我们只需要指定"可设置值资源"数据所适用的设备环境即可,具体的运行时切换工作由安卓操作系统自动完成,也就是说,在英文设备下"程序标题"文本资源的文本内容为"My Application",在其它设备下将自动切换为"我的程序".

附"自适应_多语言"项目在不同语言设备下的运行界面截图:

中文设备 英文设备

4. 使用大尺寸图片资源的注意事项:

如果你的程序中所使用的图片尺寸较大,需要注意安卓应用程序存在如下限制:

安卓操作系统给每个应用程序只分配了一定量的图片存储空间(8M左右),如果超出这个限制,在加载图片的时候就会报内存溢出运行时错误(Out Of Memmory),从而中断退出程序.

如下图的程序,如果"test.png"图片尺寸过大(注意此处的"尺寸"不是指图片文件本身的尺寸,而是指图片的宽度和高度),将有可能出现上述错误,导致应用程序中断退出:

比较妥善的解决方案为,如果您的图片尺寸过大,请采用如下方式使用:

"位图可绘制对象类"的"从资源创建"方法支持在载入图片数据的同时进行采样压缩,这样就可以避免占用过多的内存,导致载入出错.具体请参见该方法的注释.

以上内容了解一下即可.

二. 如何设计安卓界面布局

1. 窗口类及如何启动其界面布局设计器

任何直接/间接基础类为系统类"窗口"的类即为窗口类:

每个窗口类定义了一个安卓窗口,在其代码范围(包括其中的所有成员定义)内任何一个位置点击鼠标右键,选择"设计xxx的界面布局"菜单项即可启动该窗口类的界面布局设计器:

注意,如果该菜单项为灰色不可用状态,请检查以下几项:

A. 右键所点击位置是否位于该窗口类的代码范围内;

B. 该窗口类所处源文件是否被加入了项目中:

C. 该窗口类所处项目内是否加入了系统基本类库(即是否存在"Java基本类"和"安卓基本类"过滤器):

只有满足以上条件,才能启动该窗口类的界面布局设计器.

正常情况下,任何火山安卓项目中的源文件必定能满足此要求,但是如果直接打开某个不位于项目中的源文件,该条件将无法满足,此时应该先将其加入到某个 火山项目中后再打开.

以上条件是否满足的一个很简单验证方法为: 右键单击基础类"窗口",所弹出的菜单项"跳到窗口定义位置"为可用状态即表示前面的条件被满足,此时必定可以启动该窗口类的界面布局设计器.

2. 窗口界面布局设计器结构及操作说明

单击"设计xxx的界面布局"菜单项即可启动该窗口类的界面布局设计器:

点击"布局内容"按钮切换到布局内容夹后:

在上图中,标注了界面设计器的各个组成部分.

下面为界面设计器组成部件及相关操作说明信息:

1. 相关操作快捷方式

A. 在设计器中任何位置:

Ctrl+Z: 撤销;

Ctrl+Y: 重做.

B. 在"设计预览区"或"当前布局内容框":

Alt+Enter: 跳转到所选中组件的属性表;

Delete: 删除;

Ctrl+C: 复制;

Ctrl+V: 粘贴进去(目标组件为容器组件时) / 粘贴到前方(目标组件为非容器组件时);

Ctrl+Shift+V: 粘贴到后方;

Ctrl+Alt+V: 粘贴到前方;

鼠标左键单击: 选中所指定组件,同时取消先前所选择组件;

Shift+鼠标左键单击: 同时选中多个组件;

Ctrl+鼠标左键单击: 翻转所指定组件的当前选中状态;

鼠标左键按下可以拖动当前被选中组件的位置,拖动时同时按下Shift键为复制拖动,拖动过程中按下ESC键或鼠标右键则取消拖动.

2. 状态提示框

用作提供当前操作的相关状态文本信息

3. 组件工具箱

组件工具箱中列出了所有可以加入到窗口布局中的组件.

A. 组件分为两类: "非容器组件"和"容器组件",容器组件内可以加入其它子组件,非容器组件则不能.

点击组件工具箱底部的"基本容器组件"按钮即可切换到容器组件夹:

B. 有些容器组件不支持加入子组件(如列表框,表格等),还有些容器组件中只能加入一个子组件(如横向滚动容器,纵向滚动容器等),如果您在操作时发现新的组件无法加入到所指定容器组件中,就需要检查这方面的原因;

C. 组件工具箱中的可用组件是系统自动从当前项目的用户和系统源文件中(直接/间接基础类为"窗口组件"的类)提取出来的,如果您自己开发的组件未能被列入到组件工具箱中,请在界面布局设计器启动后立即查看"状态提示框"中的内容,里面会有详细 的载入失败错误原因提示;

D. 因为上一条中的原因,如果组件工具箱中的组件缺失或者没有,请检查您的项目中是否加入了安卓基本类库中的相关系统源文件:

E. 将工具箱中的组件加入到窗口布局中的方法:

直接将所欲加入的组件从工具箱中拖动到"设计预览区"或者"当前布局内容框"内的指定位置即可.

拖动到当前布局内容框中时如果同时按下Ctrl键,可以拖到目标组件的内部(目标组件为容器组件时)或后面(目标组件为非容器组件时),否则默认为始终拖到目标组件的前面.

4. 设计预览区

提供当前布局的预览状态,预览时所使用尺寸由"预览尺寸调节框"决定.在预览区中可以进行的操作见前面的"相关操作快捷方式"节.

5. 预览尺寸调节框

该组合框用作设置当前设计预览区的预览尺寸.

注意: 窗口布局预览尺寸仅在预览时使用,对于窗口布局结果数据没有任何影响.

组合框中已经内置了大部分常用尺寸,如果其中没有您所需要的尺寸,可以使用"<管理自定义尺寸...>"项目自行定义 添加.

6. 当前布局内容框

当前布局内容框中列出了当前布局中的所有组件及其层次结构,在其中所可以进行的操作见前面的"相关操作快捷方式"节.

7. 被选中组件提示框

在该提示框中列出了当前所有被选中组件的名称.

8. 被选中组件属性表

用作显示和修改当前所有被选中组件的属性.

每个组件的属性分为两类,一种是组件自身的属性,另一种是组件所处的父组件要求其提供的属性.前一类属性称为"自有属性",后一类属性称为"布局属性".

注意: 具体有哪些布局属性由组件所处父组件而不是组件自身来决定.

如编辑框组件的自身属性:

当编辑框组件位于"线性布局器"组件内时的布局属性:

注: 可以使用连续两个英文双引号""作为文本属性的内容以强制提供空文本属性值(属性内容为空表示使用默认属性值).

9. 已有布局列表框

窗口布局设计器支持在同一个窗口布局中同时设计用作匹配多种目标设备环境的布局数据(相关概念见前面的"如何定义能够自适应设备环境的安卓资源"章节).

在此列表框中,可以复制建立针对指定安卓修饰符的布局数据,该布局数据只会在安卓程序当前运行的设备环境匹配此安卓修饰符时才会被 自动使用. 如:

其中的"en-large"是一个安卓修饰符,用作指定该布局数据所应用到的设备环境.该修饰符是一个组合修饰符,其中的"en"表示为英文设备,"large"表示为大屏幕设备.

● 当窗口布局设计完毕按下确定按钮后,所设计的布局数据将被加入到对应窗口类中,譬如以下窗口布局:

在按下确定按钮之后,将在对应窗口类中加入以下代码:

具体打开所隐藏属性值的弹出菜单项为"杂类->显示/隐藏属性值".

所有在窗口设计器中设计的布局数据均存放在这些成员变量及其"@安卓.窗口.布局"属性值中,因此可以直接复制/移动/修改这些代码.

如果同时设计了可应用到多种设备的布局数据(譬如前面所提到的),将会加入类似以下代码:

"@安卓.窗口.布局.en-large"属性为""@安卓.窗口.布局"属性的扩展,后面附加了所对应的安卓修饰符.

3. 相对布局方式

如果您开发过Windows程序,就一定知道,设计Windows程序窗口界面时采用的是绝对布局方式(即精确指定某个组件在窗口中所处的位置和尺寸),但是这种布局方式在安卓系统下是行不通的,这是为什么呢?

道理很简单: Windows程序界面的显示设备只有一种: 电脑屏幕,并且各种屏幕的DPI(每英寸像素数)和物理尺寸相差无几,而安卓程序界面的显示设备却是千千万万,其设备显示屏的DPI和物理尺寸可能相差很大,譬如电视机上可以运行安卓程序,手机上可以运行安卓程序,甚至只有很小屏幕的随声听/运动手环上也可以运行安卓程序,此时使用绝对布局方式将是一个噩梦,你根本无法设计出可以同时在各种安卓设备上正常显示的窗口界面.

由于以上原因,安卓程序采用的是相对布局方式,也就是说,某个组件的实际位置和尺寸是与其周边组件相关的.

注: 虽然无法使用以前开发Windows程序所习惯的绝对布局方式会让您觉得有点麻烦,但是 相对程序的环境可适应性及后续维护工作量,您最终会觉得这点麻烦是很值得的,而且您很快就能发现,相对布局方式也很容易学习.

4. 线性布局器

线性布局器是相对布局器中最常用的一种,它将其中的所有子组件按照所指定的布局方向(横向/纵向)顺序排列.

通过同时使用具有不同布局方向的线性布局器,我们可以非常简单方便地设计出所需要的窗口界面,并且所设计出来的窗口界面对各种安卓设备屏幕的适应性都很好.

● 布局方向为"纵向"的线性布局器使用示例:

上图中的线性布局器内顺序加入了"文本框","编辑框","按钮"3个组件,可以看到,它们在线性布局器中是 按纵向顺序排列的.

● 布局方向为"横向"的线性布局器使用示例:

上图是同样的组件在布局方向为"横向"的线性布局器中的排列效果.

● 可以将横/纵向线性布局器混合起来使用,这样就可以达到组件既可以纵向排列,也可以横向排列 的目的. 如:

线性布局器的自有属性有这些:

线性布局器要求其中的子组件所提供的布局属性有这些:

下面一一进行讲述.

A. 自有属性:
1. 布局方向

可以为"横向布局"和"纵向布局"两种属性值,用作指定 线性布局器具体的布局方向.

这个属性在前面已经讲述过了.

2. 剩余空间总权重

什么是"剩余空间",对于纵向线性布局器来说,就是其纵向空间尚未被填满的尺寸. 如:

对于横向线性布局器来说,就是其横向空间尚未被填满的尺寸. 如:

既然我们知道了什么是"剩余空间",那么"剩余空间总权重"属性也就很好理解了:

"剩余空间总权重"就是用作代表线性布局器当前剩余空间尺寸的一个权重值,该值可以是任意大于0的整数(一般使用100用作计算百分比),用作和线性布局器需要其中子组件提供的"剩余空间权重"布局属性结合起来,为每个子组件 指定其在剩余空间中的分配比例,比例值等于子组件提供的"剩余空间权重"属性值除于线性布局器的"剩余空间总权重"属性值.

是不是仍然有点不理解? 不要紧,先了解一下就好,我们在下面讲解"剩余空间权重"布局属性的时候再详细 讲述.

3. 内容横/纵向对齐

这个属性很好理解,就是用作对线性布局器中的所有子组件内容进行对齐定位.

注意: 本属性无法对所指定的单个子组件进行对齐定位,如有此要求,请使用对应子组件的"横向和纵向对齐"布局属性.

譬如我们将"内容横向对齐"和"内容纵向对齐"属性值均设置为"居中":

B. 布局属性
1. 左/右/顶/底外边距

这个属性很好理解,就是为布局器中的子组件在其四周加入所指定的外边距,譬如我们在上图中的布局中为"按钮1"组件加入属性值为50的左和顶外边距后的效果如下:

2. 组件宽度和高度类型

这两个属性很重要,它们用作确认组件的宽度/高度尺寸值.

以下以"组件宽度类型"属性进行讲述,"组件高度类型"除了尺寸方向不同,其它方面与"组件宽度类型"完全一致.

"组件宽度类型"属性值可以为三个常量之一:

A. 匹配内容宽度

组件的宽度等于其中内容的宽度. 譬如文本框的宽度等于其中文本的宽度,各种布局器的宽度等于其中所有子组件内容的宽度,等等.

下图为在横向线性布局器中两个宽度类型均为此属性值的文本框和按钮的设计和实际效果:

设计效果 实际效果

B. 匹配父组件宽度

组件的宽度等于其父组件的宽度减去组件左侧的位置. 也就是说,组件的右侧将与父组件的右侧对齐.

注意: 在一个容器组件中,只能有一个而且只能是最后一个子组件的宽度类型可以设置此为属性值,否则将导致其它子组件被排列到容器组件的右侧外部从而无法看到.

下图为将上图布局中按钮组件的宽度类型设置为此属性值后的设计和实际效果:

设计效果 实际效果

C. 直接指定

本属性值用作直接指定组件的宽度尺寸,一般用作和剩余空间分配算法(见后面关于"剩余空间权重"布局属性的讲述)配合使用以实现基于比例为单位的伪绝对布局.

注意:

1. 除了前述用途或用作分隔的"空白框"组件外,本属性值很少单独使用,因为它将造成程序界面对不同设备屏幕的适应性变差;

2. "组件宽度/高度类型"属性被设置为此属性值后,需要 同时在对应的"组件宽度/高度值"属性中指定具体的尺寸值.

3. 横向和纵向对齐

本布局属性用作指定组件在其所处线性布局器中的横/纵向对齐方式.

注意: 如果组件所处线性布局器的布局方向为横向,则只能指定组件的纵向对齐方式,如果线性布局器布局方向为纵向,则只能指定组件的横向对齐方式.

下图为一个横向线性布局器中具有各种对齐方式组件的设计和实际效果:

设计效果 实际效果

4. 剩余空间权重

我们在前面讲述了什么是"剩余空间"以及"剩余空间总权重"属性,也讲述了组件的"剩余空间权重"属性值除于其所处线性布局器的"剩余空间总权重"属性值为该组件在线性布局器剩余空间尺寸中的分配比例.

下面我们以先前的一张图作为例子进行讲述:

我们现在将"文本框1"的"剩余空间权重"属性值设置为50,将"编辑框1"的"剩余空间权重"属性值设置为30,当前布局将成为以下效果:

因为线性布局器的"剩余空间总权重"属性值默认为100,那么根据为以上组件所设置的"剩余空间权重"属性值进行除法运算,可以很容易的得到"文本框1"的高度上将附加剩余空间 高度尺寸的50%,"编辑框1"的高度上将附加剩余空间高度尺寸的30%,剩余空间高度尺寸还剩下20%未被分配,其位于最后一个组件"按钮1"的下方.

注意:

1. 如果线性布局器内存在"组件宽度/高度类型"属性值为"匹配父组件宽度/高度"的直接子组件,那么由于线性布局器所有剩余空间都将被该子组件所占用,本算法将无法取得效果;

2. 如果使用剩余空间权重来进行布局,而相关组件的"组件宽度/高度类型"属性 值不为"直接指定",那么所具体分配的空间还会受到这些组件的自身宽度/高度分配算法的影响,如果要去除这些影响,请参考下一节;

3. 横向线性布局器的此属性效果与纵向线性布局器的一致,只不过两者剩余空间的尺寸'方向不同而已.

● 使用"组件宽度/高度类型"属性的"直接指定"属性值与剩余空间分配算法配合实现基于比例的伪绝对布局的方法:

下图布局中有3个按钮,它们具有不同的字体大小,其中"我的按钮1"的"文本字体尺寸"属性值为20,"我的按钮2"的"文本字体尺寸"属性值为30,"我的按钮3"的"文本字体尺寸"属性值为40. 该布局的设计和实际效果分别为:

设计效果 实际效果

注意: "文本字体尺寸"属性在设计时不支持预览

现在我们有一个要求,就是将每个按钮的高度尺寸都设置为一样,但是不能直接指定其高度值,因为这种方法无法适应各种设备.

我们可以将每个按钮的"剩余空间权重"属性值设置为同一个固定值(譬如30)来指定为其附加相同尺寸的剩余空间,但是现在有一个问题,就是每个按钮的 自身高度因为其文本字体尺寸的不同而不同,而这个高度值我们无法预知,因此只是简单地设置"剩余空间权重"属性值是无法达到我们的要求的.

见下方左图,3个按钮的高度明显不一致(右图中为正确的高度尺寸):

为了屏蔽掉按钮的内容对其高度的影响,我们把所有按钮的高度值直接指定为0或者某个固定值(该固定值可以用作指定按钮的最小高度),这样在同一设备屏幕上该线性布局器的剩余空间尺寸就是一个固定值了,然后再同时设置按钮的"剩余空间权重"属性值,就可以达到我们的目的.

下图为修改后布局的设计和实际效果:

设计效果 实际效果

根据上述算法,我们可以很轻易地将某个子组件的位置和尺寸指定为一个基于线性布局器空间尺寸的明确比例值,如果组件之间存在空白区域,我们可以使用"空白框"组件来进行填充.

● 下面提供一些常用布局的设计方法与实际效果(具体例程请参见系统安装目录的“samples\samples.vsln”解决方案中的"复杂窗口布局展示"项目):

1. 复杂工作区布局

设计效果 实际效果

布局组件说明:

图示序号 | 组件类型 | 组件属性表
1 文本框 文本 = "标题内容"

剩余空间权重 = 100

2 | 按钮 | 文本 = "处理按钮"
3 线性布局器 布局方向 = 横向布局

剩余空间总权重 = 100

组件宽度类型 = 匹配父组件宽度

4 按钮 文本 = "右上工作区"

组件宽度类型 = 匹配父组件宽度

5 按钮 文本 = "右下工作区"

组件宽度类型 = 匹配父组件宽度

组件高度类型 = 匹配父组件高度

6 按钮 文本 = "左侧工作区"

组件高度类型 = 匹配父组件高度

剩余空间权重 = 30

7 线性布局器 布局方向 = 纵向布局

组件高度类型 = 匹配父组件高度

剩余空间权重 = 70

8 线性布局器 布局方向 = 横向布局

剩余空间总权重 = 100

组件宽度类型 = 匹配父组件宽度

剩余空间权重 = 100

9 空白框 组件高度类型 = 直接指定

组件高度值 = 20

10 线性布局器 布局方向 = 横向布局

剩余空间总权重 = 100

组件宽度类型 = 匹配父组件宽度

11 | 按钮 | 文本 = "处理按钮"
12 | 空白框 | 剩余空间权重 = 100
13 | 按钮 | 文本 = "确定"
14 | 按钮 | 文本 = "取消"

2. 表格布局

设计效果 实际效果

布局组件说明:

图示序号 组件类型 组件属性表
1 线性布局器 布局方向 = 横向布局

剩余空间总权重 = 100

剩余空间权重 = 20

组件宽度类型 = 匹配父组件宽度

2 按钮 文本 = "0" -> "9"

剩余空间权重 = 30

组件宽度类型 = 直接指定

组件宽度值 = 0

组件高度类型 = 匹配父组件高度

3 空白框 剩余空间权重 = 5

组件宽度类型 = 直接指定

组件宽度值 = 0

4 空白框 剩余空间权重 = 6

组件高度类型 = 直接指定

组件高度值 = 0

5 按钮 文本 = "="

剩余空间权重 = 65

组件宽度类型 = 直接指定

组件宽度值 = 0

组件高度类型 = 匹配父组件高度

注意: 布局中具有相同类型和属性的组件只列出了其中的一个

--- 完 ---