C# 对象
对象是 C# OOP 程序的基本构建块。 对象是数据和方法的组合。 数据和方法称为对象的成员。 在 OOP 程序中，我们创建对象。 这些对象通过方法进行通信。 每个对象都可以接收消息，发送消息和处理数据。
创建对象有两个步骤。 首先，我们定义一个类。 类是对象的模板。 它是一个蓝图，描述了类对象共享的状态和行为。 一个类可以用来创建许多对象。 在运行时从类创建的对象称为该特定类的实例。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Program.
using System;
namespace Being
{
class Being {}
class Program
{
static void Main(string[] args)
{
var b = new Being();
Console.WriteLine(b);
}
}
}
在第一个示例中，我们创建一个简单的对象。
class Being {}
这是一个简单的类定义。 模板的主体为空。 它没有任何数据或方法。
var b = new Being();
我们创建Being类的新实例。 为此，我们使用了new关键字。 b变量是创建对象的句柄。
Console.WriteLine(b);
我们将对象打印到控制台以获取该对象的一些基本描述。 打印对象是什么意思？ 实际上，当我们打印对象时，我们将其称为ToString()方法。 但是我们还没有定义任何方法。 这是因为创建的每个对象都继承自基本object。 它具有一些基本功能，可以在所有创建的对象之间共享。 其中之一是ToString()方法。
1 2$ dotnet run Being.Being
我们得到对象类名。
C# 对象属性
对象属性是捆绑在类实例中的数据。 对象属性称为实例变量或成员字段。 实例变量是在类中定义的变量，该类中的每个对象都有一个单独的副本。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Program.
using System;
namespace ObjectAttributes
{
class Person
{
//实例变量,这个变量必须通过类实例化后才能操作
public string name;
}
class Program
{
static void Main(string[] args)
{
var p1 = new Person();
p1.name = "Jane";
var p2 = new Person();
p2.name = "Beky";
Console.WriteLine(p1.name);
Console.WriteLine(p2.name);
}
}
}
在上面的 C# 代码中，我们有一个带有一个成员字段的Person类。
1
2
3
4
class Person
{
public string name;
}
我们声明一个名称成员字段。 public关键字指定可以在类块之外访问成员字段。
1
2
var p1 = new Person();
p1.name = "Jane";
我们创建Person类的实例，并将名称变量设置为“ Jane”。 我们使用点运算符来访问对象的属性。
1
2
var p2 = new Person();
p2.name = "Beky";
我们创建Person类的另一个实例。 在这里，我们将变量设置为“ Beky”。
1 2Console.WriteLine(p1.name); Console.WriteLine(p2.name);
我们将变量的内容打印到控制台。
1 2 3$ dotnet run Jane Beky
我们看到了程序的输出。 Person类的每个实例都有一个单独的名称成员字段副本。
C# 方法
方法是在类主体内定义的函数。 它们用于通过对象的属性执行操作。 方法将模块化带入我们的程序。
在 OOP 范式的封装概念中，方法至关重要。 例如，我们的AccessDatabase类中可能有一个Connect()方法。 我们无需知道方法Connect()如何精确地连接到数据库。 我们只需要知道它用于连接数据库。 这对于划分编程中的职责至关重要，尤其是在大型应用中。
对象将状态/特性和行为分组，方法代表对象的行为部分。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Program.
using System;
namespace Methods
{
class Circle
{
private int radius;
public void SetRadius(int radius)
{
this.radius = radius;
}
public double Area()
{
return this.radius * this.radius * Math.PI;
}
}
class Program
{
static void Main(string[] args)
{
var c = new Circle();
c.SetRadius(5);
Console.WriteLine(c.Area());
}
}
}
在代码示例中，我们有一个 Circle 类。 我们定义了两种方法。
private int radius;
我们只有一个成员字段。 它是圆的半径。 private关键字是访问说明符。 它表明变量仅限于外部世界。 如果要从外部修改此变量，则必须使用公共可用的SetRadius()方法。 这样我们可以保护我们的数据。
1
2
3
4
public void SetRadius(int radius)
{
this.radius = radius;
}
这是SetRadius()方法。 this变量是一个特殊变量，我们用它来访问方法中的成员字段。 this.radius是实例变量，而半径是局部变量，仅在SetRadius()方法内部有效。
1
2
var c = new Circle();
c.SetRadius(5);
我们创建Circle类的实例，并通过在圆对象上调用SetRadius()方法来设置其半径。 我们使用点运算符来调用该方法。
1
2
3
4
public double Area()
{
return this.radius * this.radius * Math.PI;
}
Area()方法返回圆的面积。 Math.PI是内置常数。
1
2
$ dotnet run
78.5398163397448
运行该示例可得出此结果。
C# 访问修饰符
访问修饰符设置方法和成员字段的可见性。 C# 具有四个基本访问修饰符：public，protected，private和internal。 可以从任何地方访问public成员。 protected成员只能在类本身内部以及继承的和父类访问。 private成员仅限于包含类型，例如 仅在其类或接口内。 可以从同一程序集（exe 或 DLL）中访问internal成员。
修饰符还有两种组合：protected internal和private protected。 protected internal类型或成员可以由声明它的程序集中的任何代码访问，也可以从另一个程序集中的派生类中访问。 private protected类型或成员只能在其声明程序集中通过同一个类或从该类派生的类型的代码进行访问。
访问修饰符可防止意外修改数据。 它们使程序更强大。
| 类 | 当前程序集 | 派生类 | 当前程序集中的派生类 | 整个程序 | |
|---|---|---|---|---|---|
public |
+ | + | + | + | + |
protected |
+ | o | + | + | o |
internal |
+ | + | o | o | o |
private |
+ | o | o | o | o |
protected internal |
+ | + | + | + | o |
private protected |
+ | o | o | + | o |
上表总结了 C# 访问修饰符（+是可访问的，o 是不可访问的）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Program.
using System;
namespace AccessModifiers
{
class Person
{
public string name;
private int age;
public int GetAge()
{
return this.age;
}
public void SetAge(int age)
{
this.age = age;
}
}
class Program
{
static void Main(string[] args)
{
var p = new Person();
p.name = "Jane";
p.SetAge(17);
Console.WriteLine("{0} is {1} years old",
p.name, p.GetAge());
}
}
}
在上面的程序中，我们有两个成员字段。 一个被宣布为公开，另一个被宣布为私有。
1
2
3
4
public int GetAge()
{
return this.age;
}
如果成员字段是private，则访问它的唯一方法是通过方法。 如果要在类外部修改属性，则必须将方法声明为public。 这是数据保护的重要方面。
1
2
3
4
public void SetAge(int age)
{
this.age = age;
}
SetAge()方法使我们能够从类定义之外更改private年龄变量。
1
2
var p = new Person();
p.name = "Jane";
我们创建Person类的新实例。 因为名称属性是public，所以我们可以直接访问它。 但是，不建议这样做。
p.SetAge(17);
SetAge()方法修改年龄成员字段。 由于已声明private，因此无法直接访问或修改。
1
2
Console.WriteLine("{0} is {1} years old",
p.name, p.GetAge());
最后，我们访问两个成员以构建一个字符串。
1
2
$ dotnet run
Jane is 17 years old
运行示例将给出此输出。
具有private访问修饰符的成员字段不被派生类继承。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Program.
using System;
namespace Protected
{
class Base
{
public string name = "Base";
protected int id = 5323;
private bool isDefined = true;
}
class Derived : Base
{
public void info()
{
Console.WriteLine("This is Derived class");
Console.WriteLine("Members inherited");
Console.WriteLine(this.name);
Console.WriteLine(this.id);
// Console.WriteLine(this.isDefined);
}
}
class Program
{
static void Main(string[] args)
{
var derived = new Derived();
derived.info();
}
}
}
在前面的程序中，我们有一个Derived类，该类继承自Base类。 Base类具有三个成员字段。 全部具有不同的访问修饰符。 isDefined 成员不继承。 private修饰符可以防止这种情况。
class Derived : Base
类Derived继承自Base类。 要从另一个类继承，我们使用冒号（:)运算符。
1
2
3
Console.WriteLine(this.name);
Console.WriteLine(this.id);
// Console.WriteLine(this.isDefined);
public和protected成员由Derived类继承。 可以访问它们。 private成员未继承。 访问成员字段的行被注释。 如果我们取消注释该行，则代码将无法编译。
1
2
3
4
5
6
7
$ dotnet run
Program.(9,22): warning 0414: The field 'Base.isDefined' is assigned but its value
is never used [C:\Users\Jano\Documents\harp\tutorial\oop\Protected\Protected.proj]
This is Derived class
Members inherited
Base
5323
运行程序，我们收到此输出。
