C#编程基础-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44415461/article/details/123853864

C#类的定义（class）

 类的访问修饰符    修饰符    类名
{
    类的成员
}

类的访问修饰符：用于设定对类的访问限制
public：访问不受限制，可以类内和任何类外的代码中访问
protected：可访问域限定于类内或从该类派生的类内
internal：可访问域限定于类所在的程序集内
private：可访问域限定于它所属的类内
修饰符：修饰符是对类本身特点的描述
abstract：是抽象的意思，使用它修饰符的类不能被实例化
sealed：密封类，不能被继承
static：静态类，不能被实例化
类名：在同一个命名空间下类名必须是唯一的
类的成员：在类中能定义的元素，主要包括字段、属性、方法

C#方法的定义

 访问修饰符    修饰符    返回值类型    方法名(参数列表)
 {
     语句块;
 }

访问修饰符: 默认是 private
修饰符: virtual（虚拟的）、abstract（抽象的）、override（重写的）、static（静态的）、sealed（密封的）
返回值类型: 用于在调用方法后得到返回结果，返回值可以是任意的数据类型，如果指定了返回值类型，必须使用 return关键字返回一个与之类型匹配的值。如果没有指定返回值类型，必须使用 void 关键字表示没有返回值。
方法名: 对方法所实现功能的描述。
参数列表: 在方法中允许有 0到多个参数，如果没有指定参数也要保留参数列表的小括号。参数的定义形式是“数据类型参数名”，如果使用多个参数，多个参数之间需要用逗号隔开。

C# get和set访问器：获取和设置字段（属性）的值

public    数据类型    属性名
{
    get
    {
        获取属性的语句块;
        return 值;
    }
    set
    {
        设置属性得到语句块;
    }
}

简化写法:

 public    数据类型    属性名{get;set;}

C#调用类成员

创建类对象的语法:

类名对象名 = new 类名();

调用类中的成员:

对象名 . 类的成员

C#构造函数（构造方法）

访问修饰符  类名 (参数列表)
{
    语句块；
}

访问修饰符: 这里构造方法的访问修饰符通常是public类型的，这样在其他类中都可以创建该类的对象。

C#析构函数（方法）

~类名()
{
    语句块；
}

在析构方法中不带任何参数，它实际上是保证在程序中会调用垃圾回收方法 Finalize()。

C#方法重载（函数重载）

 class SumUtils
{
   public int Sum(int a,int b)
   {
       return a + b;
   }
   public double Sum(double a,double b)
   {
       return a + b;
   }
   public string Sum(string a,string b)
   {
       return a + b;
   }
   public int Sum(int a)
   {
       int sum = 0;
       for(int i = 1; i < a; i++)
       {
           sum += i;
       }
       return sum;
   }
}

参数列表不同主要体现在参数个数或参数的数据类型不同。在调用重载的方法时系统是根据所传递参数的不同判断调用的是哪个方法。

C#方法的参数（实参和形参）

方法中的参数分为实际参数和形式参数，实际参数被称为实参，是在调用方法时传递的参数；形式参数被称为形参，是在方法定义中所写的参数。

public int Add(int a,int b)
{
   return a+b;
}

在上面的方法定义中,a 和 b 是形式参数

public void Print()
{
    Add(3,4);
}

在调用 Add 方法时传递的参数 3 和 4 即为实际参数
方法中的参数除了定义数据类型外，还可以定义引用参数和输出参数。引用参数使用 ref 关键字定义，输出参数使用 out 关键字定义。

class RefClass
{
   public bool Judge(ref int num)
   {
       if (num % 5 == 0)
       {
           return true;
       }
       return false;
   }
}

//在 Main 方法中调用 Judge 方法，代码如下。
class Program
{
   static void Main(string[] args)
   {
       RefClass refClass = new RefClass();
       int a = 20;
       bool result = refClass.Judge(ref a);
       Console.WriteLine("验证结果是：" + result);
   }
}

