学习c#的第十四天

[C# 接口（Interface）](# 接口（Interface）)

接口的特点

定义接口

接口继承

接口和抽象类的区别

[C# 命名空间（Namespace）](# 命名空间（Namespace）)

[using 关键字](#using 关键字)

定义命名空间

嵌套命名空间

C# 接口（Interface）

接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 "是什么" 部分，派生类定义了语法合同 "怎么做" 部分。

接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。

接口使得实现接口的类或结构在形式上保持一致。

抽象类在某种程度上与接口类似，但是，它们大多只是用在当只有少数方法由基类声明由派生类实现时。

接口本身并不实现任何功能，它只是和声明实现该接口的对象订立一个必须实现哪些行为的契约。

抽象类不能直接实例化，但允许派生出具体的，具有实际功能的类。

接口的特点

多重继承：通过接口可以实现多重继承，一个类可以实现多个接口。这使得接口在解决单继承语言中的多继承问题时非常有用。
无法直接实例化：接口不能被直接实例化，因为接口只定义了成员的签名，没有具体的实现。需要通过实现接口的类来创建对象。
成员的默认访问修饰符为public：接口中的成员默认为public，因为接口的目的是提供给外部使用。在C#中，不需要显式指定public修饰符。
成员不能有修饰符：接口中的成员（方法、属性、事件、索引器）不能有修饰符，如new、static、abstract、override、virtual等。
需要实现所有接口成员：如果一个类实现了一个接口，那么该类必须实现接口中定义的所有成员。否则，该类必须声明为抽象类。
接口成员可以被隐藏：当一个类实现多个接口时，如果多个接口中有相同的成员名称，可以使用关键字new来隐藏父接口中的成员。
接口可以包含属性：接口中可以定义属性，包括具有get和set访问器的自动属性。

总之，接口是一种定义了一组函数成员的引用类型，具有多重继承、无法直接实例化、必须实现所有成员等特点，通过实现接口可以为类提供共享的行为和功能。

定义接口

C# 中的接口（Interface）是一种抽象类型，它定义了对象应该具有的行为而不包含任何实际的实现。接口可以包含方法、属性、事件和索引器的声明，但不能包含字段或实例构造函数。

接口通过关键字 interface 进行声明，成员默认为公共的，并且不能包含访问修饰符。类可以实现一个或多个接口，并且接口之间可以进行多重继承。

下面是一个简单的接口示例：

cs 复制代码

using System;

// 定义接口
public interface IShape
{
    void Draw();  // 方法声明
    string Name { get; set; }  // 属性声明
}

// 实现接口
public class Circle : IShape
{
    public string Name { get; set; }  // 实现属性

    public void Draw()  // 实现方法
    {
        Console.WriteLine("正在绘制圆。。。");
    }
}

public class Rectangle : IShape
{
    public string Name { get; set; }

    public void Draw()
    {
        Console.WriteLine("正在绘制矩形。。。");
    }
}

class Program
{
    static void Main()
    {
        IShape shape1 = new Circle();
        shape1.Name = "Circle";
        shape1.Draw();  // 输出结果：正在绘制圆。。。

        IShape shape2 = new Rectangle();
        shape2.Name = "Rectangle";
        shape2.Draw();  // 输出结果：正在绘制矩形。。。
    }
}

在上述代码中，定义了一个 IShape 接口，其中包含一个方法 Draw 和一个属性 Name。然后，Circle 类和 Rectangle 类分别实现了 IShape 接口，并提供了对应的方法和属性的实现。在 Main 方法中，创建了 Circle 和 Rectangle 的实例，并分别赋值给 IShape 类型的变量，调用其方法和属性。

接口继承

在C#中，接口可以继承自一个或多个接口，这种机制被称为接口继承。通过接口继承，一个接口可以从一个或多个基接口中继承成员，从而构建更为灵活和复杂的接口体系。

下面是一个简单的接口继承示例：

cs 复制代码

using System;

// 定义基础接口
public interface IShape
{
    void Draw();
}

// 定义继承接口
public interface IResizableShape : IShape
{
    void Resize(int percentage);
}

// 实现接口
public class Circle : IResizableShape
{
    public void Draw()
    {
        Console.WriteLine("正在绘制圆。。。");
    }

    public void Resize(int percentage)
    {
        Console.WriteLine($"调整圆的大小为 {percentage}%");
    }
}

class Program
{
    static void Main()
    {
        IResizableShape shape = new Circle();
        shape.Draw();   // 输出结果：正在绘制圆。。。
        shape.Resize(50);  // 输出结果：调整圆的大小为 50%
    }
}

在上述代码中，定义了一个基础接口 IShape，它包含了一个 Draw 方法。然后定义了一个继承接口 IResizableShape，它继承自 IShape 接口，并新增了一个 Resize 方法。最后，Circle 类实现了 IResizableShape 接口。

在 Main 方法中，创建了 Circle 的实例，并将其赋值给 IResizableShape 类型的变量，然后调用了其继承自基础接口和新增方法，可以看到接口继承可以让代码更加灵活和可扩展。

接口和抽象类的区别

接口和抽象类的主要区别如下：

继承关系：接口可以被多个类实现，而抽象类只能被单一类继承。
方法实现：接口只能声明方法、属性、事件和索引器，不包含方法的具体实现；而抽象类可以包含方法的实现。
多继承：由于单一继承的限制，使用抽象类时，如果要继承其他类，则只能通过接口来实现多重继承。
实例化：抽象类不能直接实例化，需要通过子类进行实例化；而接口本身不能实例化，需要通过实现接口的类来实例化。
修改影响：抽象类在增加新方法时，子类需要重新编译以实现新增的方法；而接口在增加新方法时，实现类需要手动实现新增的方法。
成员类型：接口中的成员默认为public（公共）的，而抽象类的成员可以有各种访问修饰符。
内容限制：接口中只能包含方法、属性、事件和索引器的声明，不包含字段、构造函数、析构函数、静态成员或常量；而抽象类可以包含这些成员。

还有一点，我们在VS中实现接口时会发现有2个选项，一个是实现接口，一个是显示实现接口。"实现接口"是常规的实现方式，实现的方法属于实现类的公共方法；而"显示实现接口"是一种特殊的实现方式，实现的方法不会作为实现类的公共方法，而是只能通过接口引用来调用。

C# 命名空间（Namespace）

命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式。在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。

我们举一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。

using 关键字

using的用法：

1、using 指令：引入命名空间这是最常见的用法，通过 using 指令可以引入命名空间，使得在代码中可以直接使用该命名空间下的类型、类成员等。例如：

cs 复制代码

using System;
using Namespace1.SubNamespace;

上述代码中，我们引入了 System 命名空间和 Namespace1.SubNamespace 命名空间，这样就可以直接使用它们下面的类型和成员。

2、using static 指令：指定无需指定类型名称即可访问其静态成员的类型 using static 指令允许我们直接使用某个类型的静态成员，而无需指定类型名称。例如：

cs 复制代码

using static System.Math;
var value = PI; // 直接使用 System.Math.PI

上述代码中，我们使用 using static System.Math，这样就可以直接使用 Math 类的静态成员，如 PI，而无需写成 Math.PI。

3、起别名有时候命名空间的名称可能很长，为了简化代码，可以为命名空间起一个别名。例如：

cs 复制代码

using Project = PC.MyCompany.Project;

上述代码中，我们将 PC.MyCompany.Project 命名空间起了一个别名 Project，这样在代码中就可以使用 Project 来代替 PC.MyCompany.Project。

4、using 语句：将实例与代码绑定 using 语句用于在代码段结束时，自动调用对象的 Dispose 方法，释放资源。例如：

cs 复制代码

using (Font font3 = new Font("Arial", 10.0f),
        font4 = new Font("Arial", 10.0f))
{
    // 使用 font3 和 font4
}

上述代码中，我们创建了两个 Font 对象，并将它们放在 using 语句中。当代码块执行完毕时，会自动调用 font3 和 font4 的 Dispose 方法来释放资源。

定义命名空间

命名空间的定义是以关键字 namespace 开始，后跟命名空间的名称，如下所示：

cs 复制代码

namespace namespace_name
{
   // 代码声明
}

下面是一个简单的示例，展示了如何定义和使用命名空间：

cs 复制代码

using System;

namespace MyNamespace
{
    class MyClass
    {
        public void MyMethod()
        {
            Console.WriteLine("这是我的类中的一个方法。");
        }
    }

    interface MyInterface
    {
        void MyMethod();
    }
}

namespace AnotherNamespace
{
    class AnotherClass
    {
        public void AnotherMethod()
        {
            Console.WriteLine("这是另一个类中的一个方法。");
        }
    }
}

在上面的示例中，我们定义了两个命名空间：MyNamespace 和 AnotherNamespace。MyNamespace 中包含了一个名为 MyClass 的类和一个名为 MyInterface 的接口。AnotherNamespace 中包含了一个名为 AnotherClass 的类。

要在另一个代码文件中使用这些命名空间中的成员，可以按照以下方式进行引用：

cs 复制代码

using MyNamespace;
using AnotherNamespace;

class Program
{
    static void Main()
    {
        MyClass myObject = new MyClass();
        myObject.MyMethod();  // 调用 MyNamespace 中的方法

        AnotherClass anotherObject = new AnotherClass();
        anotherObject.AnotherMethod();  // 调用 AnotherNamespace 中的方法
    }
}

在上述示例中，我们在 Program 类中通过 using 关键字引入了 MyNamespace 和 AnotherNamespace，然后可以直接使用这两个命名空间下的类和方法。

嵌套命名空间

在C#中，命名空间可以进行嵌套，即一个命名空间可以包含在另一个命名空间中。这种嵌套的结构可以用于更好地组织和管理代码，如下所示：

cs 复制代码

namespace namespace_name1 
{
   // 代码声明
   namespace namespace_name2 
   {
     // 代码声明
   }
}

下面是一个示例，展示了如何定义和使用嵌套命名空间：

cs 复制代码

using System;

namespace OuterNamespace
{
    class OuterClass
    {
        public void OuterMethod()
        {
            Console.WriteLine("这是OuterClass中的一个方法。");
        }
    }

    namespace InnerNamespace
    {
        class InnerClass
        {
            public void InnerMethod()
            {
                Console.WriteLine("这是内部类中的一个方法。");
            }
        }
    }
}

在上面的示例中，我们定义了两个命名空间：OuterNamespace 和 InnerNamespace。InnerNamespace 嵌套在 OuterNamespace 中。

要在另一个代码文件中使用嵌套命名空间中的成员，可以按照以下方式进行引用：

cs 复制代码

using OuterNamespace;
using OuterNamespace.InnerNamespace;

class Program
{
    static void Main()
    {
        OuterClass outerObject = new OuterClass();
        outerObject.OuterMethod();  // 调用 OuterNamespace 中的方法

        InnerClass innerObject = new InnerClass();
        innerObject.InnerMethod();  // 调用 InnerNamespace 中的方法
    }
}

在上述示例中，我们在 Program 类中通过 using 关键字引入了 OuterNamespace 和 OuterNamespace.InnerNamespace，然后可以直接使用这两个命名空间下的类和方法。

嵌套命名空间可以帮助我们更好地组织和管理代码，提高可读性和可维护性。