精结绳文档1.4（搬运）

# 结绳速通文档

## 简介

结绳（Tiecode）是一款面向对象的编程语言，它允许开发者使用中文编写代码，从而降低了编程的语言**门槛**。结绳支持**跨平台**应用开发，使得开发者能够使用**同一套**语法来创建适用于不同操作系统的应用程序。这种设计特别适合编程初学者，因为它简化了学习过程，并且使得编程更加直观易懂。

> 

 

## 第一章：概念

### 1.0 对象

面向对象编程最重要的概念是对象，对象可以**指代**万物，例如，地球、汽车、飞机、人等等，一切皆为对象。

### 1.1 类

类是类型的简称，世间万物都是对象，那么就需要利用类型来**区分**它们，例如：人类、植物类、矿物类、食物类等等。

### 1.2 继承

继承是指一个类（子类）可以继承另一个类（父类）的特性和行为。这就像孩子从父母那里继承**特征**一样。想象一下，如果你有一个食谱书，每个食谱都是一个“类”，而你根据食谱做出的每一道菜就是“对象”。如果你有一个基础食谱，比如“蛋糕”，然后你可以根据这个基础食谱做出巧克力蛋糕或草莓蛋糕。这里的“蛋糕”就像是父类，而“巧克力蛋糕”和“草莓蛋糕”就像是继承了“蛋糕”特性的子类。

### 1.3 多态

多态是指不同类的对象可以对**同一请求**做出**不同的响应**。这就好比不同的动物对“叫”这个动作有不同的表现。

### 1.4 封装

这就像一个遥控器，你不需要知道遥控器里面是怎么工作的，你只需要知道哪个按钮是用来换台的。封装就是把复杂的东西**藏起来**，只让你看到和使用你**需要**的部分。

## 第二章：语法

相比起其他编程语言，结绳的语法非常简洁易懂，很适合中国宝宝们。

### 2.0 变量

变量这个概念原本来自**数学**，你可以将它理解为一个带有标签的箱子，标签上会写着**名称**和**类型**，而箱子里面可以用来装变量的**内容**。程序会根据名称和类型找到对应的箱子，从里面**拿**东西或者把东西**放**进去，但是这个东西的类型必须和箱子标签上的类型**一致**或者是它的子类型(也就是继承它)。

定义变量的基本语法为：`变量 变量名 : 变量类型 = 初始值`，示例：

“`tie

变量 早餐 : 食品 = 面包

// 表示今天的早餐是面包

“`

如果没有初始值，那么`=`和后面的可以省略，示例：

“`tie

变量 早餐 : 食品

// 表示不知道今天的早餐是什么

“`

在结绳中，如果一个变量没有显式定义初始值，那么它自动创建一个初始值，示例：

“`tie

变量 数字 : 整数

// 后面并没有为它赋值，但是它此时的值为0

“`

在结绳中，定义变量时，它的默认值通常不会是**空值**，除非是你**手动**赋值为空。因为结绳会自动为没有默认值的变量创建一个对象。

如果你需要定义一个不包含任何值的变量，也就是**空值**，可以在变量类型后面添加`?`，示例：

“`tie

变量 早餐 : 食品?

// 同样是不知道今天的早餐是什么，但是这里是明确不知道。而前面的会有默认值，也就是你在不知道吃什么的情况下会下意识的吃什么

“`

在定义变量的语法中，你也可以使用`为`关键词来替代`:`符号，示例：

“`tie

变量 早餐 为 食品 = 面包 // 知道今天的早餐是面包

变量 午餐 为 食品 // 不知道今天的午餐吃什么，但是我会找点东西填饱肚子

变量 晚餐 为 食品? // 不知道今天的晚餐吃什么，那就不吃了

“`

### 2.1 常量

它本质上也是变量，但它不能修改，只能赋值一次，之后就只能访问了。示例：

“`tie

常量 早餐 : 食品 = 面包 // 表示每一天的早餐都固定是面包

常量 午餐 : 食品 // 表示每一天午餐都不知道吃什么，看情况吃点

常量 晚餐 : 食品? // 表示每一天都不吃晚餐

“`

### 2.2 数组

数组这个概念也是来源于数学，如果说变量是**单个**箱子，那么常量就是**并排**的多个箱子，这牌箱子有一个共享的标签，也就是**变量名**，而每个箱子也有自己的标签：**索引**，其实就是“序号”的意思，用来表示这个箱子是第几个箱子。索引是从0开始的数字，0表示第一个，1表示第二个，2表示第三个……等等。

