类 方法

成员和类访问修饰符 - access specifier

  1. public:所有对象都可以访问;
  2. private:对象本身在对象内部可以访问; - 成员默认修饰符
  3. protected:只有该类对象及其子类对象可以访问
  4. internal:同一个程序集的对象可以访问; - 类默认修饰符
  5. protected internal:访问限于当前程序集或派生自包含类的类型。

1-3 与普通的修饰符一致

  • Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。

带有 internal 访问修饰符的任何成员可以被 定义在该成员所定义的应用程序内的任何类或方法访问。

简单概括为 那里用到它,就可以使用它的成员

  • Protected Internal 访问修饰符

Protected Internal 访问修饰符允许在本类,派生类或者包含该类的程序集中访问。这也被用于实现继承。


对象

对象(Object)类型 是 C# 通用类型系统(Common Type System - CTS)中所有数据类型的终极基类

其他对象都是从它派生出来的

  1. ObjectSystem.Object 类的别名。
  2. 对象(Object)类型可以被分配任何其他类型(值类型、引用类型、预定义类型或用户自定义类型)的值。

但是,在分配值之前,需要先进行类型转换。

  1. 当一个值类型转换为对象类型时,则被称为 装箱
  2. 另一方面,当一个对象类型转换为值类型时,则被称为 拆箱

参考 杂项 -》 装箱拆箱

C# object obj; obj = 100; // 这是装箱


Method

  1. static 方法
  2. 构造 Contractor 器(函数) 可 public 可 private 可 protected
  3. 析构函数
  4. overload 函数 只有返回值不同的函数并不能重载 以下类型也算重载:
  5. 类型 形参 例: public int Add<T>(int a ,int b)
  6. 引用 形参 例: public int Add(ref int a ,out int a)

参数传递

当调用带有参数的方法时,您需要向方法传递参数。在 C# 中,有三种向方法传递参数的方式:

方式 描述
值参数 复制参数的实际值给函数的形式参数,实参和形参使用的是两个不同内存中的值。形参的值改变不会影响实参的值,保证了实参数据的安全。
引用参数ref 这种方式复制参数的内存位置的引用给形式参数。这意味着,当形参的值发生改变时,同时也改变实参的值。(参考引用)
输出参数out 这种方式可以拿到多个返回值(并不是通过return)。(参考引用)

类的默认访问标识符是 internal,成员的默认访问标识符是 private。

  • 类定义

C# <access specifier> class class_name { // member variables <access specifier> <data type> variable1; ... <access specifier> <data type> variableN; // member methods <access specifier> <return type> method1(parameter_list) { // method body } ... <access specifier> <return type> methodN(parameter_list) { // method body } }

  • C# 中的构造函数 类的 构造函数 是类的一个特殊的成员函数,当创建类的新对象时执行。

    构造函数的名称与类的名称完全相同,它没有任何返回类型。

    默认的构造函数没有任何参数。

    但是如果需要一个带有参数的构造函数可以有参数,这种构造函数叫做参数化构造函数。这种技术可以在创建对象的同时给对象赋初始值

  • C# 中的析构函数 类的 析构函数 是类的一个特殊的成员函数,当类的对象超出范围时执行。

    析构函数的名称是在类的名称前加上一个波浪形 ~作为前缀,它不返回值,也不带任何参数。

    析构函数用于在结束程序(比如关闭文件、释放内存等)之前释放资源。 析构函数不能继承或重载。

  • C# 类的静态成员 使用 static 关键字把类成员定义为静态的。

    声明一个类成员为静态时,意味着无论有多少个类的对象被创建,只会有一个该静态成员的副本。

    关键字 static 意味着类中只有一个该成员的实例。

    1. 静态变量用于定义常量,因为它们的值可以通过直接调用类而不需要创建类的实例来获取。
    2. 静态变量可在成员函数或类的定义外部进行初始化。也可以在类的定义内部初始化静态变量。
    3. 一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。

      因为只有一个副本,所以内部使用的值的位置必须都为固定不变的) 如:Main() 函数

C# 接口(Interface)

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

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

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

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

接口不能指定修饰符,底层已经默认是 public

示例:

interface IMyInterface
{
    void MethodToImplement();
}

通常接口命名以 I 字母开头

继承接口后,需要实现接口的方法, 方法名必须与接口定义的方法名一致。

  • 如果一个接口继承其他接口,那么实现类或结构就需要实现所有接口的成员。

