c#基础 (语言)

一.c#基础 (语言)

1. 数据类型：

   1. 常见的类型有：

      1. 字符类型：string(字符串，可存汉字)，char(字符类型)
      2. 值类型：int(整数)，long(长整型)，short（短整数）等
      3. 布尔类型：true，false
      4. 浮点型：float（单精度浮点数）、double（双精度浮点数）等。

   2. 可分为值类型和引用类型

      1. 值类型：存储在栈上，例如：值类型、浮点型、浮点型
      2. 引用类型：存储在堆上，例如：字符类型、类(class)、接口(interface)、数组

   3. 值类型和引用类型的装箱、拆箱

      1. 值类型到引用类型为装箱
      2. 引用类型到值类型为拆箱

   4. 栈和堆

      1. 栈：存放在栈里的数据，是顺序存储的，他是一片连续的内存域，系统自动分配和维护，引用类型总是存放在堆中
      2. 堆：堆是无序的，是一片不连续的内存域，用户可以自己释放，如若用户不手动释放，当到达一定值时，过垃圾回收器(GC)来回收

   5. GC垃圾回收

      1. GC（垃圾回收）是指程序运行过程中自动管理内存的一种机制。在大多数现代编程语言中，都会提供自动的垃圾回收机制来帮助开发人员管理内存。GC 的主要目的是回收不再使用的内存，并使该内存可用于其他目的，从而提高内存的利用率和程序的性能。
      2. 分代式垃圾回收器将对象按照其存活时间分为不同的代数（一般包括0代、1代和2代），每个代数都有自己的内存区域。通常来说，0代对象的生命周期最短，而2代对象的生命周期最长。垃圾回收器在进行垃圾回收时，会优先回收0代对象，因为相比于1代和2代对象，0代对象的存活时间更短，更容易被回收。这种优先级回收的策略可以提高垃圾回收的效率和性能，减少不必要的回收操作对程序性能的影响。

   6. 显示转换 和 隐式转换

      1. 显示转换:是在我们进行两个类型转换的时候，需要明确需要转换的类型，例如 double 转 int 这里需要强制转换(显示转换)，但是在强制转换的时候可能会出现类型丢失或精度损失

         //<目标类型> 变量名 = (<目标类型>)<原始数据>;
         //转化为 int 类型，其他转换同理
         double a = 10.5;
         int b = (int)a;
         

      2. 隐式转换：在转换类型的时候自动转换，在转换的时候不会出现数据丢失，系统自动转换，如当我在 int 转换为 double 的时候不会出现数据丢失，会自动补齐为双精度

         int a = 10;
         double b = (double)a;
         

2. 面向对象(OOP) ：Object Oriented Programming简称OOP，是面向对象的语言

   1. 类(Class)：用户定义的数据类型，可以表示实体，也可以在内部定义方法，不是具体存在的，例如手机，手机中可以存在很多品牌的手机，类是对象的抽象

       //这是一个类(Class)
       public class Class1
       {
      
       }
      

   2. 对象(obj)：对象是类的实例，是真实存在的，通过实例化一个类，可以创建一个对象

      //例如 我们创建一个 A 的类，给他里面封装一个为 Name 的字段
      public class A
       {
           //这里可以声名字段，例如
           public string Name { get; set; }
       }
      
      //这里为类 B
       public class B
       {
           //在这里定义一个无返无参的方法
           public void GetName()
           {
               //我们去实例化一个 A 
               A a = new A();
               //通过实例化后的对象 a,给 Name 赋值，这里就完成了给对象赋值
               a.Name = "张三";
           }
       }
      

3. 面向对象的三大基础特征：封装、继承、多态

   1. 封装：封装属性、方法，对外隐藏内部的细节，只提供接口对外部访问

   2. 继承：子类继承父类，子类可以使用父类的所有功能，也可以在此基础上添加新的方法及属性，或者重写父类的方法

      1. 子类继承父类：子类是父类的派生类，父类是子类的基类

      2. 子类继承的父类的方法，可以不重复写父类的方法，提高了代码的服用性

      3. 覆盖方法：子类可以重写父类的方法，重写父类方法的逻辑

      4. 访权限：子类可以调用父类的公共和受保护成员，但是不可以调用父类的私用成员

         internal class Program
         {
             static void Main(string[] args)
             {
                 //实例化 GetA 类
                 GetA getA = new GetA();
                 getA.OneA("你通过GetA继承了GetB调用了OneA");
             }
         	//GetA基类
             public class GetA : GetB
             {
         
             }
         	//GetB派生类
             public class GetB
             {
                 public void OneA(string a)
                 {
                     Console.Write(a);
                 }
             }
         }
         

   3. 多态：指的是同一个方法在不同对象上表现出不同的行为。多态性使得可以使用统一的接口来操作不同的对象，从而提高了灵活性、可扩展性和可维护性。

      1. 对象多态：就指的是重写和覆盖,就是父类被子类重写或者覆盖后表现出来的多种形态

      2. 行为多态：就指的是重载