从该实例中可以看出，在调用带有引用参数的方法时，实际参数必须是一个变量，并且在传值时必须加上 ref 关键字。
引用参数与我们平时使用的参数有些类似，但输出参数不同，输出参数相当于返回值,即在方法调用完成后可以将返回的结果存放到输出参数中。
输出参数多用于一个方法需要返回多个值的情况。需要注意的是，在使用输出参数时，必须在方法调用完成前为输出参数赋值。

class OutClass
{
   public void Judge(int num, out bool result)
   {
       if (num % 5 == 0)
       {
           result = true;
       }
       else
       {
           result = false;
       }
   }
}

//在 Main 中调用该方法，代码如下。
class Program
{
    static void Main(string[] args)
    {
        OutClass outClass = new OutClass();
        bool rs;
        outClass.Judge(20, out rs);
        Console.WriteLine(rs);
    }
}

从该实例中可以看出，在使用输出参数时，必须在方法操作结束前为带输出参数的形式参数赋值。
在调用含有带输出参数的方法时，必须在传递参数时使用 out 关键字，但不必给输出参数赋值。

C# lambda表达式
访问修饰符修饰符返回值类型方法名(参数列表) => 表达式;

这里需要注意的是，如果在方法定义中定义了返回值类型，在表达式中不必使用 return 关键字，只需要计算值即可。

 class LambdaClass
{
   	public static int Add(int a, int b) => a + b;
}

//在 Main 方法中调用，代码如下。
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(LambdaClass.Add(100, 200));
    }
}

C#递归

//使用递归实现计算所输入数的阶乘。
class FactorialClass
{
   public static int Factorial(int n)
   {
       if(n == 0)
       {
           return 1;
       }
       return n * Factorial(n - 1);
   }
}

//在 Main 方法中调用，代码如下。
class Program
{
    static void Main(string[] args)
    {
        int num = 5;
        int res =  FactorialClass.Factorial(num);
        Console.WriteLine(num + " 的阶乘等于：" + res);
        Console.Read();
    }
}

C#嵌套类

在类中除了能编写前面提到的类成员以外，还能直接定义类。将一个类定义在另一个类的内部，即可将在类内部定义的类称为嵌套类。
在 C# 中嵌套类相当于类中的成员，能使用类成员的访问修饰符和修饰符。但是，在访问嵌套类中的成员时必须加上外层类的名称。

class OuterClass
{
	  //嵌套类（内部类）
	  public class InnerClass
	  {
	      public string CardId { get; set; }
	      public string Password { get; set; }
	      public void PrintMsg()
	      {
	          Console.WriteLine("卡号为：" + CardId);
	          Console.WriteLine("密码为：" + Password);
	      }
	  }
}

//在 Main 方法中调用嵌套类的成员，代码如下。
 class Program
{
    static void Main(string[] args)
    {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.CardId = "S3547";
        innerClass.Password = "123456";
        innerClass.PrintMsg();
        Console.Read();
    }
}

C# partial部分类详解
访问修饰符修饰符 partial class 类名{……}

在这里，partial 即为定义部分类的关键字。部分类主要用于当一个类中的内容较多时将相似类中的内容拆分到不同的类中，并且部分类的名称必须相同。

public partial class Course
{
	   public int Id { get; set; }
	   public string Name { get; set; }
	   public double Points { get; set; }
}

public partial class Course
{
    public void PrintCoures()
    {
        Console.WriteLine("课程编号：" + Id);
        Console.WriteLine("课程名称：" + Name);
        Console.WriteLine("课程学分：" + Points);
    }
}

//在 Main 方法中为属性赋值并调用 PrintCourse 方法,代码如下。
class Program
{
    static void Main(string[] args)
    {
        Course course = new Course();
        course.Id = 1001;
        course.Name = "信息部";
        course.Points = 3;
        course.PrintCoures();
        Console.Read();
    }
}