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、特点
  1. 名称与类名相同:构造函数的名称必须与类的名称完全相同。
  2. 没有返回类型:构造函数没有返回值类型(包括 void)。
  3. 可以重载:在同一个类中可以定义多个构造函数,它们之间可以有不同的参数列表(参数类型和数量可以不同)。
  4. 自动调用:当创建对象时,构造函数会被自动调用。
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、特点
  1. 名称:析构函数的名称与类名相同,但前面带有波浪号(~)。
  2. 没有参数和返回值:析构函数不能有参数,也不能返回值。
  3. 不能被手动调用:析构函数只能由垃圾回收器自动调用,不能在代码中直接调用。
  4. 适用于资源管理:通常用于释放非托管资源,如文件句柄、数据库连接等。
 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 中导入命名空间的常见方法。选择哪种方法取决于项目的具体需求和你个人的偏好。

你可能感兴趣的:(c#,开发语言,c#入门)