Skip to content

Z
zetcode-zh

OpenDocCN / zetcode-zh
大约 1 年 前同步成功

通知 2
Star 157
Fork 40
Z
zetcode-zh

体验新版 GitCode，发现更多精彩内容 >>

提交 921311b7 编写于 作者: W wizardforcel
浏览文件
操作

2020-06-16 19:52:56

上级 70e8a328
隐藏空白更改
内联 并排
Showing with 126 addition and 126 deletion
docs/dotnet/133.md
浏览文件 @ 921311b7
......@@ -223,7 +223,7 @@ Console.WriteLine("Today is {0}", DateTime.Today.ToString("M/d"));
```
括号（圆括号）用于标记方法签名。 签名由方法参数组成。 圆括号用于表示评估值。
括号（圆括号）用于标记方法签名。 签名由方法参数组成。 圆括号用于表示求值值。
```cs
int[] array = new int[5] {1, 2, 3, 4, 5};
......
docs/dotnet/134.md
浏览文件 @ 921311b7
......@@ -568,7 +568,7 @@ string msg = string.Format("{0} is {1} years old.", name, age);
```
我们使用内置字符串类的`Format()`方法。 `{0}`和`{1}`是评估变量的地方。 数字代表变量的位置。 `{0}`计算得出第一个提供的变量，`{1}`计算得出第二个变量。
我们使用内置字符串类的`Format()`方法。 `{0}`和`{1}`是求值变量的地方。 数字代表变量的位置。 `{0}`计算得出第一个提供的变量，`{1}`计算得出第二个变量。
```cs
$ dotnet run
......
docs/dotnet/137.md
浏览文件 @ 921311b7
......@@ -480,7 +480,7 @@ namespace AndOperator
```
示例显示了逻辑和运算符。 仅当两个操作数均为 true 时，它的评估结果为 true。
示例显示了逻辑和运算符。 仅当两个操作数均为 true 时，它的求值结果为 true。
```cs
$ dotnet run
......@@ -568,7 +568,7 @@ True
这是`negation.exe`程序的输出。
`||`和`&&`运算符经过短路评估。 短路评估意味着仅当第一个参数不足以确定表达式的值时，才评估第二个参数：当逻辑的第一个参数的结果为 false 时，总值必须为 false ; 当逻辑或的第一个参数为 true 时，总值必须为 true。 短路评估主要用于提高性能。
`||`和`&&`运算符经过短路求值。 短路求值意味着仅当第一个参数不足以确定表达式的值时，才求值第二个参数：当逻辑的第一个参数的结果为 false 时，总值必须为 false ; 当逻辑或的第一个参数为 true 时，总值必须为 true。 短路求值主要用于提高性能。
一个例子可以使这一点更加清楚。
......@@ -626,7 +626,7 @@ if (One() && Two())
```
`One()`方法返回`false`。 短路& &不评估第二种方法。 没有必要。 一旦操作数为`false`，则逻辑结论的结果始终为`false`。 仅将“ Inside one”打印到控制台。
`One()`方法返回`false`。 短路& &不求值第二种方法。 没有必要。 一旦操作数为`false`，则逻辑结论的结果始终为`false`。 仅将“ Inside one”打印到控制台。
```cs
Console.WriteLine("#############");
......@@ -638,7 +638,7 @@ if (Two() || One())
```
在第二种情况下，我们使用`||`运算符，并使用`Two()`方法作为第一个操作数。 在这种情况下，“ Inside two”和“ Pass”字符串将打印到终端。 再次不必评估第二操作数，因为一旦第一操作数评估为`true`，则逻辑或始终为`true`。
在第二种情况下，我们使用`||`运算符，并使用`Two()`方法作为第一个操作数。 在这种情况下，“ Inside two”和“ Pass”字符串将打印到终端。 再次不必求值第二操作数，因为一旦第一操作数求值为`true`，则逻辑或始终为`true`。
```cs
$ ShortCircuit>dotnet run
......@@ -1294,7 +1294,7 @@ This is the output of the example.
## C# 运算符优先级
运算符优先级告诉我们首先评估哪个运算符。 优先级对于避免表达式中的歧义是必要的。
运算符优先级告诉我们首先求值哪个运算符。 优先级对于避免表达式中的歧义是必要的。
以下表达式 28 或 40 的结果是什么？
......@@ -1310,7 +1310,7 @@ This is the output of the example.
```
要更改评估的顺序，可以使用括号。 括号内的表达式始终首先被求值。
要更改求值的顺序，可以使用括号。 括号内的表达式始终首先被求值。
下表显示了按优先级排序的通用 C# 运算符（优先级最高）：
......@@ -1384,7 +1384,7 @@ False
## C# 关联规则
有时，优先级不能令人满意地确定表达式的结果。 还有另一个规则称为关联性。 运算符的关联性确定优先级与相同的运算符的评估顺序。
有时，优先级不能令人满意地确定表达式的结果。 还有另一个规则称为关联性。 运算符的关联性确定优先级与相同的运算符的求值顺序。
```cs
9 / 3 * 3
......@@ -1439,7 +1439,7 @@ j *= 3 + 1;
```
复合赋值运算符从右到左关联。 我们可能期望结果为 1。但是实际结果为 0。由于有关联性。 首先评估右边的表达式，然后应用复合赋值运算符。
复合赋值运算符从右到左关联。 我们可能期望结果为 1。但是实际结果为 0。由于有关联性。 首先求值右边的表达式，然后应用复合赋值运算符。
```cs
$ dotnet run
......@@ -1686,7 +1686,7 @@ cond-exp ? exp1 : exp2
```
如果 cond-exp 为 true，则评估 exp1 并返回结果。 如果 cond-exp 为 false，则评估 exp2 并返回其结果。
如果 cond-exp 为 true，则求值 exp1 并返回结果。 如果 cond-exp 为 false，则求值 exp2 并返回其结果。
`Program.cs`
......@@ -1717,7 +1717,7 @@ bool adult = age >= 18 ? true : false;
```
首先，对赋值运算符右侧的表达式进行求值。 三元运算符的第一阶段是条件表达式评估。 因此，如果年龄大于或等于 18，则返回`?`字符后的值。 如果不是，则返回`:`字符后的值。 然后将返回值分配给成人变量。
首先，对赋值运算符右侧的表达式进行求值。 三元运算符的第一阶段是条件表达式求值。 因此，如果年龄大于或等于 18，则返回`?`字符后的值。 如果不是，则返回`:`字符后的值。 然后将返回值分配给成人变量。
```cs
$ dotnet run
......
docs/dotnet/138.md
浏览文件 @ 921311b7
......@@ -386,7 +386,7 @@ break;
```
在这种情况下，我们测试域变量是否等于“ us”字符串。 如果为 true，则将消息打印到控制台。 该选项以`break`关键字结束。 如果成功评估了其中一个选项，则`break`关键字将终止`switch`块。
在这种情况下，我们测试域变量是否等于“ us”字符串。 如果为 true，则将消息打印到控制台。 该选项以`break`关键字结束。 如果成功求值了其中一个选项，则`break`关键字将终止`switch`块。
```cs
default:
......@@ -395,7 +395,7 @@ break;
```
`default`关键字是可选的。 如果没有评估`case`选项，则执行`default`部分。
`default`关键字是可选的。 如果没有求值`case`选项，则执行`default`部分。
```cs
$ dotnet run
......@@ -595,7 +595,7 @@ while (expression)
```
`while`关键字在大括号括起来的块内执行语句。 每次将表达式评估为 true 时都会执行这些语句。
`while`关键字在大括号括起来的块内执行语句。 每次将表达式求值为 true 时都会执行这些语句。
`Program.cs`
......@@ -678,7 +678,7 @@ namespace DoWhile
```
首先执行该块，然后评估真值表达式。 在我们的情况下，条件不满足，`do while`语句终止。
首先执行该块，然后求值真值表达式。 在我们的情况下，条件不满足，`do while`语句终止。
## C# 循环语句
......
docs/dotnet/140.md
浏览文件 @ 921311b7
......@@ -790,7 +790,7 @@ This is the output.
## C# 类常量
C# 可以创建类常量。 这些常量不属于具体对象。 他们属于阶级。 按照约定，常量用大写字母表示。
C# 可以创建类常量。 这些常量不属于具体对象。 他们属于类。 按照约定，常量用大写字母表示。
`Program.cs`
......
docs/dotnet/154.md
浏览文件 @ 921311b7
......@@ -55,7 +55,7 @@ var result = await client.GetAsync("http://webcode.me");
```
`GetAsync()`方法将 GET 请求作为异步操作发送到指定的 Uri。 `await`运算符会暂停对异步方法的评估，直到异步操作完成为止。 异步操作完成后，`await`操作符将返回操作结果（如果有）。
`GetAsync()`方法将 GET 请求作为异步操作发送到指定的 Uri。 `await`运算符会暂停对异步方法的求值，直到异步操作完成为止。 异步操作完成后，`await`操作符将返回操作结果（如果有）。
```cs
$ dotnet run
......
docs/dotnet/88.md
浏览文件 @ 921311b7
......@@ -10,7 +10,7 @@
## Visual Basic
Visual Basic 编程语言是.NET Framework 的高级编程语言。 这是一种非常流行的语言。 目前，它是世界十大流行语言之一。 它是为 Windows 平台创建的。 Mono 项目已为 Linux 和 Mac 平台创建了一个克隆。 Visual Basic 的创建易于学习。 它源自 BASIC 语言家族。 它是一种面向对象的编译语言。 源代码被编译为可执行文件（.exe），由.Net 平台执行。 自最初发布以来，Visual Basic 进行了许多更改。 它因设计不佳而受到严厉批评。 许多缺点已得到解决。 一些不太好的文物仍然保留在语法中。 曾经被认为是 C# 的简单表亲，多年来，它已成为功能齐全的高级编程语言。 它的受欢迎程度上升和下降。
Visual Basic 编程语言是.NET Framework 的高级编程语言。 这是一种非常流行的语言。 目前，它是世界十大流行语言之一。 它是为 Windows 平台创建的。 Mono 项目已为 Linux 和 Mac 平台创建了一个克隆。 Visual Basic 的创建易于学习。 它源自 BASIC 语言家族。 它是一种面向对象的编译语言。 源代码被编译为可执行文件（`.exe`），由.Net 平台执行。 自最初发布以来，Visual Basic 进行了许多更改。 它因设计不佳而受到严厉批评。 许多缺点已得到解决。 一些不太好的文物仍然保留在语法中。 曾经被认为是 C# 的简单表亲，多年来，它已成为功能齐全的高级编程语言。 它的受欢迎程度上升和下降。
## 编程语言
......@@ -29,13 +29,13 @@ Visual Basic 编程语言是.NET Framework 的高级编程语言。 这是一种
| 9 | Obj C | 3.2% |
| 10 | Delphi | 2.4% |
Java 是使用最广泛的编程语言。 Java 在创建便携式移动应用，对各种设备进行编程以及创建企业应用方面表现出色。 每四个应用都使用 C / C++ 进行编程。 它们主要用于创建操作系统和各种桌面应用。 C / C++ 是使用最广泛的系统编程语言。 大多数著名的桌面应用都是用 C++ 创建的。 可能是 MS Office，Macromedia Flash，Adobe Photoshop 或 3D Max。 这两种语言也主导了游戏编程业务。
Java 是使用最广泛的编程语言。 Java 在创建便携式移动应用，对各种设备进行编程以及创建企业应用方面表现出色。 每四个应用都使用 C/C++ 进行编程。 它们主要用于创建操作系统和各种桌面应用。 C/C++ 是使用最广泛的系统编程语言。 大多数著名的桌面应用都是用 C++ 创建的。 可能是 MS Office，Macromedia Flash，Adobe Photoshop 或 3D Max。 这两种语言也主导了游戏编程业务。
PHP 在网络上占主导地位。 Java 主要由大型组织使用，而 PHP 由较小的公司和个人使用。
Visual Basic 代表了快速的应用开发的流行和 Microsoft 的统治地位。
C# 计划成为下一个主要语言。 它应该主要与 Java 和 C / C++ 语言竞争。
C# 计划成为下一个主要语言。 它应该主要与 Java 和 C/C++ 语言竞争。
Python 和 PERL 是流行的脚本语言，并且是紧密的竞争者。
......
docs/dotnet/89.md
浏览文件 @ 921311b7
......@@ -190,7 +190,7 @@ Console.WriteLine("Today is {0}", GetToday)
```
括号（方括号）用于标记方法签名。 签名由方法参数组成。 圆括号用于表示评估值。
括号（方括号）用于标记方法签名。 签名由方法参数组成。 圆括号用于表示求值值。
```vb
Dim array() As Integer = { _
......
docs/dotnet/90.md
浏览文件 @ 921311b7
......@@ -28,7 +28,7 @@ Option Strict On
```
`Option Strict`语句可以为 On 或 Off。 默认值为“关”，以便与旧版 Visual Basic 程序向后兼容。 建议在所有新程序中使用此语句。 当该语句为 On 时，编译器将检测各种不良的编程习惯。
`Option Strict`语句可以为`On`或`Off`。 默认值为“关”，以便与旧版 Visual Basic 程序向后兼容。 建议在所有新程序中使用此语句。 当该语句为`On`时，编译器将检测各种不良的编程习惯。
```vb
Module Example
......@@ -37,7 +37,7 @@ End Module
```
每个 Visual Basic 程序都应正确构造。 源代码放置在模块中。 在模块内，代码进一步分为过程和功能。 结构正确的模块更易于维护，并且不易出错。 在我们的例子中，我们创建一个名为 Example 的模块。 为此，我们使用`Module`关键字。 模块定义以`End Module`语句结束。
每个 Visual Basic 程序都应正确构造。 源代码放置在模块中。 在模块内，代码进一步分为过程和功能。 结构正确的模块更易于维护，并且不易出错。 在我们的例子中，我们创建一个名为`Example`的模块。 为此，我们使用`Module`关键字。 模块定义以`End Module`语句结束。
```vb
Sub Main()
......@@ -46,7 +46,7 @@ End Sub
```
使用`Sub`关键字，创建一个过程。 Sub 是从子例程字派生的。 子例程和过程是同义词。 在 Visual Basic 中，首选词是过程。 过程是 Visual Basic 代码的一部分。 这是为了实现代码的模块化。
使用`Sub`关键字，创建一个过程。 `Sub`是从子例程字派生的。 子例程和过程是同义词。 在 Visual Basic 中，首选词是过程。 过程是 Visual Basic 代码的一部分。 这是为了实现代码的模块化。
```vb
Console.WriteLine("This is Visual Basic")
......@@ -98,7 +98,7 @@ name = Console.ReadLine()
```
我们从终端读取一行。 当我们按下 Enter 键时，字符串将分配给 name 变量。
我们从终端读取一行。 当我们按下`Enter`键时，字符串将分配给`name`变量。
```vb
Console.WriteLine("Hello {0}", name)
......@@ -192,7 +192,7 @@ End Module
```
命令行参数可以传递给 Main 过程。
命令行参数可以传递给`Main`过程。
```vb
Sub Main(ByVal cmdArgs() As String)
......@@ -266,7 +266,7 @@ Dim city As String = "New York"
```
我们声明一个 String 类型的 city 变量，并将其初始化为“ New York”值。
我们声明一个`String`类型的`city`变量，并将其初始化为`"New York"`值。
```vb
Dim name As String = "Paul", age As Integer = 35, _
......@@ -385,7 +385,7 @@ output = String.Format("{0} is {1} years old.", _
```
我们使用内置`String`模块的`Format()`方法。 `{0}`和`{1}`是评估变量的地方。 数字代表变量的位置。 `{0}`计算得出的第一个变量，`{1}`计算得出的第二个变量。
我们使用内置`String`模块的`Format()`方法。 `{0}`和`{1}`是求值变量的地方。 数字代表变量的位置。 `{0}`计算得出的第一个变量，`{1}`计算得出的第二个变量。
```vb
$ ./interpolation.exe
......
docs/dotnet/91.md
浏览文件 @ 921311b7
......@@ -4,13 +4,13 @@
在 Visual Basic 教程的这一部分中，我们将讨论数据类型。
计算机程序可以处理数据。 用于各种数据类型的工具是现代计算机语言的基本组成部分。 根据 Wikipedia 的定义，`data type`是一组值，以及对这些值的允许操作。
计算机程序可以处理数据。 用于各种数据类型的工具是现代计算机语言的基本组成部分。 根据维基百科的定义，`data type`是一组值，以及对这些值的允许操作。
Visual Basic 中的两种基本数据类型是值类型和引用类型。 基本类型（字符串除外），枚举和结构是值类型。 类，字符串，标准模块，接口，数组和委托是引用类型。 每种类型都有一个默认值。 参考类型在堆上创建。 引用类型的生存期由.NET 框架管理。 引用类型的默认值为空引用。 分配给引用类型的变量会创建引用的副本，而不是引用值的副本。 值类型在堆栈上创建。 生存期由变量的生存期决定。 分配给值类型的变量会创建要分配的值的副本。 值类型具有不同的默认值。 例如，布尔默认值为 False，十进制为 0，字符串为空字符串“”。
Visual Basic 中的两种基本数据类型是值类型和引用类型。 基本类型（字符串除外），枚举和结构是值类型。 类，字符串，标准模块，接口，数组和委托是引用类型。 每种类型都有一个默认值。 参考类型在堆上创建。 引用类型的生存期由 .NET 框架管理。 引用类型的默认值为空引用。 分配给引用类型的变量会创建引用的副本，而不是引用值的副本。 值类型在堆栈上创建。 生存期由变量的生存期决定。 分配给值类型的变量会创建要分配的值的副本。 值类型具有不同的默认值。 例如，布尔默认值为`False`，十进制为 0，字符串为空字符串`""`。
## 布尔值
我们的世界建立了双重性。 有天与地，水与火，井与章，男人与女人，爱与恨。 在 Visual Basic 中，`Boolean`数据类型是具有以下两个值之一的原始数据类型：True 或 False。 这是基本的数据类型。 在计算机程序中非常常见。
我们的世界建立了双重性。 有天与地，水与火，井与章，男人与女人，爱与恨。 在 Visual Basic 中，`Boolean`数据类型是具有以下两个值之一的原始数据类型：`True`或`False`。 这是基本的数据类型。 在计算机程序中非常常见。
快乐的父母正在等待孩子的出生。 他们为两种可能性都选择了名称。 如果要成为男孩，他们选择了约翰。 如果要成为女孩，他们会选择杰西卡。
......@@ -52,7 +52,7 @@ Dim num As Byte
```
num 变量具有 Byte 数据类型。 这个很重要。 字节数据类型的整数值可以为 0..255。
`num`变量具有`Byte`数据类型。 这个很重要。 字节数据类型的整数值可以为`0..255`。
```vb
Randomize()
......@@ -60,7 +60,7 @@ num = CType(Math.Round(Rnd()), Byte)
```
这两行随机取 0 或 1。`Rnd()`函数返回小于 1 但大于或等于 0 的随机值。 我们使用`Round()`方法将数字四舍五入。 大于 0.5 的随机值将四舍五入为 1。所有其他随机值将四舍五入为零。使用`CType()`函数将 Double 数据类型转换为`Byte`。 因此，将`num`变量分配为 0 或 1。`Randomize()`函数根据系统计时器初始化带有种子的随机数生成器。
这两行随机取 0 或 1。`Rnd()`函数返回小于 1 但大于或等于 0 的随机值。 我们使用`Round()`方法将数字四舍五入。 大于 0.5 的随机值将四舍五入为 1。所有其他随机值将四舍五入为零。使用`CType()`函数将`Double`数据类型转换为`Byte`。 因此，将`num`变量分配为 0 或 1。`Randomize()`函数根据系统计时器初始化带有种子的随机数生成器。
```vb
If num = 0 Then
......@@ -71,7 +71,7 @@ End If
```
根据`num`变量，布尔值`male`变量设置为 True 或 False。
根据`num`变量，布尔值`male`变量设置为`True`或`False`。
```vb
If male = True Then
......@@ -82,24 +82,24 @@ End If
```
如果将男性变量设置为 True，则选择名称 John。 否则，我们选择名称 Jessica。 诸如 If / Else 语句之类的控件结构可使用布尔值。
如果将男性变量设置为`True`，则选择名称 John。 否则，我们选择名称 Jessica。 诸如`If/Else`语句之类的控件结构可使用布尔值。
## 整数
整数是实数的子集。 它们写时没有小数或小数部分。 整数落入集合 Z = {...，-2，-1，0，1，2，......}中整数是无限的。
整数是实数的子集。 它们写时没有小数或小数部分。 整数落入集合`Z = {..., -2, -1, 0, 1, 2, ......}`中整数是无限的。
在计算机语言中，整数是原始数据类型。 实际上，计算机只能使用整数值的子集，因为计算机的容量有限。 整数用于计算离散实体。 我们可以有 3、4、6 个人，但不能有 3.33 个人。 我们可以有 3.33 公斤。
| VB 别名 | .NET 类型 | 尺寸 | 范围 |
| --- | --- | --- | --- |
| `SByte` | `System.SByte` | 1 个字节 | -128 至 127 |
| `Byte` | `System.Byte` | 1 byte | 0 至 255 |
| `SByte` | `System.SByte` | 1 字节 | -128 至 127 |
| `Byte` | `System.Byte` | 1 字节 | 0 至 255 |
| `Short` | `System.Int16` | 2 字节 | -32,768 至 32,767 |
| `UShort` | `System.UInt16` | 2 bytes | 0 至 65,535 |
| `UShort` | `System.UInt16` | 2 字节 | 0 至 65,535 |
| `Integer` | `System.Int32` | 4 字节 | -2,147,483,648 至 2,147,483,647 |
| `UInteger` | `System.UInt32` | 4 bytes | 0 至 4,294,967,295 |
| `UInteger` | `System.UInt32` | 4 字节 | 0 至 4,294,967,295 |
| `Long` | `System.Int64` | 8 字节 | -9,223,372,036,854,775,808 至 9,223,372,036,854,775,807 |
| `ULong` | `System.UInt64` | 8 bytes | 0 至 18,446,744,073,709,551,615 |
| `ULong` | `System.UInt64` | 8 字节 | 0 至 18,446,744,073,709,551,615 |
可以根据我们的需要使用这些整数类型。 没有人（也许有些圣经人除外）的年龄可以超过 120、130 岁。 然后，我们可以在程序中将`Byte`类型用于年龄变量。 这样可以节省一些内存。
......@@ -203,9 +203,9 @@ There are total of 384 apples
| VB 别名 | .NET 类型 | 大小 | 精度 | 范围 |
| --- | --- | --- | --- | --- |
| `Single` | `System.Single` | 4 bytes | 7 位数 | 1.5 x 10^-45 至 3.4 x 10^38 |
| `Double` | `System.Double` | 8 bytes | 15-16 位数字 | 5.0 x 10^-324 至 1.7 x 10^308 |
| `Decimal` | `System.Decimal` | 16 字节 | 小数点后 28-29 位 | 1.0 x 10^-28 至 7.9 x 10^28 |
| `Single` | `System.Single` | 4 字节 | 7 位数 | 1.5 x 10^-45 至 3.4 x 10^38 |
| `Double` | `System.Double` | 8 字节 | 15-16 位数 | 5.0 x 10^-324 至 1.7 x 10^308 |
| `Decimal` | `System.Decimal` | 16 字节 | 28-29 位小数 | 1.0 x 10^-28 至 7.9 x 10^28 |
上表给出了浮点类型的特征。
......@@ -374,14 +374,14 @@ End Enum
```
使用`Enum`关键字创建枚举。 星期一，星期二...裸词实际上存储数字 0..6。
使用`Enum`关键字创建枚举。 星期一，星期二...星期日实际上存储数字`0..6`。
```vb
Dim day As Days = Days.Monday
```
我们有一个名为 day 的变量，其类型为 Days。 它被初始化为星期一。
我们有一个名为`day`的变量，其类型为`Days`。 它被初始化为星期一。
```vb
If day = Days.Monday
......@@ -474,14 +474,14 @@ End Module
```
程序将 Z 字符打印到终端。
程序将`Z`字符打印到终端。
```vb
Dim word As String = "ZetCode"
```
在这里，我们创建一个字符串变量，并为其分配“ ZetCode”值。
在这里，我们创建一个字符串变量，并为其分配`"ZetCode"`值。
```vb
Dim c As Char = CType(word.SubString(0, 1), Char)
......@@ -649,7 +649,7 @@ Rem Option Strict On
```
当 Option Strict 语句为 On 时，某些隐式转换是不可能的。 这就是为什么我们评论这一行。
当`Option Strict`语句为`On`时，某些隐式转换是不可能的。 这就是为什么我们评论这一行。
```vb
val = 0.54
......
docs/dotnet/92.md
浏览文件 @ 921311b7
......@@ -165,14 +165,14 @@ Console.WriteLine("17" < "9") 'Returns True
```
值 17 不小于 9。但是在两个字符串上应用&lt;时，我们不比较数字。 我们比较字符的排序顺序。 1 在 9 之前，因此具有“较低位置”，并且比较返回 True。
值 17 不小于 9。但是在两个字符串上应用`<`时，我们不比较数字。 我们比较字符的排序顺序。 1 在 9 之前，因此具有“较低位置”，并且比较返回`True`。
```vb
Console.WriteLine("aa" > "ab") ' Returns False
```
如果前两个字符相等，则继续对后两个字符进行操作。 a 字符位于 b 之前，并且比较操作返回 False。
如果前两个字符相等，则继续对后两个字符进行操作。 a 字符位于 b 之前，并且比较操作返回`False`。
有`String.Compare()`方法，该方法比较两个指定的字符串并返回一个整数，该整数指示它们在排序顺序中的相对位置。 如果返回的值小于零，则第一个字符串小于第二个字符串。 如果返回零，则两个字符串相等。 最后，如果返回的值大于零，则第一个字符串大于第二个字符串。
......@@ -195,7 +195,7 @@ End Module
```
第三个可选的 ignoreCase 参数确定是否应履行该案件。
第三个可选的`ignoreCase`参数确定是否应履行该案件。
```vb
Console.WriteLine(String.Compare(str1, str2, True))
......@@ -428,7 +428,7 @@ Console.WriteLine(str.Contains("e"))
```
如果字符串包含特定字符，则`Contains()`方法返回 True。
如果字符串包含特定字符，则`Contains()`方法返回`True`。
```vb
Console.WriteLine(str.IndexOf("e"))
......@@ -466,7 +466,7 @@ determination
## 复制与克隆
我们将描述两种方法之间的区别。 复制并克隆。 `Copy()`方法创建一个新的 String 实例，该实例的值与指定的 String 相同。 `Clone()`方法返回对正在克隆的字符串的引用。 它不是堆上字符串的独立副本。 它是同一字符串上的另一个引用。
我们将描述两种方法之间的区别。 复制并克隆。 `Copy()`方法创建一个新的`String`实例，该实例的值与指定的`String`相同。 `Clone()`方法返回对正在克隆的字符串的引用。 它不是堆上字符串的独立副本。 它是同一字符串上的另一个引用。
```vb
Option Strict On
......@@ -516,7 +516,7 @@ Console.WriteLine(str Is copied) ' Prints False
```
`Is`运算符比较两个参考对象。 因此，将复制的字符串与原始字符串进行比较将返回 False。 因为它们是两个不同的对象。
`Is`运算符比较两个参考对象。 因此，将复制的字符串与原始字符串进行比较将返回`False`。 因为它们是两个不同的对象。
## 格式化字符串
......@@ -533,7 +533,7 @@ Console.WriteLine(str Is copied) ' Prints False
长度部分是可选的。 它是参数的字符串表示形式中的最小字符数。 如果为正，则该参数为右对齐；否则为 0。 如果为负，则为左对齐。 如果指定，则必须用冒号分隔索引和长度。
formatString 是可选的。 它是一个格式化值的字符串，是一种特定的方式。 它可以用来格式化日期，时间，数字或枚举。
`formatString`是可选的。 它是一个格式化值的字符串，是一种特定的方式。 它可以用来格式化日期，时间，数字或枚举。
在这里，我们展示了如何使用格式项的长度分量。 我们将三列数字打印到终端。 左，中和右对齐。
......@@ -580,7 +580,7 @@ Console.WriteLine(str1, oranges, apples, bananas)
```
现在，我们将复合格式放在一起。 我们有字符串和对象列表（橙色，苹果，香蕉）。 `{0}`格式项目是指橙色。 `WriteLine()`方法将`{0}`格式项替换为 oranges 变量的内容。
现在，我们将复合格式放在一起。 我们有字符串和对象列表（橙色，苹果，香蕉）。 `{0}`格式项目是指橙色。 `WriteLine()`方法将`{0}`格式项替换为`oranges`变量的内容。
```vb
Dim str2 As String = "There are {1} oranges, {2} bananas and " + _
......
docs/dotnet/93.md
浏览文件 @ 921311b7
......@@ -228,7 +228,7 @@ $ ./division.exe
```
division.exe 程序的结果。
`division.exe`程序的结果。
我们将提到的最后两个运算符是模运算符和幂运算符。
......@@ -325,7 +325,7 @@ Console.WriteLine(y > x)
```
关系运算符始终导致布尔值。 这两行显示 False 和 True。
关系运算符始终导致布尔值。 这两行显示`False`和`True`。
```vb
If (y > x)
......@@ -334,7 +334,7 @@ End If
```
仅在满足括号内的条件时才执行`If`语句的主体。 `x > y`返回 True，因此消息“ y 大于 x”被打印到终端。
仅在满足括号内的条件时才执行`If`语句的主体。 `x > y`返回`True`，因此消息“`y`大于`x`”被打印到终端。
```vb
Option Strict On
......@@ -364,7 +364,7 @@ End Module
```
示例显示了逻辑`And`运算符。 仅当两个操作数均为 True 时，它的评估结果为 True。
示例显示了逻辑`And`运算符。 仅当两个操作数均为`True`时，它的求值结果为`True`。
```vb
$ ./andop.exe
......@@ -375,7 +375,7 @@ False
```
如果正好一个操作数为 True，则逻辑`Xor`运算符的计算结果为 True。
如果正好一个操作数为`True`，则逻辑`Xor`运算符的计算结果为`True`。
```vb
Option Strict On
......@@ -405,7 +405,7 @@ End Module
```
如果两个操作数均为 True 或均为 False，则逻辑`Xor`的计算结果为 False。
如果两个操作数均为`True`或均为`False`，则逻辑`Xor`的计算结果为`False`。
```vb
$ ./xorop.exe
......@@ -416,7 +416,7 @@ False
```
如果两个操作数中的任何一个为 True，则逻辑`Or`运算符的计算结果为 True。
如果两个操作数中的任何一个为`True`，则逻辑`Or`运算符的计算结果为`True`。
```vb
Option Strict On
......@@ -452,7 +452,7 @@ False
```
否定运算符`Not`设为 True False 和 False True。
否定运算符`Not`设为`True False`和`False True`。
```vb
Option Strict On
......@@ -481,7 +481,7 @@ True
```
`AndAlso`和`OrElse`运算符经过短路评估。 短路评估意味着仅当第一个参数不足以确定表达式的值时才评估第二个参数：当 And 的第一个参数评估为 false 时，总值必须为 false； 并且当 Or 的第一个参数计算为 true 时，总值必须为 true。 （维基百科）短路评估主要用于提高性能。
`AndAlso`和`OrElse`运算符经过短路求值。 短路求值意味着仅当第一个参数不足以确定表达式的值时才求值第二个参数：当`And`的第一个参数求值为`false`时，总值必须为`false`； 并且当`Or`的第一个参数计算为`true`时，总值必须为`true`。 （维基百科）短路求值主要用于提高性能。
一个例子可以使这一点更加清楚。
......@@ -527,7 +527,7 @@ End If
```
一个函数返回 False。 短路`AndAlso`不评估第二功能。 没有必要。 一旦操作数为 False，逻辑结论的结果始终为 False。 控制台上仅打印“ Inside one”。
一个函数返回`False`。 短路`AndAlso`不求值第二功能。 没有必要。 一旦操作数为`False`，逻辑结论的结果始终为`False`。 控制台上仅打印`"Inside one"`。
```vb
Console.WriteLine("#############")
......@@ -549,7 +549,7 @@ Inside two
```
shorcircuit.exe 程序的结果。
`shorcircuit.exe`程序的结果。
## 关系运算符
......@@ -640,7 +640,7 @@ Console.WriteLine("ab" > "aa") ' Prints True
```
假设我们有一个包含更多字符的字符串。 如果前几个字符相等，我们将比较下一个字符。 在我们的情况下，第二个位置的 b 字符的值比 a 字符大。 这就是为什么“ ab”字符串大于“ aa”字符串的原因。 当然，以这种方式比较字符串没有多大意义。 但这在技术上是可能的。
假设我们有一个包含更多字符的字符串。 如果前几个字符相等，我们将比较下一个字符。 在我们的情况下，第二个位置的 b 字符的值比 a 字符大。 这就是为什么`"ab"`字符串大于`"aa"`字符串的原因。 当然，以这种方式比较字符串没有多大意义。 但这在技术上是可能的。
最后，我们将提到`Is`运算符。 运算符检查两个对象引用是否引用同一对象。 它不执行值比较。
......@@ -674,7 +674,7 @@ Dim o2 As Object = New Object
```
我们声明并初始化两个 Object 实例。 `Object`类是.NET 框架中所有类的基类。 我们将在以后更详细地描述它。
我们声明并初始化两个`Object`实例。 `Object`类是.NET 框架中所有类的基类。 我们将在以后更详细地描述它。
```vb
Dim o3 As Object
......@@ -696,7 +696,7 @@ Console.WriteLine(o3 Is o2)
```
在第一种情况下，我们得到 False。 `o1`和`o2`是两个不同的对象。 在第二种情况下，我们得到 True。 `o3`和`o2`指的是同一对象。
在第一种情况下，我们得到`False`。 `o1`和`o2`是两个不同的对象。 在第二种情况下，我们得到`True`。 `o3`和`o2`指的是同一对象。
## 按位运算符
......@@ -806,7 +806,7 @@ End Module
## 运算符优先级
运算符优先级告诉我们首先评估哪个运算符。 优先级对于避免表达式中的歧义是必要的。
运算符优先级告诉我们首先求值哪个运算符。 优先级对于避免表达式中的歧义是必要的。
以下表达式 28 或 40 的结果是什么？
......@@ -822,7 +822,7 @@ End Module
```
要更改评估的顺序，可以使用括号。 括号内的表达式始终首先被求值。
要更改求值的顺序，可以使用括号。 括号内的表达式始终首先被求值。
下面的列表显示了按优先级排序的常见 Visual Basic 运算符（优先级最高）：
......@@ -877,7 +877,7 @@ Console.WriteLine(Not True Or True)
```
在这种情况下，否定运算符具有更高的优先级。 首先，第一个 True 值被否定为 False，然后 Or 运算符组合 False 和 True，最后得到 True。
在这种情况下，否定运算符具有更高的优先级。 首先，第一个`True`值被否定为`False`，然后`Or`运算符组合`False`和`True`，最后得到`True`。
```vb
$ ./precedence.exe
......@@ -890,7 +890,7 @@ False
## 关联性
有时，优先级不能令人满意地确定表达式的结果。 还有另一个规则称为关联性。 运算符的关联性确定优先级与相同的运算符的评估顺序。
有时，优先级不能令人满意地确定表达式的结果。 还有另一个规则称为关联性。 运算符的关联性确定优先级与相同的运算符的求值顺序。
```vb
9 / 3 * 3
......@@ -920,7 +920,7 @@ Console.WriteLine(j)
```
您可能期望结果为 1。但是实际结果为 0。由于有关联性。 首先评估右边的表达式，然后应用复合赋值运算符。
您可能期望结果为 1。但是实际结果为 0。由于有关联性。 首先求值右边的表达式，然后应用复合赋值运算符。
## `AddressOf`运算符
......
docs/dotnet/94.md
浏览文件 @ 921311b7
......@@ -17,7 +17,7 @@ End If
```
`If`关键字用于检查表达式是否为真。 如果为 true，则执行一条语句。 该语句可以是单个语句或复合语句。 复合语句由 If / End If 块包围的多个语句组成。
`If`关键字用于检查表达式是否为真。 如果为`true`，则执行一条语句。 该语句可以是单个语句或复合语句。 复合语句由`If/End If`块包围的多个语句组成。
```vb
Option Strict On
......@@ -38,7 +38,7 @@ End Module
```
我们有一个`num`变量。 它被分配为 31。`If`关键字检查布尔表达式。 表达式放在方括号之间。 `31 &gt; 0`为 true，因此将执行块内的语句。
我们有一个`num`变量。 它被分配为 31。`If`关键字检查布尔表达式。 表达式放在方括号之间。 `31 > 0`为`true`，因此将执行块内的语句。
```vb
$ ./ifstatement.exe
......@@ -95,7 +95,7 @@ End Module
```
我们有性别变量。 它具有“女性”字符串。 布尔表达式的计算结果为 false，我们在控制台中得到“ It is a girl”。
我们有性别变量。 它具有“女性”字符串。 布尔表达式的计算结果为`false`，我们在控制台中得到`"It is a girl"`。
```vb
$ ./branch.exe
......@@ -128,7 +128,7 @@ End Module
```
我们有一个数值变量，并测试它是否为负数或正数或等于零。 第一个表达式的计算结果为 false。 满足第二个条件。 程序在控制台上输出“ a 等于零”。 分支的其余部分将被跳过。
我们有一个数值变量，并测试它是否为负数或正数或等于零。 第一个表达式的计算结果为`false`。 满足第二个条件。 程序在控制台上输出“a 等于零”。 分支的其余部分将被跳过。
## `Select`语句
......@@ -230,7 +230,7 @@ Case 0 To 21
```
在这里，我们指定一个值范围。 如果用户输入的值在 0 到 21 之间（包括 0 和 21），则程序将在控制台上打印“ Junior”。
在这里，我们指定一个值范围。 如果用户输入的值在 0 到 21 之间（包括 0 和 21），则程序将在控制台上打印“Junior”。
```vb
$ ./agerange.exe
......@@ -254,7 +254,7 @@ End While
```
`While`关键字在`While`和`End While`关键字包围的块内执行语句。 每次将表达式评估为 true 时都会执行这些语句。
`While`关键字在`While`和`End While`关键字包围的块内执行语句。 每次将表达式求值为`true`时都会执行这些语句。
```vb
Option Strict On
......@@ -290,7 +290,7 @@ Dim i As Integer = 0
```
我们启动 i 变量。 它用作计数器。
我们启动`i`变量。 它用作计数器。
```vb
While i < 10
......@@ -299,7 +299,7 @@ End While
```
`While`关键字后面的表达式是第二阶段，即测试。 执行主体中的语句，直到表达式的计算结果为 false。
`While`关键字后面的表达式是第二阶段，即测试。 执行主体中的语句，直到表达式的计算结果为`false`。
```vb
i = i + 1
......@@ -329,7 +329,7 @@ End Module
```
首先执行迭代，然后评估真值表达式。
首先执行迭代，然后求值真值表达式。
## `For Next`语句
......@@ -352,7 +352,7 @@ End Module
```
在此示例中，我们将数字 0..9 打印到控制台。
在此示例中，我们将数字`0..9`打印到控制台。
```vb
For i As Integer = 0 To 9
......@@ -475,7 +475,7 @@ End Module
```
我们定义了一个无限的`While`循环。 只有一种方法可以跳出这样的循环。 我们必须使用`Exit While`语句。 我们从 1 到 30 中选择一个随机值。我们打印该值。 如果该值等于 22，则结束无穷的 while 循环。
我们定义了一个无限的`While`循环。 只有一种方法可以跳出这样的循环。 我们必须使用`Exit While`语句。 我们从 1 到 30 中选择一个随机值。我们打印该值。 如果该值等于 22，则结束无穷的`while`循环。
```vb
$ ./exitstm.exe
......@@ -518,7 +518,7 @@ End Module
```
我们使用`While`循环遍历数字 1..999。
我们使用`While`循环遍历数字`1..999`。
```vb
If ((num Mod 2) = 0)
......
docs/dotnet/95.md
浏览文件 @ 921311b7
......@@ -64,7 +64,7 @@ Next
```
我们遍历数组并打印其元素。 数组具有`Length`属性，该属性给出数组中元素的数量。 由于数组基于零，因此索引为 0..length-1。
我们遍历数组并打印其元素。 数组具有`Length`属性，该属性给出数组中元素的数量。 由于数组基于零，因此索引为`0..length-1`。
我们可以在一个语句中声明并初始化一个数组。
......@@ -222,7 +222,7 @@ Next i
```
我们需要两个循环才能从二维数组中获取数据。 `UBound()`功能具有可选的第二个参数 rank。 这是我们检索最高索引的维度。 如果省略等级，则假定为 1 维。
我们需要两个循环才能从二维数组中获取数据。 `UBound()`功能具有可选的第二个参数`rank`。 这是我们检索最高索引的维度。 如果省略等级，则假定为 1 维。
```vb
$ ./twodimensions.exe
......@@ -377,7 +377,7 @@ Dim jagged As Integer()() = New Integer(4)() {}
```
这是锯齿状数组的声明。 我们有一个数组数组。 更具体地说，我们声明了一个数组，该数组具有五个 Integer 数据类型的数组。
这是锯齿状数组的声明。 我们有一个数组数组。 更具体地说，我们声明了一个数组，该数组具有五个整数数据类型的数组。
```vb
jagged(0) = New Integer() {1}
......@@ -397,7 +397,7 @@ Console.Write(jagged(i)(j) & " ")
## 数组方法
有多种使用数组的方法。 这些方法可用于检索，修改数据，排序，复制，搜索数据。 我们使用的这些方法是 Array 类的静态方法或数组对象的成员方法。
有多种使用数组的方法。 这些方法可用于检索，修改数据，排序，复制，搜索数据。 我们使用的这些方法是`Array`类的静态方法或数组对象的成员方法。
```vb
Option Strict On
......
docs/dotnet/96.md
浏览文件 @ 921311b7
......@@ -86,7 +86,7 @@ Addition(x, y)
```
在这里，我们将调用`Addition()`过程并将两个参数传递给它。 这些参数是两个 Integer 值。
在这里，我们将调用`Addition()`过程并将两个参数传递给它。 这些参数是两个`Integer`值。
```vb
Sub Addition(ByVal k As Integer, ByVal l As Integer)
......@@ -400,14 +400,14 @@ End Module
```
在前面的示例中，我们声明了两个变量。 变量 a 具有模块作用域，变量 b 具有程序作用域。
在前面的示例中，我们声明了两个变量。 变量`a`具有模块作用域，变量`b`具有程序作用域。
```vb
Dim a As Byte = 2
```
变量 a 在两个过程之外的 Example 模块内部声明。 在两个过程中均有效。
变量`a`在两个过程之外的 Example 模块内部声明。 在两个过程中均有效。
```vb
Sub Main()
......@@ -417,7 +417,7 @@ End Sub
```
变量 b 在`Main()`过程中声明。 仅在此有效。 在第二个过程中无效。
变量`b`在`Main()`过程中声明。 仅在此有效。 在第二个过程中无效。
```vb
Sub SimpleProcedure()
......
docs/dotnet/97.md
浏览文件 @ 921311b7
......@@ -192,7 +192,7 @@ End NameSpace
```
我们在`MyMath`名称空间中具有`Math`类的框架。 在 Basic 类中，我们定义`PI`常量和`GetPi()`方法。
我们在`MyMath`名称空间中具有`Math`类的框架。 在`Basic`类中，我们定义`PI`常量和`GetPi()`方法。
```vb
Option Strict On
......@@ -229,7 +229,7 @@ Imports MyMath
Figure: Root namespace
在 Visual Basic 2008 Express 版上，会自动创建一个根名称空间。 可以在项目属性的“应用”选项卡下找到。 删除根名称空间或将其包含在导入路径中。 例如，如果在那里有“测试”，则将行更改为 Imports `Testing.MyMath`。
在 Visual Basic 2008 Express 版上，会自动创建一个根名称空间。 可以在项目属性的“应用”选项卡下找到。 删除根名称空间或将其包含在导入路径中。 例如，如果在那里有“测试”，则将行更改为`Imports Testing.MyMath`。
```vb
Console.WriteLine(Basic.PI)
......
docs/dotnet/98.md
浏览文件 @ 921311b7
......@@ -125,7 +125,7 @@ p1.Name = "Jane"
```
我们创建`Person`类的实例。 并将 Name 变量设置为“ Jane”。 我们使用点运算符来访问对象的属性。
我们创建`Person`类的实例。 并将`Name`变量设置为`"Jane"`。 我们使用点运算符来访问对象的属性。
```vb
Dim p2 as New Person
......@@ -353,7 +353,7 @@ End Module
```
在前面的程序中，我们有一个 Derived 类，该类继承自`Base`类。 `Base`类具有三个成员字段。 全部具有不同的访问修饰符。 `IsDefined`成员未继承。 `Private`修饰符可以防止这种情况。
在前面的程序中，我们有一个`Derived`类，该类继承自`Base`类。 `Base`类具有三个成员字段。 全部具有不同的访问修饰符。 `IsDefined`成员未继承。 `Private`修饰符可以防止这种情况。
```vb
Class Derived
......@@ -387,7 +387,7 @@ Base
方法重载允许创建多个具有相同名称的方法，它们的输入类型彼此不同。
方法重载有什么好处？ Qt4 库提供了一个很好的用法示例。 `QPainter`类具有三种绘制矩形的方法。 它们的名称为`drawRect()`，其参数不同。 一个引用一个浮点矩形对象，另一个引用一个整数矩形对象，最后一个引用四个参数，x，y，width，height。 如果开发 Qt 的 C++ 语言没有方法重载，则库的创建者必须将其命名为`drawRectRectF()`，`drawRectRect()`和`drawRectXYWH()`之类的方法。 方法重载的解决方案更为优雅。
方法重载有什么好处？ Qt4 库提供了一个很好的用法示例。 `QPainter`类具有三种绘制矩形的方法。 它们的名称为`drawRect()`，其参数不同。 一个引用一个浮点矩形对象，另一个引用一个整数矩形对象，最后一个引用四个参数，`x`，`y`，`width`，`height`。 如果开发 Qt 的 C++ 语言没有方法重载，则库的创建者必须将其命名为`drawRectRectF()`，`drawRectRect()`和`drawRectXYWH()`之类的方法。 方法重载的解决方案更为优雅。
```vb
Option Strict On
......@@ -578,7 +578,7 @@ fr.GetInfo()
```
我们创建带有两个参数的 Friend 对象。 然后，我们调用对象的`GetInfo()`方法。
我们创建带有两个参数的`Friend`对象。 然后，我们调用对象的`GetInfo()`方法。
```vb
./constructor2.exe
......@@ -588,7 +588,7 @@ Lenka was born on 5/3/1990
## 类常量
Visual Basic 可以创建类常量。 这些常量不属于具体对象。 他们属于阶级。 按照约定，常量用大写字母表示。
Visual Basic 可以创建类常量。 这些常量不属于具体对象。 他们属于类。 按照约定，常量用大写字母表示。
```vb
Option Strict On
......@@ -667,7 +667,7 @@ End Function
```
创建的每个类都从基`Object`继承。 `ToString()`方法属于此 Object 类。 我们使用`Overrides`关键字来通知我们正在覆盖方法。
创建的每个类都从基`Object`继承。 `ToString()`方法属于此`Object`类。 我们使用`Overrides`关键字来通知我们正在覆盖方法。
```vb
Dim b as New Being
......@@ -751,7 +751,7 @@ Dim h As New Human
```
我们实例化派生的 Human 类。
我们实例化派生的`Human`类。
```vb
$ ./inheritance.exe
......@@ -961,7 +961,7 @@ Class Circle
```
圆是 Drawing 类的子类。 它必须实现抽象 Area（）方法。
圆是`Drawing`类的子类。 它必须实现抽象`Area()`方法。
```vb
$ ./abstractclass.exe
......
docs/dotnet/99.md
浏览文件 @ 921311b7
......@@ -13,7 +13,7 @@
* 蜜蜂
* 合约
对象通过这些方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实施情况。 程序员可能会在 GUI 工具箱的窗口中调用 Maximize 方法，但对如何实现此方法一无所知。 从这个角度来看，接口是一种方法，通过这些方法，对象可以与外界交互，而不会过多地暴露其内部工作原理。
对象通过这些方法与外界交互。 实际的实现对程序员而言并不重要，或者也可能是秘密的。 公司可能会出售图书馆，但它不想透露实际的实施情况。 程序员可能会在 GUI 工具箱的窗口中调用`Maximize`方法，但对如何实现此方法一无所知。 从这个角度来看，接口是一种方法，通过这些方法，对象可以与外界交互，而不会过多地暴露其内部工作原理。
从第二个角度来看，接口就是契约。 如果达成协议，则必须遵循。 它们用于设计应用的体系结构。 他们帮助组织代码。
......@@ -265,7 +265,7 @@ Connecting to the database
## 多态性
多态是以不同方式将运算符或函数用于不同数据输入的过程。 实际上，多态性意味着如果类 B 从类 A 继承，则不必继承关于类 A 的所有内容； 它可以完成 A 类所做的某些事情。 （维基百科）
多态是以不同方式将运算符或函数用于不同数据输入的过程。 实际上，多态性意味着如果类`B`从类`A`继承，则不必继承关于类`A`的所有内容； 它可以完成`A`类所做的某些事情。 （维基百科）
通常，多态性是以不同形式出现的能力。 从技术上讲，它是重新定义派生类的方法的能力。 多态性与将特定实现应用于接口或更通用的基类有关。
......@@ -327,7 +327,7 @@ End Module
```
在上面的程序中，我们有一个抽象的 Shape 类。 该类变形为两个后代类，即 Rectangle 和 Square。 两者都提供了自己的 Area（）方法的实现。 多态为 OOP 系统带来了灵活性和可伸缩性。
在上面的程序中，我们有一个抽象的`Shape`类。 该类变形为两个后代类，即`Rectangle`和`Square`。 两者都提供了自己的`Area()`方法的实现。 多态为 OOP 系统带来了灵活性和可伸缩性。
```vb
Public Overrides Function Area() As Integer
......@@ -340,7 +340,7 @@ End Function
```
Rectangle 和 Square 类具有 Area 方法的自己的实现。
`Rectangle`和`Square`类具有`Area`方法的自己的实现。
```vb
Dim shapes() As Shape = { New Square(5), _
......@@ -357,7 +357,7 @@ Next
```
我们遍历每个形状并在其上调用 Area 方法。 编译器为每种形状调用正确的方法。 这就是多态性的本质。
我们遍历每个形状并在其上调用`Area`方法。 编译器为每种形状调用正确的方法。 这就是多态性的本质。
## `NotOverridable`，`NotInheritable`
......@@ -396,7 +396,7 @@ End Module
```
该程序将无法编译。 我们收到错误消息“ Public Overrides Sub Say（）”无法覆盖“ Public NotOverridable Sub Say（）”，因为它被声明为“ NotOverridable”。
该程序将无法编译。 我们收到错误消息“`Public Overrides Sub Say()`”无法覆盖“`Public NotOverridable Sub Say()`”，因为它被声明为“`NotOverridable`”。
```vb
Option Strict On
......@@ -540,7 +540,7 @@ Dim col As New Color(23, 42, 223)
```
我们创建 Color 对象的实例。
我们创建`Color`对象的实例。
```vb
Dim obj1 As New MyObject(23, "small", col)
......@@ -563,7 +563,7 @@ obj2.Col.red = 255
```
在这里，我们修改复制对象的成员字段。 我们增加 Id，将 Size 更改为“ big”，然后更改颜色对象的红色部分。
在这里，我们修改复制对象的成员字段。 我们增加`Id`，将`Size`更改为`"big"`，然后更改颜色对象的红色部分。
```vb
Console.WriteLine(obj1)
......@@ -571,7 +571,7 @@ Console.WriteLine(obj2)
```
`Console.WriteLine()`方法调用 obj2 对象的`ToString()`方法，该方法返回对象的字符串表示形式。
`Console.WriteLine()`方法调用`obj2`对象的`ToString()`方法，该方法返回对象的字符串表示形式。
```vb
Id: 23, Size: small, Color:(255, 42, 223)
......@@ -579,7 +579,7 @@ Id: 24, Size: big, Color:(255, 42, 223)
```
我们可以看到 ID 分别为 23 和 24。大小不同。 “小”对“大”。 但是，这两个实例的颜色对象的红色部分相同：255。更改克隆对象的成员值（Id，Size）不会影响原始对象。 更改引用对象（Col）的成员也影响了原始对象。 换句话说，两个对象都引用内存中的同一颜色对象。
我们可以看到 ID 分别为 23 和 24。大小不同。 “小”对“大”。 但是，这两个实例的颜色对象的红色部分相同：255。更改克隆对象的成员值（`Id`，`Size`）不会影响原始对象。 更改引用对象（`Col`）的成员也影响了原始对象。 换句话说，两个对象都引用内存中的同一颜色对象。
要更改此行为，我们接下来将做一个深层复制。
......@@ -687,7 +687,7 @@ End Function
```
现在，当我们克隆 MyObject 时，我们以 Col 引用类型调用`Clone()`方法。 这样，我们也可以获得颜色值的副本。
现在，当我们克隆`MyObject`时，我们以`Col`引用类型调用`Clone()`方法。 这样，我们也可以获得颜色值的副本。
```vb
$ ./deepcopy.exe
......@@ -702,7 +702,7 @@ Id: 24, Size: big, Color:(255, 42, 223)
异常是为处理异常的发生而设计的，这些特殊情况会改变程序执行的正常流程。 引发或引发异常。
在执行应用期间，许多事情可能出错。 磁盘可能已满，我们无法保存文件。 Internet 连接可能断开，我们的应用尝试连接到站点。 所有这些都可能导致我们的应用崩溃。 为避免发生这种情况，我们必须应对可能发生的所有可能的错误。 为此，我们可以使用异常处理。
在执行应用期间，许多事情可能出错。 磁盘可能已满，我们无法保存文件。 互联网连接可能断开，我们的应用尝试连接到站点。 所有这些都可能导致我们的应用崩溃。 为避免发生这种情况，我们必须应对可能发生的所有可能的错误。 为此，我们可以使用异常处理。
`Try`，`Catch`和`Finally`关键字用于处理异常。
......@@ -750,7 +750,7 @@ Catch e As Exception
异常类型跟随`Catch`关键字。 在我们的例子中，我们有一个通用的`Exception`，它将捕获任何类型的异常。 有一些通用的例外，还有一些更具体的例外。 发生错误时，将执行`Catch`关键字后面的语句。 发生异常时，将创建一个异常对象。 从该对象中，我们获得`Message`属性并将其打印到控制台。
当前上下文中任何未捕获的异常都会传播到更高的上下文，并寻找适当的 catch 块来处理它。 如果找不到任何合适的 catch 块，则.NET 运行时的默认机制将终止整个程序的执行。
当前上下文中任何未捕获的异常都会传播到更高的上下文，并寻找适当的 `catch`块来处理它。 如果找不到任何合适的`catch`块，则 .NET 运行时的默认机制将终止整个程序的执行。
```vb
Option Strict On
......@@ -771,7 +771,7 @@ End Module
```
在此程序中，我们除以零。 我们没有自定义异常处理。 在 Visual Basic 2008 Express 上，我们收到以下错误消息：“未处理的异常：System.DivideByZeroException：试图除以零。”。
在此程序中，我们除以零。 我们没有自定义异常处理。 在 Visual Basic 2008 Express 上，我们收到以下错误消息：“未处理的异常：`System.DivideByZeroException`：试图除以零。”。
```vb
Option Strict On
......@@ -912,7 +912,7 @@ Class BigValueException
```
我们有一个 BigValueException 类。 该类派生自内置的`Exception`类。
我们有一个`BigValueException`类。 该类派生自内置的`Exception`类。
```vb
Dim Const LIMIT As Integer = 333
......@@ -949,7 +949,7 @@ Catch e As BigValueException
## 属性
属性是特殊的类成员。 我们使用预定义的 set 和 get 方法来访问和修改它们。 属性读取和写入会转换为获取和设置方法调用。 与使用自定义方法调用（例如`object.GetName()`）相比，使用字段符号（例如`object.Name`）访问变量更容易。 但是，就属性而言，我们仍然具有封装和信息隐藏的优势。
属性是特殊的类成员。 我们使用预定义的设置和获取方法来访问和修改它们。 属性读取和写入会转换为获取和设置方法调用。 与使用自定义方法调用（例如`object.GetName()`）相比，使用字段符号（例如`object.Name`）访问变量更容易。 但是，就属性而言，我们仍然具有封装和信息隐藏的优势。
```vb
Option Strict On
......@@ -1012,7 +1012,7 @@ End Set
```
类似地，`Set`关键字为 _name 字段创建一个 mutator 方法。
类似地，`Set`关键字为`_name`字段创建一个修改器方法。
```vb
Dim p as New Person
......@@ -1034,7 +1034,7 @@ Jane
## 委托
委托是.NET Framework 使用的一种类型安全的函数指针。 委托通常用于实现回调和事件侦听器。
委托是 .NET Framework 使用的一种类型安全的函数指针。 委托通常用于实现回调和事件侦听器。
```vb
Option Strict On
......@@ -1306,7 +1306,7 @@ AddHandler gen.ValueFive, AddressOf five.OnFiveEvent
```
我们将 ValueFive 事件插入其处理程序。
我们将`ValueFive`事件插入其处理程序。
```vb
$ ./event2.exe
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或