示例:

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
    }
}
  • 特点

  • 接口方法不能用public abstract等修饰。

  • 接口内不能有字段变量,构造函数。
  • 接口内可以定义属性(有get和set的方法)。如string color { get ; set ; }。
  • 实现接口时,必须和接口的格式一致。
  • 必须实现接口的所有方法。

C# 继承

继承是面向对象程序设计中最重要的概念之一。继承允许根据一个类来定义另一个类,这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

当创建一个类时,程序员不需要完全重新编写新的数据成员和成员函数,只需要设计一个新的类,继承了已有的类的成员即可。这个已有的类被称为的基类,这个新的类被称为派生类。
  • 基类和派生类 一个类可以派生自多个类或接口,这意味着它可以从多个基类或接口继承数据和函数。

    示例

    C# class <派生类> : <基类> { ... }

  • C# 多重继承 多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。 与单一继承相对,单一继承指一个类别只可以继承自一个父类。

    C# 不支持多重继承。但是,可以使用接口来实现多重继承。

    实现接口方法时,不需要使用关键字 override

    示例

    ```C# // 基类 PaintCost public interface PaintCost { int getCost(int area);

    } // 派生类 class Rectangle : Shape, PaintCost { public int getArea() { return (width * height); } public int getCost(int area) { return area * 70; } } ```

C# 多态性

多态性意味着有多重形式。在面向对象编程范式中,多态性往往表现为"一个接口,多个功能"。

多态性可以是静态的或动态的。

  1. 在静态多态性中,函数的响应是在编译时发生的。
  2. 在动态多态性中,函数的响应是在运行时发生的。

  3. 静态多态性 在编译时,函数和对象的连接机制被称为早期绑定,也被称为静态绑定。 C# 提供了两种技术来实现静态多态性。 分别为:

    1. 函数重载
    2. 运算符重载(参考 杂项记录 -》运算符重载)

函数重载 1. 可以在同一个范围内对相同的函数名有多个定义。 2. 函数的定义必须彼此不同,可以是参数列表中的参数类型不同,也可以是参数个数不同。 3. 不能重载只有返回类型不同的函数声明。

  • 动态多态性

动态多态性是通过 抽象类虚方法 实现的。

C# 允许使用关键字 abstract 创建抽象类,用于提供接口的部分类的实现。 1. 当一个派生类继承自该抽象类时,实现即完成。 2. 抽象类包含抽象方法,抽象方法可被派生类实现。 3. 派生类具有更专业的功能。 4. 实现方法时一定要使用关键字 override

抽象类的规则: 1. 不能创建一个抽象类的实例。 2. 不能在一个抽象类外部声明一个抽象方法。 3. 通过在类定义前面放置关键字 sealed,可以将类声明为密封类。 4. 当一个类被声明为 sealed 时,它不能被继承。 5. 抽象类不能被声明为 sealed

示例:

```C#
abstract class Shape
{
   abstract public int area();
}
class Rectangle:  Shape
{
   private int length;
   private int width;
   public Rectangle( int a=0, int b=0)
   {
      length = a;
      width = b;
   }
   public override int area ()
   {
      Console.WriteLine("Rectangle 类的面积:");
      return (width * length); 
   }
}
```

虚方法 当有一个定义在中的函数需要在继承类中实现时,可以使用虚方法。

虚方法是使用关键字 virtual 声明的。

  1. 虚方法可以在不同的继承类中有不同的实现
  2. 对虚方法的调用是在运行时发生的。

    ```C# class Shape { protected int width, height; public Shape( int a=0, int b=0) { width = a; height = b; } public virtual int area() { Console.WriteLine("父类的面积:"); return 0; } } class Rectangle: Shape { public Rectangle( int a=0, int b=0): base(a, b) {

    } public override int area () { Console.WriteLine("Rectangle 类的面积:"); return (width * height); } } ```


总结 :

  • abstract,interface ,seal

接口和抽象类类似,但本质和用途不一样 1. 抽象类一般作底层基类,单继承 2. 接口用来无关类多继承 3. 密封类作顶层类实现封密性 4. 抽象类可以提供某些方法的部分实现,接口不可以。 5. 抽象类的实例是它的子类给出的。接口的实例是实现接口的类给出的。 6. 在抽象类中加入一个方法,那么它的子类就同时有了这个方法。 7. 在接口中加入新的方法,那么实现它的类就要重新编写(这就是为什么说接口是一个类的规范了)。

  • virtual 虚函数用来在普通类的继承中重写(重构)某一函数

除了接口中的方法重写不需要关键字 override ,其余都需要