C#学习 - 初识类型、变量、方法

构成C#语言的基本元素

关键字、操作符、标识符、文本都是标记（Token），编译器能够识别

关键字（Keyword）

C#有一般关键字（C# Keyword：任何时候都是关键字）和上下文关键字（Contextual Keywords：在某些语境中时是关键字）

操作符（Operator）

也成为运算符，某些关键字也是操作符

标识符（Identifier）

标识符就是名字，比如给变量取的名字
取名规范：不能完全与关键字相同；可以使用下划线；不能以数字开头；可以用@作为前缀使用关键字作为标识符
给变量命名时最好要有意义：对类命名时要是名词或者名词复数；对类的成员命名时，属性要是名词或者名词复数，方法要是动词或动词短语…
当一个标识符中有多个单词时，首个单词小写，后续单词首字母大写（驼峰法）；每个单词首字母大写（Pascal法）
变量名使用驼峰法；方法名、类名、名称空间等都是用Pascal法

标点符号

句末的“;”、还有"{}"…
在程序中不参与运算

文本（字面值）

int x = 1;//这里的1就是文本（字面值）
1

文本可以是整数、实数（浮点数）、字符、字符串、布尔（False & Ture）、空（NULL）

整数

整数有int（整型）、long（长整型）

int a = 3;
long b = 3L;//后面带L代表这个数是长整型
1
2

整型是用32个bit位来表示数字；长整型是用64个bit位来表示数字

实数

实数有float（单精度浮点型）、double（双精度浮点型）

float a = 1.2F;//F表示单精度浮点数
double b = 1.2D;//D表示双精度浮点数，D可以省略，带小数时，默认是double类型
1
2

单精度浮点型有32个bit位；双精度浮点型有64个bit位

字符

字符有char类型

char a = 'A';//需要用单引号，同时单引号内部只能有一个字符
1

字符串

有string类型

string a = "ABC";//需要用到双引号
string b = "";//双引号内可以是空
string c = "C";//双引号内也可以只有一个字符
1
2
3

布尔

有bool类型

bool a = true;
bool b = false;
1
2

“true”和“false”就是布尔值的文本

空（NULL）

string str = null;//代表变量str没有任何值
1

没用引用实例，还要去访问这个实例的方法时，运行程序会出现System.NullReferenceException错误，如：

Form form = null;
form.ShowDialog();
1
2

注释与空白

注释：

// - 行注释，这一行在此符号后面的全部注释掉
/**/ - 跨注释，两个*号之间的全部注释掉
注：行注释后紧接跨注释会导致跨注释失效；跨注释无法嵌套使用
1
2
3

空白：
写程序时使用空格、回车或者Tab使代码更清晰，某些情况下空白必须有
当空白留得不好时，VS2022可以用(Ctrl+K)+(Ctrl+D)进行格式化

初识类型（Type）

var x = 1;//int x = 1;
//var关键字声明的变量在赋值后，csharp编译器会自动判断出赋的是什么类型的值
Console.WriteLine(x.GetType().Name);
//打印出来是int32，就是32个bit位的整型
var y = 1.0;//double y = 1.0D;
Console.WriteLine(y.GetType().Name);
//此时打印的是double
1
2
3
4
5
6
7

上段代码说明C#有不同的数据类型，数据类型不仅可以声明变量，还能声明函数

初识变量

变量就是存放数据的地方

int x;//x就是变量，这就算声明完变量
x = 10;//将x赋值10，赋值要与x的类型相同
//比如整数型不能存放浮点型
1
2
3

初识方法

方法（函数）就是处理数据的逻辑

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Addtive m = new Addtive();
            //声明一个叫 m 的引用变量，创建一个Addtive的引用实例
            //可以用 m 来引用Addtive中的方法
            int n = m.Add(10, 20);
            //函数返回的是int，所以创建一个整型的数接收
            Console.WriteLine(n);
        }
    }
    class Addtive//创建一个类
    {
        public int Add(int a, int b)//括号内是函数的参数，需要声明
        //public指的是这个类外面也能访问这个方法
        //第一个int指的是函数Add加工完参数后返还的值的类型
        {
            int c = a + b;//加工参数的方法
            return c;//返还值
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

上段代码中的

public int Add(int a, int b)
{
	int c = a + b;
	return c;
}
1
2
3
4
5

这些就是函数声明

Addtive m = new Addtive();
int n = m.Add(10, 20);
1
2

上面两行就是函数调用
函数不一定需要返回值也不一定需要参数，如：

public string Time()//无参数
{
	int day = DateTime.Now.Day;
	return day.ToString();
}
public void Add(int a, int b)
{
	int c = a + b;
	Console.WriteLine(c);
}//无返回值
1
2
3
4
5
6
7
8
9
10

程序 = 数据 + 算法

算法简介

循环

打印1~100的整数

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Tool t = new Tool();
            t.Printf();
        }
    }
    class Tool
    {
        public void Printf()
        {
            for (int i = 1; i < 101; i++)
            //i++表示先进行循环，循环一次后i = i + 1
            {
                Console.WriteLine(i);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

递归

递归是指函数自己调用自己

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Tool t = new Tool();
            t.Printf(1);
        }
    }
    class Tool
    {
        public void Printf(int i)
        {
            if (i > 100)
            { }
            else
            {
                Console.WriteLine(i);
                Printf(i + 1);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

计算1到100整数相加的和

循环：

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Tool t = new Tool();
            t.Printf();
        }
    }
    class Tool
    {
        public void Printf()
        {
            int j = 0;
            for (int i = 1; i < 101; i++)
            {
                j = j + i;
            }
            Console.WriteLine(j);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

递归：

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Tool t = new Tool();
            t.Printf(1, 0);
        }
    }
    class Tool
    {
        public void Printf(int i, int j)
        {
            if (i > 100)
            {
                Console.WriteLine(j);
            }
            else
            {
                j = i + j;
                Printf(i + 1, j);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

高斯算式：

public void Printf(int x)
{
	Console.WriteLine((x + 1) * x / 2);
}
1
2
3
4