定义数组变量的时候，需要在**变量类型**后面添加`[]`，有**2种**定义数组变量的方式。

* 方式1 根据长度定义数组变量

“`tie

变量 喜好 : 文本[长度]

“`

长度就是数组可容纳的元素的**数量**，数组长度**必须**填写**正整数**，也就是不能包含小数点且不能小于0。如果你不填写长度，那么默认就是0，示例：

“`tie

变量 喜好 : 文本[3] // 表示可以包含3个喜好

变量 习惯 : 文本[] // 这里没有写0，但是默认是0，表示没有习惯

“`

> 使用这种方式定义的数组变量，其中每一个元素的值都是**默认值**，如果是**基本类型(暂时不在这里讲解)**，则会有对应的默认值，例如整数是0，如果是**定义的类型**，如面包等，默认值是**空**，就是什么都没有。

 

* 方式2 根据元素定义数组变量

“`tie

变量 喜好 : 文本[] = { “吃饭”, “睡觉”, “打游戏” }

“`

赋值时需要用`{`和`}`把每一个**元素(对象)**框起来，每一个元素之间使用`,`来分隔。这样数组的长度就是你给的元素的数量。

 

> 两种定义数组的方式**不能**同时使用！为什么呢？因为假如你定义的数组长度和后面赋值的元素个数不一样怎么办？比如你定义的数组长度是10，但你却给它赋值了20个元素，即便反过来数组长度是20，元素数量是10个也不行，程序无法帮你补全元素数量，也不会帮你裁剪多余的元素

 

数组的长度是固定的，一旦定义就**不能**再修改，但是可以用索引**更换**数组里的元素。数组本身也是**对象**，也可以使用`=`来覆盖它，示例：

“`tie

变量 今天吃什么 : 食物[] // 表示什么都没有

变量 昨天吃什么 : 食物[] = { 面包, 炸鸡, 面条 } // 吃3样东西

今天吃什么 = 昨天吃什么

// 所以“今天吃什么”的值为：[面包,炸鸡,面条]，和“昨天吃什么”一样

“`

这样就把“昨天吃什么”变量包含的内容**复制**给了“今天吃什么”变量，而这个变量的原内容也会因此丢失，这是唯一能改变数组长度的方法。

可以这样理解数组和变量的关系：数组是装在**一个**箱子里的**一排**箱子，也就是箱子套箱子。

> 后面这段关于“多维数组”的内容可能有些困难，不是必须理解的，简单看一下即可

 

—

 

数组可以是多维的，只需要增加`[]`的组合即可，示例：

“`tie

变量 数组 : 文本[2][2] // 定义了一个2×2的二维数组

变量 数组2 : 文本[][] = {

   { “元素1”, “元素2”, “元素3” },

   { “元素4”, “元素5”, “元素6” }

}

“`

多维数组并不常用，例如二维数组和三维数组一般用于定义**游戏地图**，而四维再往上就很难理解了，大多数人都做不到，所以不要和多维数组死磕。

 

—

 

从数组中**取值**和**赋值**都要使用`[]`，示例：

“`tie

变量 旅游景点 : 文本[] = { “敦煌莫高窟”, “北京故宫”, “杭州西湖” }

旅游景点[0] = “长城” // 把第一个元素(敦煌莫高窟)替换成长城

变量 我要去的景点 : 文本 = 旅游景点[0]

// 从旅游景点里获取第一个元素(长城)，因此我要去的景点的值为：长城

“`

多维数组的取值和赋值也是叠加`[]`，示例：

“`tie

变量 地图 : 逻辑型[][] = {

   { 真, 假, 假 },

   { 真, 真, 假 },

   { 假, 真, 真 }

}

地图[1][2] = 真 // 修改了第2行第3个元素为真，本来为假

变量 值 : 逻辑型 = 地图[1][2]

// 获取了第2行第3个元素，此时值为：真

“`

注意，数组常量也不能同时定义数组长度和赋值哦！示例：

“`tie

常量 数组 : 整数[10] = { 1, 2, 3 } // 这样是错误的，原因已经在前面解释过了

// 这样才是正确的：

常量 数组2 : 整数[10]

常量 数组3 : 整数[] = { 1, 2, 3 }

“`

### 2.3 方法

方法也叫**函数**，可以理解为一种**行为**、**动作**，也是程序实际上**做**的事情。比如，每个人都有**吃饭**方法，当自己想要吃饭时，就会调用吃饭方法，此时身体会做出动作，开始吃东西。方法可以包含**返回值**、**参数**等附加信息，以下是介绍：

