C#入门篇6（面向对象）
目录
一、类
1、概念
2、语法
3、使用
3、提示
二、属性
1、属性 是一个类的成员，通常由两个方法组成：
2、语法
3、使用
三、静态和非静态的区别
1、定义方式：
2、访问对象数据：
3、调用方式：
4、用途：
四、构造函数
1、格式
2、特点
3、使用
五、this关键字
1. 访问实例变量和方法
2. 调用同一类中的其他构造函数
3. 返回当前对象
4. 在索引器中使用 this
总结：
六、析构函数
1、格式
2、特点
3、使用
七、命名空间
1、格式
2、 使用
3、导入命名空间的方法
方法 1：使用 using 指令
方法 2：命名空间搜索
方法 3：全局导入
方法 4：使用 NuGet 包管理器
方法 5：项目文件中的 元素
一、类
1、概念
类（Class）是面向对象编程中的核心概念，它定义了对象的属性和方法。
2、语法
public class ClassName { // 成员变量（属性） public int Property { get; set; } // 构造函数 public ClassName() { // 初始化代码 } // 方法 public void MethodName() { // 执行代码 } } /*public class ClassName：定义一个类，ClassName 是类的名称。 属性（Property）：用于存储对象的状态。 构造函数（Constructor）：用于初始化对象。构造函数的名称与类名相同，并且没有返回类型。 方法（Method）：定义了类的行为。*/
3、使用
/*Person 类包含了 Name 和 Age 属性，和一个 Greet 方法。
Person 类的构造函数用于初始化 Name 和 Age 属性。
在 Main 方法中，我们创建了 Person 类的一个对象 person1，并调用了 Greet 方法。*/
// 定义一个 Person 类
public class Person
{
// 属性
public string Name { get; set; }
public int Age { get; set; }
// 构造函数
public Person(string name, int age)
{
Name = name;
Age = age;
}
// 方法
public void Greet()
{
Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
}
}
// 使用 Person 类
public class Program
{
public static void Main()
{
// 创建 Person 类的对象
Person person1 = new Person("Alice", 30);
// 调用方法
person1.Greet();
}
}/*BankAccount 类包含了一个私有字段 balance，用于存储账户余额。
提供了 Deposit 和 Withdraw 方法来操作账户余额。
GetBalance 方法用于获取当前余额。*/
// 定义一个 BankAccount 类
public class BankAccount
{
// 私有字段
private decimal balance;
// 构造函数
public BankAccount(decimal initialBalance)
{
balance = initialBalance;
}
// 方法：存款
public void Deposit(decimal amount)
{
if (amount > 0)
{
balance += amount;
}
}
// 方法：取款
public bool Withdraw(decimal amount)
{
if (amount > 0 && amount <= balance)
{
balance -= amount;
return true;
}
return false;
}
// 方法：获取余额
public decimal GetBalance()
{
return balance;
}
}
// 使用 BankAccount 类
public class Program
{
public static void Main()
{
// 创建 BankAccount 类的对象
BankAccount account = new BankAccount(1000m);
// 存款
account.Deposit(500m);
// 取款
bool success = account.Withdraw(200m);
if (success)
{
Console.WriteLine("Withdrawal successful.");
}
else
{
Console.WriteLine("Withdrawal failed.");
}
// 获取余额
Console.WriteLine($"Current balance: {account.GetBalance()}");
}
}3、提示
- 表示当前类的对象可以用this
- 类不占内存空间，创建出来的类占用内存
二、属性
1、属性 是一个类的成员，通常由两个方法组成：
- getter：用于读取属性值。
- setter：用于设置属性值
2、语法
/*private int _property：一个私有字段，用于存储属性的实际值。 public int Property：属性的定义，包括 getter 和 setter。 get：方法用于返回字段的值。 set：方法用于设置字段的值，value 是传递给 setter 的值。*/ public class ClassName { // 私有字段 private int _property; // 公共属性 public int Property { get { return _property; } // 获取属性值 set { _property = value; } // 设置属性值 } }
3、使用
- 有get 有set 可读可写
- 有get没有set 可读
- 有set没有get 可写
/*Person 类有一个私有字段 _name 和一个公共属性 Name。Name 属性的 setter 方法中包含了一个验证逻辑，确保姓名不为空。
Age 属性是一个自动实现的属性，C# 编译器会自动创建一个隐式的私有字段来存储 Age 的值。*/
// 定义一个 Person 类
public class Person
{
// 私有字段
private string _name;
// 公共属性
public string Name
{
get { return _name; }
set
{
// 可以添加一些验证逻辑
if (!string.IsNullOrEmpty(value))
{
_name = value;
}
}
}
// 另一个属性
public int Age { get; set; } // 自动实现的属性
}
// 使用 Person 类
public class Program
{
public static void Main()
{
// 创建 Person 类的对象
Person person = new Person();
// 设置属性值
person.Name = "Alice";
person.Age = 30;
// 获取属性值
Console.WriteLine($"Name: {person.Name}");
Console.WriteLine($"Age: {person.Age}");
}
}/*Circle 类有一个私有字段 _radius 和一个只读属性 Radius。Radius 属性只有 getter，没有 setter，因此它是只读的。
Circle 类的构造函数用于初始化 Radius，GetArea 方法用于计算圆的面积。*/
// 定义一个 Circle 类
public class Circle
{
// 私有字段
private double _radius;
// 构造函数
public Circle(double radius)
{
_radius = radius;
}
// 只读属性
public double Radius
{
get { return _radius; }
}
// 计算圆的面积
public double GetArea()
{
return Math.PI * _radius * _radius;
}
}
// 使用 Circle 类
public class Program
{
public static void Main()
{
// 创建 Circle 类的对象
Circle circle = new Circle(5.0);
// 获取属性值
Console.WriteLine($"Radius: {circle.Radius}");
// 计算面积
Console.WriteLine($"Area: {circle.GetArea()}");
}
}三、静态和非静态的区别
1、定义方式：
静态方法：使用 static 关键字定义。静态方法属于类本身，而不是类的实例。它们可以在不创建类实例的情况下被调用。
非静态方法：没有 static 关键字。非静态方法属于类的实例，每次调用时必须通过类的对象来访问。
2、访问对象数据：
静态方法：不能直接访问实例变量和实例方法。它们只能访问类变量和其他静态方法。静态方法不能使用 this 关键字，因为它不属于任何具体的实例。
非静态方法：可以访问类的所有成员，包括实例变量、静态变量、实例方法和静态方法。非静态方法使用 this 关键字来引用当前对象。
3、调用方式：
静态方法：可以通过类名直接调用，例如 ClassName.staticMethod()。静态方法也可以通过类的实例调用，但不推荐这种做法。
非静态方法：必须通过类的实例调用，例如 instance.nonStaticMethod()。
4、用途：
静态方法：通常用于那些不依赖于类的实例数据的功能，如工具类方法（例如 Math.max()）。
非静态方法：通常用于处理特定实例的数据和行为，需要依赖于实例的状态。
public class Example {
static int staticVar = 0; // 静态变量
int instanceVar = 1; // 实例变量
static void staticMethod() {
System.out.println("Static method called");
// System.out.println(instanceVar); // 错误：无法访问实例变量
}
void instanceMethod() {
System.out.println("Instance method called");
System.out.println(staticVar); // 可以访问静态变量
System.out.println(instanceVar); // 可以访问实例变量
}
}四、构造函数
构造函数（Constructor）是一个特殊的函数，用于初始化对象的状态
1、格式
class ClassName { // 构造函数 ClassName() { // 初始化代码 } }
2、特点
- 名称与类名相同：构造函数的名称必须与类的名称完全相同。
- 没有返回类型：构造函数没有返回值类型（包括
void）。 - 可以重载：在同一个类中可以定义多个构造函数，它们之间可以有不同的参数列表（参数类型和数量可以不同）。
- 自动调用：当创建对象时，构造函数会被自动调用。
3、使用
/*默认构造函数：public Person() 是一个没有参数的构造函数，每次创建 Person 对象时，将 name 初始化为 “未知”，age 初始化为 0。
带参数的构造函数：public Person(String name, int age) 是一个接收参数的构造函数，允许用户在创建对象时设置 name 和 age 的值。
对象创建：在 main 方法中，首先调用默认构造函数创建 person1，然后调用带参数的构造函数创建 person2。
方法调用：调用 printInfo 方法来输出每个对象的姓名和年龄。*/
public class Person {
private String name;
private int age;
// 默认构造函数
public Person() {
this.name = "未知";
this.age = 0;
}
// 带参数的构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 打印信息的方法
public void printInfo() {
System.out.println("姓名: " + name + ", 年龄: " + age);
}
public static void main(String[] args) {
// 使用默认构造函数
Person person1 = new Person();
person1.printInfo(); // 输出: 姓名: 未知, 年龄: 0
// 使用带参数的构造函数
Person person2 = new Person("Alice", 25);
person2.printInfo(); // 输出: 姓名: Alice, 年龄: 25
}
}五、this关键字
1. 访问实例变量和方法
在类的实例方法中，this 关键字用于访问当前对象的实例变量和方法。如果方法的参数名称与实例变量名称相同，可以使用 this 来区分它们。
public class Person
{
private string name;
private int age;
// 构造函数
public Person(string name, int age)
{
this.name = name; // 使用 this 来访问实例变量
this.age = age;
}
// 设置名称的方法
public void SetName(string name)
{
this.name = name; // 使用 this 来区分实例变量和方法参数
}
// 打印信息的方法
public void PrintInfo()
{
Console.WriteLine($"姓名: {this.name}, 年龄: {this.age}");
}
}2. 调用同一类中的其他构造函数
在一个构造函数中可以使用 this() 来调用同一类中的另一个构造函数。这种方式有助于减少重复代码。
public class Person
{
private string name;
private int age;
// 带参数的构造函数
public Person(string name, int age)
{
this.name = name;
this.age = age;
}
// 无参数构造函数
public Person() : this("未知", 0) // 使用 this() 调用另一个构造函数
{
}
public void PrintInfo()
{
Console.WriteLine($"姓名: {this.name}, 年龄: {this.age}");
}
}3. 返回当前对象
可以使用 this 关键字在方法中返回当前对象，以便于实现链式调用（method chaining）
public class Person
{
private string name;
private int age;
public Person SetName(string name)
{
this.name = name;
return this; // 返回当前对象
}
public Person SetAge(int age)
{
this.age = age;
return this; // 返回当前对象
}
public void PrintInfo()
{
Console.WriteLine($"姓名: {this.name}, 年龄: {this.age}");
}
}
public class Program
{
public static void Main()
{
// 链式调用示例
Person person = new Person()
.SetName("Alice")
.SetAge(25);
person.PrintInfo(); // 输出: 姓名: Alice, 年龄: 25
}
}4. 在索引器中使用 this
在 C# 中，索引器允许你通过数组下标语法访问对象的属性。this 关键字可以在索引器中使用
public class MyCollection
{
private int[] items = new int[10];
// 索引器
public int this[int index]
{
get { return items[index]; }
set { items[index] = value; }
}
}
public class Program
{
public static void Main()
{
MyCollection collection = new MyCollection();
collection[0] = 42; // 使用索引器设置值
Console.WriteLine(collection[0]); // 使用索引器获取值，输出: 42
}
}总结：
在 C# 中，this 关键字主要用于：
- 访问当前对象的实例变量和方法，尤其是当参数和实例变量名称冲突时。
- 在构造函数中调用其他构造函数。
- 返回当前对象以支持链式调用。
- 在索引器中进行自定义访问
六、析构函数
用于清理资源和执行必要的清理操作的特殊方法。它会在对象被垃圾回收时自动调用。
1、格式
class ClassName { // 析构函数 ~ClassName() { // 清理代码 } }
2、特点
- 名称：析构函数的名称与类名相同，但前面带有波浪号（
~）。 - 没有参数和返回值：析构函数不能有参数，也不能返回值。
- 不能被手动调用：析构函数只能由垃圾回收器自动调用，不能在代码中直接调用。
- 适用于资源管理：通常用于释放非托管资源，如文件句柄、数据库连接等。
3、使用
using System;
public class ResourceHandler
{
private string resourceName;
// 构造函数
public ResourceHandler(string name)
{
resourceName = name;
Console.WriteLine($"{resourceName} 被创建.");
}
// 析构函数
~ResourceHandler()
{
Console.WriteLine($"{resourceName} 被销毁.");
// 在这里释放资源（如关闭文件、数据库连接等）
}
public void UseResource()
{
Console.WriteLine($"{resourceName} 正在使用.");
}
}
public class Program
{
public static void Main()
{
ResourceHandler handler = new ResourceHandler("文件资源");
handler.UseResource();
// 显式将对象设置为 null，促使垃圾回收（这并不保证立即回收）
handler = null;
// 手动调用垃圾回收器（建议在实际代码中不要过多使用）
GC.Collect();
GC.WaitForPendingFinalizers();
}
}七、命名空间
在 C# 中，命名空间（namespace）是一种组织代码的机制，它用于将相关的类、结构体、接口、枚举等类型归类在一起，从而提高代码的可读性和维护性。命名空间可以帮助避免名称冲突，并使代码结构更清晰。
1、格式
namespace NamespaceName { // 类型定义 class ClassName { // 成员定义 } }
2、 使用
using System;
namespace MyApplication
{
namespace Utilities
{
public class Helper
{
public void DisplayMessage()
{
Console.WriteLine("Hello from Utilities.Helper!");
}
}
}
namespace Models
{
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public void PrintInfo()
{
Console.WriteLine($"Name: {Name}, Age: {Age}");
}
}
}
}
namespace MyApplication.Test
{
public class TestClass
{
public void RunTest()
{
// 创建 Models 命名空间中的 Person 对象
MyApplication.Models.Person person = new MyApplication.Models.Person
{
Name = "Alice",
Age = 30
};
person.PrintInfo();
// 创建 Utilities 命名空间中的 Helper 对象
MyApplication.Utilities.Helper helper = new MyApplication.Utilities.Helper();
helper.DisplayMessage();
}
}
}
public class Program
{
public static void Main()
{
MyApplication.Test.TestClass test = new MyApplication.Test.TestClass();
test.RunTest();
}
}using 指令：
- 如果在文件顶部使用
using指令，可以简化命名空间的引用。例如，如果需要频繁使用MyApplication.Models和MyApplication.Utilities中的类型，可以在文件开始处添加using MyApplication.Models;和using MyApplication.Utilities;。这样，在文件中可以直接使用类名而不需要写全名。
using MyApplication.Models;
using MyApplication.Utilities;
namespace MyApplication.Test
{
public class TestClass
{
public void RunTest()
{
Person person = new Person
{
Name = "Alice",
Age = 30
};
person.PrintInfo();
Helper helper = new Helper();
helper.DisplayMessage();
}
}
}3、导入命名空间的方法
在 Visual Studio 2022 中导入命名空间通常有以下几种方法：
方法 1：使用 using 指令
这通常是导入单个命名空间或多个命名空间的最常见方式。在代码文件顶部添加 using 指令，以允许在文件中使用特定命名空间下的类型而无需完全限定它们。例如：
using System;
using System.Collections.Generic;
方法 2：命名空间搜索
如果你在使用某个类或类型时需要完整限定名称（即 完全限定名.类型），Visual Studio 会给出提示，让你可以通过按下 Alt + Enter 或点击提示的弹窗来快速导入该命名空间。这将添加相应的 using 指令到文件的顶部。
方法 3：全局导入
通过在解决方案资源的 Solution Explorer 中选择项目，然后点击右键选择 Add > Existing Item... 可以选择或者创建一个 using.cs 文件（或 usings.xml）。在这个文件中，可以添加全局导入的命名空间，然后在项目中所有代码文件中将使用这些导入的命名空间。
方法 4：使用 NuGet 包管理器
如果使用的是通过 NuGet 管理包的管理项目（比如 ASP.NET Core 项目），一些第三方库可能已经有一个“引用全局导入”选项。
方法 5：项目文件中的
在项目文件 .csproj 中，可以通过
...
以上就是在 Visual Studio 2022 中导入命名空间的常见方法。选择哪种方法取决于项目的具体需求和你个人的偏好。