4. 重载和重写

   1. 重载：在一个类中方法名称相同，参数类型不同，返回值不同叫做重载，在传的参数类型不同的时候调用的方法不同，子类继承父类也可以完成重载

      //这是一个简单的重载 方法名相同 参数不同 执行的方法不同
      public class GetA
      {
          public void OneA(string a)
          {
              Console.Write(a);
          }
      
           public string OneA(string a,int b)
       	{
           	Console.Write(a + b);
          	 return a + b;
       	}
      }
      

   2. 重写：子类继承父类，方法名相同，参数相同，返回值相同，重写父类的逻辑

      internal class Program
      {
          static void Main(string[] args)
          {
              GetA getA = new GetA();
              getA.OneA();
              GetB getB = new GetB();
              getB.OneA();
          }
      
          public class GetA
          {
              public virtual void OneA()
              {
                  Console.Write("我是一个重写之前的方法");
              }
          }
      
      
          public class GetB : GetA
          {
              public override void OneA()
              {
                  Console.Write("我是一个重写之后的方法");
              }
          }
      }
      

5. 访问修饰符

   1. internal：内部
      1. 访问限于当前程序集，在该类的当前类库中使用
   2. privare：私有
      1. 只能在该类中访问
   3. public：公共
      1. 同一个程序的所有方法都可调用
   4. protected：受保护的
      1. 只能被该类的子类访问
   5. Protected Internal 访问修饰符
      1. 访问修饰符允许一个类将其成员变量和成员函数对同一应用程序内的子类以外的其他的类对象和函数进行隐藏

6. T (泛型)

   1. 在泛型类型或方法定义中，类型参数是在其实例化泛型类型的一个变量时，客户端指定的特定类型的占位符。 泛型T无法按原样使用，因为它不是真正的类型；它更像是类型的蓝图。 若要使用 T，客户端代码必须通过指定尖括号内的类型参数来声明并实例化构造类型。 此特定类的类型参数可以是编译器可识别的任何类型。 可创建任意数量的构造类型实例，其中每个使用不同的类型参数，减少拆箱和装箱的过程。

      //这个中的 T 代表的泛型，可存任何类型，如:int string Class 
      public class GetInfor<T>
      {
          List<T> values = new List<T>();
      
      } 
      

   2. 泛型约束，可以约束泛型的类型

      1. where T : class - T必须是一个引用类型。
      2. where T : struct - T必须是一个值类型。
      3. where T : new() - T必须有一个公共的无参数构造函数。
      4. where T : - T必须是指定基类或派生自指定基类。
      5. where T : - T必须实现指定接口。

      //where T : class - T必须是一个引用类型。
      public class GetInfor<T>  where T : class
      {
          List<T> values = new List<T>();
      }
      
      //where T : struct - T必须是一个值类型。
      public class GetInfor<T>  where T : struct
      {
          List<T> values = new List<T>();
      }
      
      //where T : new() - T必须有一个公共的无参数构造函数。
      public class GetInfor<T>  where T : new() 
      {
          List<T> values = new List<T>();
      }
      
      //where T : <base class> - T必须是指定基类或派生自指定基类。
      public class GetInfor<T>  where T : <base class>
      {
          List<T> values = new List<T>();
      }
      
      //where T : <interface> - T必须实现指定接口。
      public class GetInfor<T>  where T :<interface>
      {
          List<T> values = new List<T>();
      }
      

7. 委托(指向方法的指针)

   1. 委托（delegate）是一种引用类型，在其他语言中，与委托最接近的是函数指针，但委托不仅存储对方法入口点的引用，还存储对用于调用方法的对象实例的引用。
   2. 内置委托
      1. Action:无返回值，16个入参
      2. Func:16个入参，1个出参

​