1. 返回值

返回值可以视为一个**临时变量**，也就是不需要你自己定义的变量，程序会自动创建它。返回值同样包含**类型**和**内容**，如果方法包含返回值，那么它会在此方法里的所有代码**执行完毕**后，把结果**放**进返回值里，然后传给**调用**此方法的地方。

比如，你的朋友询问你：吃什么？此时你执行了一个“取想吃的食物”方法，根据你的思考，你决定告诉朋友你想吃蛋糕，于是返回“蛋糕”。

方法的返回类型和返回值**必须同时存在**，缺一不可！没有返回类型的方法**不能**用**返回**来返回数据，写了返回类型的方法也**必须**使用**返回**来返回数据。

2. 参数

方法参数本质上也是变量，可以表示执行这个方法**需要**什么条件，调用这个方法的地方必须满足这个方法所需要的**全部参数**。比如，你去商店购买一件物品，你把商品交给收银员，调用了他的“结账”方法，结账方法需要一个**小数(包含小数部分的整数)**类型的参数，名字是“金钱”，告诉你要付钱。此时你把那件物品的价格交给收银员，收银员在**执行结账动作**后就会把商品交给你，也就是返回给你。

注意，不能在方法里面试图通过参数把**数据**传递给调用的地方，收银员不能把钱再还给你。因为参数也是临时的，调用方法的地方只能为它赋值，不能取值。而方法内部可以为它赋值，把它当成一个临时的箱子保存数据，这样做也会**覆盖**参数里原来的内容。

 

定义方法的语法如下：

“`tie

方法 计算(数1 : 整数, 数2 : 整数) : 整数

   // 有参数有返回类型方法

   返回 数1 + 数2

结束 方法

 

方法 取想去的旅游地点() : 文本

   // 无参数有返回类型方法

   返回 “神农山”

结束 方法

 

方法 吃饭(吃什么 : 食品)

   // 有参数无返回类型方法

结束 方法

 

方法 睡觉()

   // 无参数无返回类型

结束 方法

“`

 

方法的作用是用来封装其他方法，可以减少代码量，把需要用到的一系列动作放在一个方法里，以便**一键调用**，示例：

“`tie

方法 朋友叫我(关键词 : 文本) : 文本

   如果 关键词 == “吃饭” 则

      吃饭() // 执行吃饭方法

      返回 “吃完了” // 此时吃饭已经执行完毕了

   否则

      睡觉() // 执行睡觉方法

      返回 “睡醒了” // 此时睡觉已经执行完毕了

   结束 如果

结束 方法

 

方法 吃饭()

   // 这里可以调用封装的方法，例如

   // 盛饭()

   // 夹菜()

   // 张嘴()

   // 洗碗()

   // …

结束 方法

 

方法 睡觉()

   // 这里可以调用封装的方法，例如

   吃饭() // 呃……睡觉前先吃个饭？？所以横竖都是吃饭是吧！

   // 躺下()

   // 盖被子()

   // 闭眼()

   // …

结束 方法

“`

方法参数可以拥有**默认值**，示例：

“`tie

方法 今天吃什么(午餐 : 食品 = 面条)

   // 如果调用这个方法的地方没有传递参数，那么就使用默认值，即吃面条。注意，是没有传递参数，直接不写，而不是传递空值

   吃饭(午餐)

结束 方法

“`

调用方法的语法是`方法名(参数)`，示例：

“`tie

吃饭(面包) // 调用吃饭方法并传递面包参数

睡觉() // 调用吃饭方法且不需要传递参数

变量 今天天气 : 天气 = 获取今天的天气() // 调用获取天气的方法，把返回值赋值给变量

变量 计算结果 : 整数 = 加法运算(1, 2) // 调用加法运算并传递1和2，把结果赋值给变量。这个变量的值是3

“`

### 2.4 事件

**事件**和方法是差不多的东西，区别在于方法一般是**主动**调用的，而事件一般是**被动**调用的。语法：

“`tie

事件 我:刚睡醒()

   // 无参数无返回类型事件

结束 事件

 

事件 我:准备旅游() : 文本

   // 无参数有返回类型事件

   返回 “美食之乡”

结束 事件

 

事件 我:准备吃饭(吃什么 : 食品)

   // 有参数无返回类型事件

结束 事件

 

事件 我:加法计算(数1 : 整数, 数2 : 整数) : 整数

   // 有参数有返回类型事件

   返回 数1 + 数2

结束 事件

“`

事件的意思就是**字面意思**，它代表一件事情的发生过程，例如，你做了什么事，而那件事的过程就是事件。你吃了饭，那么你吃饭这件事就是事件，而你在吃饭过程中的动作就是事件里执行的方法。

事件可以直接调用，调用方式和方法是一样的，示例：

“`tie

我.准备吃饭(鸡腿)

我.刚睡醒()

变量 想去的地方 : 文本 = 我.准备旅游()

变量 作业 : 整数 = 我.加法计算(1, 2)

“`

 

—

 

## 间章

在了解了前面的知识以后，你看看这段代码：

“`tie

类 启动窗口 : 窗口

 

   事件 启动窗口:创建完毕()

      订阅事件()

      弹出提示(“你好，结绳！”)

   结束 事件

 

结束 类

“`

这段代码里面你能看懂多少呢？如果能全部看懂，说明你非常厉害。如果全部看不懂，可以再重新看一遍前面的知识。如果半懂半不懂，这是正常的，因为代码中还有没讲解的知识。我们再换一段代码：

“`tie

类 我 : 人类

 

   常量 最爱吃 : 食品 = 酸菜粉

 

   事件 我:刚睡醒()

      订阅事件()

      大喊一声(“吃饭，启动！”)

      吃饭(最爱吃)

   结束 事件

 

   方法 吃饭(吃什么 : 食品)

      吃好了()

   结束 方法

 

   事件 我:吃好了()

      说话(“呃~吃饱了，睡会儿”)

      睡觉()

   结束 事件

 

结束 类

“`

这样是不是更加容易理解了？如果你还是全部都看不懂，说明你需要再复习一下前面的知识。

 

—

### 2.5 如果

如果今天吃了饭，那么今天就不饿了，不然今天会饿肚子。一句话解释清楚“如果”的意思。它是一种逻辑**判断**结构，符合条件时执行一段代码，或者不符合条件时执行另一段代码。

如果的语法如下：

“`tie

如果 1 > 0 则

    // 1是肯定大于0的，所以条件符合，会执行下面这一行代码

    说话(“1大于0”)

结束 如果

“`

诶，如果你希望符不符合条件都执行代码怎么办？可以这样写：

“`tie

如果 1 > 2 则

    说话(“数学不存在了！”)

否则

   说话(“对啊，1怎么可能会大于2呢？”)

结束 如果

“`

如果2种结果都不够用的话，你还可以指定**无限**个条件：

“`tie

如果 1 == 3 则

   说话(“离谱了，1怎么可能等于3啊”)

// 从第1个“否则”开始，条件后面不能再写“则”

// 多个条件分支要使用“则 条件”的语法来定义，不能写“否则 如果 条件”或者“如果 条件”！

否则 1 == 2

    说话(“1也不可能等于2吧”)

否则 1 == 1

    说话(“这才对嘛，1肯定等于1啊”)

// …. 可以无限扩展哦

    // “否则”没有条件也不能再写“则”

否则

   说话(“1不等于1难道等于0吗？”)

结束 如果

“`

你有没有注意到，只有第一个“如果”后面是有“则”的，其他的而“否则”后面却没有，其实第一个“则”也是可以**省略**的哦！就像这样：

“`tie

如果 今天 < 明天

    说话(“今天将会过去，明天还未到来”)

结束 如果

“`

关键字“则”存在的意义就是增加阅读性，有没有它都不会对代码造成影响。不过，就算你想要更好的阅读性，也不能写太多“则”，只有“如果”的条件后面可以写，“否则”的条件后面不能写哦！

### 2.6 循环

这里解释一下循环的概念。循环的意思就是，重复发生一件事情，但是呢，事件里的因素可以变化。比如，某天你坐在公交车上睡着了，你听到一阵铃声，但是你对此毫不在意，突然，整辆车都爆炸了！你以为要死了，一下子你又回到车上，刚才发生的一切似乎就像做梦一样，此时你又听到了铃声，你决定不能坐以待毙，你马上要求司机停车，然后下车了，车子继续开动，没多久就发生爆炸了。有没有发现，车子陷入了循环，但是因素变化导致每次循环的结果不同，第一次循环，你什么都没做，顺其自然。第二次你中途下车。两次循环，车子都爆炸了，但是第二次爆炸你却一点事没有。

回归正题，循环有很多种方式，如下：

– #### 计次循环

你可以直接指定循环的次数。

– #### 遍历循环

这是一种便携的方法，快速遍历数组，循环的次数根据数组的长度(元素数量)决定。

– #### 判断循环

这是一种带了“如果”的循环，每次循环开始之前，都会先判断一次条件，如果符合了就会执行1次循环，下次循环开始时又会再判断1次，如果条件不符合了，那么循环就结束了。

 

#### 1. 计次循环

“`tie

循环(索引, 0, 520)

    // 520表示循环的次数，0表示从第1次开始执行

    说话(“这是第” + (索引 + 1) + “次我爱你”)

    // 如果索引等于519(520-1)则表示这是最后一次循环

结束 循环

// 在以上循环执行完毕后，索引的值才是520哦！

“`

在计次循环中，会有一个**索引**变量，它就是循环过程中影响结果的因素，这个变量的名称是可以自己定义的，比如索引1、索引2、序号等等。而上面的代码中的“520”表示循环的次数，“0”表示从第几次开始循环。在编程中，索引通常是从0开始算的，0代表第一次循环，1代表第二次循环，2代表第三次循环……以此类推，`次数 – 1`则代表最后一次循环。在循环完毕后，索引变量的值一般**等于**循环次数。比如在第520次循环**结束后**，索引的值是520。

 

#### 2. 遍历循环

“`tie

变量 旅游地点 : 文本[] = { “长城”, “故宫”, “三星堆” }

循环(旅游地点 -> 下一个地方)

   前往旅游(下一个地方)

结束 循环

“`

遍历循环可以用来快速遍历数组，遍历循环不要求你定义1个索引变量表示第几次循环，它会根据你给定的数组或集合的长度决定执行多少次循环，然后每次循环会按顺序从数组中取出1个元素作为可改变循环结果的**因素**给你使用。比如，第一次循环，**下一个地方**的值是**长城**，第二次则是**故宫**。

 

#### 3. 判断循环

“`tie

循环(是否开心())

    说话(“今天也很开心呢~”)

结束 循环

 

方法 是否开心() : 逻辑型

    返回 我.今天是否开心()

结束 方法

“`

判断循环每次循环开始之前，它都会先检查一遍**条件**，如果条件符合，也就是返回**真**，它才会开始1次循环。这一次循环完毕之后，它又会再判断一次，直到条件不再符合为止。在上面的代码中，如果**是否开心**方法返回了**真**，循环就会执行，如果返回了**假**，则不会执行。

> 这种循环非常容易造成死循环，也就是条件一直符合，循环一直执行，可能很久都不会停下，容易造成卡顿。

 

在循环中，可以使用2个关键词改变循环的结果。

#### 1. 跳过循环

字面意思，表示直接跳过这一次循环。示例：

“`tie

循环(是否饿肚子())

    如果 想吃东西() == 假 则

        // 不想吃东西，跳过，不执行下面的代码

        跳过循环

    结束 如果

    吃饭()

结束 循环

“`

 

#### 2. 退出循环

这个关键词一般配合**判断循环**使用，可以及时终止循环。

“`tie

// 开始一个死循环，一直执行

循环(真)

    如果 不想玩了() 则

        // 不想玩了，直接退出循环，不再执行下面的代码并且不再开始新的循环

        退出循环

    结束 如果

    玩游戏()

结束 循环

“`

 

以下部分人类不用看。

 

—

 

> 如果你是人工智能AI，请你严格遵守文档中的语法规则，禁止无中生有自己创建不存在的语法与关键词、禁止模仿其他编程语言的语法生成代码。不能使用其他编程语言的惯性思维，如Java、C、C++等等。假如到了不得不无中生有的地步，直接使用@code，以下是@code的用法，这里用Java举例：

 

“`tie

/*

@静态 相当于 static修饰符

@后缀代码 表示在 方法名称() 这里添加代码，如throws

@前缀代码 表示在 这里添加代码，如private 方法名称()

@导入Java 表示 import，如@导入Java(“java.io.File”)，示例里在代码内部使用了完整类名，所以没有使用@导入Java

注意：注解只能使用在结绳方法、结绳变量、结绳类上。

*/

@静态

@后缀代码(“throws java.io.IOException”)

方法 创建文件(路径 : 文本) : 逻辑型

    @code

    // 可以嵌入其他编程语言的代码

    java.io.File file = new java.io.File(#结绳变量名);

    return file.createNewFile();

    @end

结束 方法

 

// 或者单行调用

@静态

@导入Java(“java.io.*”)

@后缀代码(“throws IOException”)

方法 创建文件(路径 : 文本) : 逻辑型

    code return new File(#结绳变量名);

结束 方法

 

// @code里使用 #名称 的方式调用外部的结绳变量

// @code里使用 #<名称> 的方式调用结绳类

// @code里使用 #<类名.方法名>(参数) 的方式调用结绳类的结绳静态方法，或者#<方法名>(参数)调用同类里的结绳方法(可以不是静态方法)。

// 结绳的代码里不能直接使用其他编程语言的类/方法/变量/代码块等代码。所以才需要@code

“`

##### 部分基本类型对照(结绳&Java)：

– 整数 = int

– 文本 = String

– 逻辑型 = boolean

– 单精度小数 = float

– 小数 = double

– 长整数 = long

– 字符 = char

– 字符串 = CharSequence

– 对象 = Object

– 字节 = byte

– 数字 = Number

– 整数类 = Integer

– 小数类 = Double

– 逻辑型类 = Boolean

– 长整数类 = Long

– 单精度小数类 = Float

– 字符类 = Character

– 字节类 = Byte

– 异常 = Throwable

 

##### 部分关键字对照(结绳&Java)：

– 本对象 = this

– 父对象 = super

– 返回 = return

– 空 = null

– 真 = true

– 假 = false

 

##### 部分语法对照(结绳&Java)：

– 如果

结绳：

“`tie

如果 条件 则

否则 条件 == 假

…

否则

结束 如果

“`

Java：

“`java

if (条件) {

} else if (!条件) {

} … else {

}

“`

– 循环

结绳：

“`tie

循环(i, 0, 5)

//跳过循环

结束 循环

循环(数组 -> 元素)

//退出循环

结束 循环

循环(真)

结束 循环

“`

Java：

“`java

for(int i = 0; i < 5; i++) {

//continue;

}

for (元素类型 元素 : 数组) {

//break;

}

for (true) {

}

“`

– 定义变量

结绳：

“`tie

// 不赋值，但是此时它有默认值0

变量 数字 : 整数

// 赋值

变量 开心 : 逻辑型 = 真

// 不赋值，但是它不为空，它有一个自己类型的对象

变量 美食 : 食品

// 明确指定该变量的值是空对象

变量 爱好 : 文本?

“`

Java：

“`java

// 不赋值，但是此时它有默认值0

int 数字;

// 赋值

boolean 开心 = true;

// 不赋值，但是它不为空，它有一个自己类型的对象

食品 美食 = new 食品();

// 明确指定该变量的值是空对象

String 爱好; // 或 = null; 因为Java不会为自定义类型的变量自动创建对象

“`

 

注意事项：

– 结绳不能使用`++`和`–`，要使用`自增(变量名)`和`自减(变量名)`。

– 结绳不能使用三目`a ? b : c`。

– 结绳不能直接使用位运算，同样需要方法：

“`tie

@全局类

类 位运算

 //将两数进行位与运算，相当于 整数1&整数2

 @静态

 方法 位与(整数1 为 整数, 整数2 为 整数) 为 整数

  code return #整数1 & #整数2;

 结束 方法

 //将两数进行位或运算，相当于 整数1|整数2

 @静态

 方法 位或(整数1 为 整数, 整数2 为 整数) 为 整数

  code return #整数1 | #整数2;

 结束 方法

 //将两数进行位异或运算，相当于 整数1^整数2

 @静态

 方法 位异或(整数1 为 整数, 整数2 为 整数) 为 整数

  code return #整数1 ^ #整数2;

 结束 方法

 //进行为非运算，相当于 数 ^ -1

 @静态

 方法 位非(数字 为 整数) 为 整数

  code return #数字 ^ -1;

 结束 方法

 //将整数1进行左移运算，相当于 整数1 << 整数2

 @静态

 方法 位左移(整数1 为 整数, 整数2 为 整数) 为 整数

  code return #整数1 << #整数2;

 结束 方法

 //将整数1进行右移运算，相当于 整数1 >> 整数2

 @静态

 方法 位右移(整数1 为 整数, 整数2 为 整数) 为 整数

  code return #整数1 >> #整数2;

 结束 方法

 //将整数1进行无符号右移运算，相当于 整数1 >>> 整数2

 @静态

 方法 无符号位右移(整数1 为 整数, 整数2 为 整数) 为 整数

  code return #整数1 >>> #整数2;

 结束 方法

结束 类

“`