C#基础语法学习笔记（传智播客学习）

作者：小丑西瓜9 | 2024-03-20 09:54:31

踩

C#基础语法学习笔记（传智播客学习）

最近在学习C#开发知识，跟着传智播客的视频学习了一下，感觉还不错，整理一下学习笔记。

C#基础语法学习笔记

1.背景知识

/*
背景知识：
（背景：.net是微软的）
一、.net与C#
1. .net:又叫dotnet，指.Net Framework框架.是一种技术，一种平台
2. C#: C sharp(锋利的)， 是一种编程语言(控制计算机，和计算机进行交互的语言），可以基于.net 平台进行开发应用
 
关系: .net是一种平台，在.net平台上可以用C#语言进行.net相关程序的开发
3.Java: Java即是一种技术，又是一种语言
 
二、.net能干什么？
1.Winform: 在.net这个平台上开发的桌面应用程序叫做 Winform应用程序开发  （桌面应用程序：通过安装到桌面）
2.ASP.NET: 在.net这个平台上开发的web(浏览器)应用程序(网站) 叫做ASP.NET  （web应用程序：通过打开浏览器输入网址访问）
3.wp7 ：windows phone ，这.net这个平台上进行的手机嵌入式开发 （嵌入式开发应用程序：工业化控制设备）
 
两种服务模式：
1.C/S ：客户机（Client）/服务器（Server） :桌面应用程序 （单机的不需要服务器的不算，因为只有C，没有S，像QQ这种是C，还需要S）
2.B/S ：浏览器（Browser）/服务器（Server）:一般是web应用程序   
 
三、开发工具：Visual Studio
是微软的一个IDE（Integrated Development集成开发环境），也可以在记事本中写，但是太麻烦了 ，工欲善其事必先利其器。

MSDN：开发工具的帮助文档
 
*/
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

2.Visual Studio使用

/* Visual Studio使用
 * 
 * 一.创建项目
 * 文件-&gt;新建-&gt;项目-&gt;选择要创建项目的类型（目前一般是.net的控制台应用）
 * 
 * 项目名称
 * 项目位置
 * 解决方案：解决方案包含项目,解决方案中可以包含多个项目（意思是这些个项目是用于解决这个方案的）
 * 
 *二、界面排版
 *
 * 1.菜单栏
 * 所有功能都会在菜单栏
 * 2.工具栏
 * 常用的工具功能，便捷
 * 
 * 3.解决方案资源管理器
 * 
 * 解决方案中可以包含多个项目，项目可以包含多个文件，文件中是我们写的程序
 * 在文件中，可以有命名空间（定义命名空间前需要引用命名空间），命名空间中可以包含类，类中可以包含方法
 * （在C#中类文件是以.cs结尾的）
 * 
 * 程序的执行过程：
 * Main方法是我们程序的入口方法，当我们执行一个程序时，会首先找到Main方法，从Main的第一句开始执行，
 * 当Main方法执行完成后（即执行到Main方法的反大括号），程序就结束了
 * 一般情况下，一个项目只有一个Main方法，或者也可以没有
 * 
 * 4.重置开发环境
 * 可以使我们的开发工具恢复至默认状态
 * 菜单工具-&gt;导入导出设置-&gt;重置所有设置-&gt;不保存当前所有设置-&gt;C#开发设置-&gt;完成 
 * 
 * 一般的窗口不小心关闭了，在视图中找
 * 
 * 三、保存/打开项目
 *  .sln ：解决方案文件，记录着解决方案中都有哪些项目
 *  .csproj：项目文件，记录着项目中都有哪些文件
 * 项目在哪忘了，右击解决方案-&gt;在文件资源管理器中打开文件夹
 * 
 * 1.打开项目：
 * 先找到项目路径，不要打开.cs文件，直接双击打开.cs文件，只是打开了一个类，只能看不能运行，右边也没有解决方案
 * 建议用vs打开.sln解决方案文件（可以打开该解决方案下的所有项目），也可以打开.csproj文件（只能打开这一个项目）
 * 
 * 2.保存项目
 * Ctrl+s：只保存当前界面下的文件
 * Ctrl+shift+s：保存所有文件
 * 
 * 四、设置vs的字体大小及行号显示
 * 
 * 1.设置vs字体大小：工具-&gt;选项-&gt;环境-&gt;字体和颜色
 * 2.行号显示：工具-&gt;选项-&gt;文本编辑器-&gt;所有语言-&gt;行号
 * 
 * 五、在同一解决方案下创建多个项目
 * 直接从头打开vs创建项目话会再弄一个新的解决方案
 * 如果想在同一解决方案下创建多个项目，需要先打开解决方案，然后新建就会出现选项 或者打开解决方案后右击添加
 * 
 * 六、启动项目设置
 * 当有多个项目时，运行会运行右侧黑色加粗的项目
 * 想更改三种方法：
 * ①工具栏有个选择框
 * ②在右侧找到要启动的项目，右击设置为启动项目
 * ③在右侧右击解决方案选择属性-&gt;启动项目-&gt;单启动项目/当前选择是现在打开的项目
 * 
 * 七、项目的加载与卸载
 * 同一解决方案下，有时候打开着多个项目，如果其他项目有错，运行当前项目可能受影响。
 * 这时候可以右击其他项目选择卸载（不是删除），等需要时再重新加载即可。
 * 
 */

using System;   //引用命名空间
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _2.Visual_Studio知识    //定义一个叫 _2.Visual_Studio知识 的命名空间
{
    class Program        //定义了一个名称为Program的类
    {
        static void Main(string[] args)  //这是一个方法叫Main
        {

        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

3.基础知识

/*
 * 基础知识
 * 
 * 一、框架及执行过程
using System;   //引用命名空间

namespace XXX   //定义一个叫XXX的命名空间
{
    class XXXX        //定义了一个名称为XXXX的类
    {
        static void Main(string[] args)  //这是一个方法叫Main
        {
            //在这里编写程序
        }
    }
}
 * 程序的执行过程：
 * Main方法是我们程序的入口方法，当我们执行一个程序时，会首先找到Main方法，从Main的第一句开始执行，由上往下一句一句执行
 * 当Main方法执行完成后（即执行到Main方法的反大括号），程序就结束了
 * 一般情况下，一个项目只有一个Main方法，或者也可以没有
 * 
 * 二、输出
 * 
 * 运行代码：点击小绿按钮或者调试-&gt;开始调试
 * 小技巧：
 * （1）vs有的会有智能提示，回车或tab键会出来
 * （2）输入cw，再按两下tab键，可以快速打出Console.WriteLine(); 语句
 * 
 * 1.Console.WriteLine("大号"); //在屏幕中换行输出
 * 2.Console.Write("111");//在屏幕中不换行输出
 * 3.Console.ReadKey();//当程序执行到Console.ReadKey();时，程序会停到这里，等待用户从键盘上键入一个键，用户键入这个键之后，程序才继续执行
                              //如果没有这一句，会一闪立马就关了
 * 4.Console.Clear();//对控制台输出的清屏
 * 
 * 
 * 总结：
 * （1）C#区分大小写
 * （2）C#中每一个语句都必须以分号;结束
 * （3）这个生成的程序在项目文件夹-&gt;bin-&gt;Debug-&gt;.exe文件，其他文件都是和调试相关的
 * （4）程序要先 生成（编译）后运行，直接点那个启动是把这两步和在一起了。生成是先看看对不对，所以按F6经常生成一下，F5是先 生成后运行
 * 
 * 三、注释
 * 注释：对写的程序进行解释，是给人看的
 * 
 * 1.单行注释  // 
 * 2.多行注释 /*开始  *斜杠结束
 * 除了多行注释语句，还可以用工具中的注释选中的行（快捷键先ctrl+e，再按一下c）
 * 3.文档注释 ///
 * 用于对类和方法进行注释，在类或方法前面连续输入三个/，会自动生成一段注释
 * 
 * 四、计算机使用的基本技巧
 * 
 * 1.常用的定位快捷键:
 * （1）Home键：跳到这一行的最前面
 * （2）End键：跳到这一行的最后面
 * （3）Ctrl+Home键：跳到这一页的最前面
 * （4）Ctrl+End键：跳到这一页的最后面
 * （5）PageUp键：上翻页（如果代码过多，就不需要用鼠标了）
 * （6）PageDown键：下翻页
 * （7）shift键：帮助选中多个字符（和其他定位键组合使用，光标经过的地方都会被选中），不用再通过鼠标选中了
 * 2.一段文字的删除习惯：
 * 不要一个一个的删，再先选中再一起删 
 * （快速选中一行：Home+shift+End） 
 * Backspace：删除当前光标前面的
 * Delete：删除当前光标后面的
 * 
 * 3.全选/复制/粘贴/剪切
 * Ctrl+A/C/V/X
 * 注意：对话框的内容的复制？
 * 
 * 4.插入、覆盖模式的困惑
 * 有时候误点了Insert会出现一个小黑框，就是进入了覆盖模式，右下角会出现一个OVR就是覆盖模式的意思
 * 再点一个Insert就会突出覆盖模式，进入插入模式
 * 
 * 5.学会使用Ctrl+Z的撤销操作
 * 6. ,.;()的全角还是半角问题
 * 敲代码都是在英文状态下的半角模式
 * 
 * 7.遇到异常、报错不要慌
 * 按住F6出现编译错误，不要慌，先去看一下
 * 
 * 8.#regin #endregion
 * 这对指令可以折叠一段代码，前面会有一个+号就可以折叠（#regin后可以加注释）
 *           
#region 测试用
Console.WriteLine("你好世界！");
Console.ReadKey();
 #endregion
 * 
 * 
 * 五、了解.net
 * .net是一种多语言的开发平台，开发.net可以用多达几十种语言进行开发（多语言、单平台（但是可以跨微软的平台））
 * Java:是一种单语言的平台，但是可以跨平台（单语言、多平台）
 * 
 * MSIL:微软中间语言 Microsoft Intermediate Language
 * CLR：公共语言运行时 Common Language Runtime
 * CLS: 公共语言规范 Common Language Specification
 * CTS: 通用类型系统 Common Type System
 * JIT: 即时编译器 Just In Time
 */



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _3.基础知识
{
    /// <summary>
    /// 这个类中有一个Main方法，是我们程序的入口方法
    /// </summary>
    class Program
    {
        /// <summary>
        /// 程序运行时，从这里开始执行代码
        /// </summary>
        /// <param name="args">
        static void Main(string[] args)
        {
            Console.WriteLine("大号"); //在屏幕中换行输出
            Console.Write("111");//在屏幕中不换行输出
            Console.WriteLine("你是大傻der");
            Console.ReadKey();//当程序执行到Console.ReadKey();时，程序会停到这里，等待用户从键盘上键入一个键，用户键入这个键之后，程序才继续执行
                              //如果没有这一句，会一闪立马就关了


            #region 测试用
            Console.WriteLine("你好世界！");
            Console.ReadKey();
            #endregion




        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

4.变量

/*
 * 变量
 * 
 * 1、概念
 * 变量代表着一块内存空间，我们可以通过变量名称向内存 存/取数据.有变量就不需要我们记忆复杂的内存地址
 * 
 * 2、变量的定义(声明)
 * 数据类型 变量名
 * 
 * （1）数据类型
 * （数值类型） int 整型
 *              double 浮点型
 *              decimal 也是浮点型：一般用于存储金钱 decimal money =1000.25m (后面有个m只是表示是decimal类型) 
 * （非数值类型）char 单个字符类型：只能存储一个字符，并且存储的这个字符要求用单引号引起来
 *               string 字符串类型：就是把0个或1个或多个字符连接起来，要求用双引号引起来
 * 注意：
 * ①在C#开发环境中，直接写一个有小数点的数字，这个数字是double类型的
 * ②在一个小数后面加一个m或者M，就是告诉编译器这个数字是decimal类型
 * 
 * （2）变量的命名规则
 * 1°必须以 字母 _ 或 @ 符号开头（不能以数字开头）
 * 2°后面可以跟任意字母、数字、下划线
 * 3°注意：
 *  ①变量名不能与C#中的关键字重复
 *  ②在C#中，是区分大小写的
 *  ③在相同的作用域内，同一变量名不能重复定义
 * 4°变量名要有意义，见名知意  
 * 5°C#变量名编码规范——Camel命名法：首个单词的首字母小写，其余单词的首字母大写 例：studentName
 * 6°Pascal命名规范：每个单词的第一个字母都大写 例：StudentName
 * 7°如果使用到英文单词的缩写，全部用大写！
 * 
 * （3）声明变量的三种方式：
 * 变量一定要先定义，再赋值，后使用
 * ①先定义，再赋值 int a; a=3;
 * ②定义变量时直接赋值 int a=3;
 * ③一次声明多个同类型的变量，多个变量名称中间用逗号分隔，最后以分号结束
 * int a,b,c; a=1; b=2; c=3;
 * int a=1,b=2,c=3;
 * 
 * 
 * 
 * 3、变量的赋值输出
 * 变量名 = 值
 * 
 * （1）赋值符：
 * 赋值运算符和赋值表达式
 *  a =a +1;
 *  注意：
 *  ①这里的 = 等号时赋值运算符，赋值的意思，而不是数学意义上的相等
 *  ②变量可以重复赋值，一旦给一个变量赋了新值，那么变量中的老值就不复存在了
 *  
 * （2）连接符：
 * +号在C#中有两种意义：
 *  ①加法：两边参与运算的是数值类型，则表示是数学中的加法运算
 *  ②连接：可以连接两个字符串，这里的+表示连接的意思
+ 字符串变量 相当于 + 字符串变量.Tostring()
+连接的两个变量，如果一边是字符串，另一边会自动调动字符串.Tostring()方法
 * 
 * （3）占位符：
 * 占位符由{数字}组成，数字由0开始编号
 * 在Console.WriteLine("")中，第一个变量/字符串可以使用占位符
 * 注意：
 * ①索引(从0开始)必须大于或等于0，且小于参数列表 的大小
 * ②用逗号分开的叫参数，Console输出的永远是第一个参数的内容，后面的参数只是用于替换前面占位符的值
 * 
 * 4、例：借助第三变量交换变量
 * int t;//定义第三变量
   t = a;
   a = b;  
   b = t;
 * 
 * 5、字符串类型：
 * （1）Console.ReadLine();
 * 作用：用于接收用户的输入
 * 注意：
 * 用于让用户从键盘上输入一句话，让程序执行到下面这句话，就会暂停，按回车程序将继续执行
 * 输入的数据默认是字符串类型，所以要定义一个字符串变量来存储用户输入的值
 * （2）字符串转义
 * 1°什么时候用？
 * 当我们需要在字符串中输入一些特殊字符时，比如：半角引号、换行、退格，就需要使用转义字符
 * 2°概念：
 * 转义字符是一个字符，它是由一个\和一个字母来组成具有特殊意义的一个字符
 * 3°常用的转义字符：
 * \n ：换行
 * \b ：backspace 退格
 * \t ：tab键 制表符（由多个空格组成的一个字符，具有行与行之间的对齐功能）
 * \\ :表示一个\
 * @ :在字符串前面加一个@符号有两种意义：
 *   ①字符串中如果有\ ,则不再理解为转义符
 *   ②使字符串可以换行
 *   （如果字符串前面加了@符号，在字符串上用两个双引号代表一个双引号）
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 变量
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

5.运算符与表达式

 /*
  * 运算符与表达式
  * 
  * 一、算术运算符与算术表达式
  * 
  * 1、算术运算符
  * ① + 加
  * ② - 减
  * ③ * 乘
  * ④ / 除 ：整除
  * ⑤ % 取余、取模 ：取余数
  * 注意：
  * 它们是二元运算符，要求参与运算的两个操作数的类型必须相同，并且经过运算后的结果与操作数的类型相同
  * ++ :自增1 （有前加和后加）
  * -- :自减1 （有前减和后减）
  * 这两个是一元运算符 （如何区分一元还是二元？看有几个操作数， + 左右有两个操作数，所以是二元；++旁边只有一个操作数，所以是一元） 
  * 在C#中，一般情况下，一元运算符的优先级大于二元运算符
  * 
  * 例：
c = a++: 先将 a 赋值给 c，再对 a 进行自增运算
c = ++a: 先将 a 进行自增运算，再将 a 赋值给 c 
c = a--: 先将 a 赋值给 c，再对 a 进行自减运算
c = --a: 先将 a 进行自减运算，再将 a 赋值给 c 

  * 2、算术表达式：
  * 由算术运算符连接起来的式子
  * 3、优先级
  * 先算乘除，后算加减，有括号先算括号里的，相同级别的从左至右运算
  * （如果要改变计算的优先级，用小括号，小括号可以无限制套用，但是一定要成对出现）
  * 在C#中，一般情况下，一元运算符的优先级大于二元运算符
  * 
  * 
  * 4、类型转换
  * （1）自动类型转换（隐式转换）：
  * 1°发生隐式转换的条件：
  * ①两种类型兼容：参与运算的两个数据类型必须相兼容（例：int和double兼容，都是数值类型）
  * ②目标类型大于源类型：必须一边的数据类型表示范围小，一边的表示范围大，并且把小的转向大的不丢失精度（从int到double）
  * 
  * 2°注意：
  * 在自动转换中，转换不会都是丢失精度的，如果丢失精度，那么这个转换肯定不会自动完成
  * 常见到，参与运算的两个操作数一个是int，一个是double，那么int类型会自动转换成double类型
  * 所以：两个int类型的运算想得到double类型，*1.0就可以了
  * 
  * （2）强制类型装换（显式转换）：
  * 1°背景：
  * 当需要丢失精度的转换,系统是不会帮我们自动转换的，需要程序员来写代码完成转换，就是强制类型转换
  * (如double3.14到int3的转换，会丢失0.14的精度)
  * 2°语法：
  * (数据类型名) 待转换的值
  * 例：
  * int b = (int)3.14
  * 
  * 3°条件：
  * 强制类型转换，数据类型一定要相兼容（兼容的意思只都是数值类型，比如字符串和数值就不兼容）
  * 
  * （3）字符类型的转换——借助类方法
  *方式一： Convert：不再仅是内存级别的转换，而是考虑数据意义的转换。Convert是一个加工、改造的过程
  * ①Convert.ToInt32(待转字符串) ：将字符串变成整数
  * ②Convert.ToDouble(待转字符串)：将字符串变成浮点数
  * ③Convert.ToString()： 一切类型都可以转换成string类型
方式二：将字符串类型装换为对应的数值类型
Console.Parse(String);
int.Parse(String)
double.Parse(String)
例：
                  string s = "123";
                  //int a = Convert.ToInt32(s);
                  int a = int.Parse(s);
  * 二、复合运算符
  * += ：a+=3 等价于 a=a+3
  * -= 
  * *= 
  * /=
  * %=
  * 注意: >= 大于等于号中间不能有空格
  *
  * 三、关系运算符和关系表达式
  * 1、关系运算符
  * 在C#中，有6个关系运算符，用于比较两个事物之间的关系（所以为二元运算符）
  * >
  * <
  * == 等于
  * != 不等于
  * >=
  * <=
  * 
  * 2、关系表达式
  * 由关系运算符连接起来的式子
  * 3、bool类型（布尔）
  * （1）bool值有两个
  * 真：true
  * 假：false
  * （2）关系运算的结果是布尔类型的
  * 
  * 
  * 四、逻辑运算符和逻辑表达式
  *
  * 1、逻辑运算符
  * ① && 并且（逻辑与）：两边都是真才是真   
  * ② || 或者（逻辑或）：两边只要有一个真才是真
  * ③ ！ 取反（逻辑非）：真变假，假变真
  *（！是一元运算符，&& ||是二元运算符）
  *
  * 2、逻辑表达式
  * 有逻辑运算符连接起来的式子
  * 
  */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 运算符与表达式
{
      internal class Program
      {
            static void Main(string[] args)
            {
                  int a = 5, b = 6;
                  int c = a++ * --b;
                  //  b=b-1 (b是前减 )
                  //  c=a*b (相乘赋值给c )
                  //  a=a+1 (a是后加)
                  Console.WriteLine(c);
                  Console.ReadKey();

            }
      }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

6.程序调试

/*
 * 程序调试：
 * debug能力才是最重要的
 * 
 * 编译错误：一般是语法错误，编译器通不过会直接提示，以后通不过多读，需要经验积累
 * 运行错误（逻辑错误）：能编译通过，但是自己敲到代码不符合需求逻辑，需要找出错误地方就需要程序调试
 * 
 * 对于运行错误有以下两种调试方法：
 *
 *（1）利用编辑器自带调试功能:三步走
 * ①设置断点:在最前面的灰色处点一下就可以设置。断点：当程序运行到我们设置的断点处，程序就会停止
 * ②单步运行：点击启动调试，按F10一步一步执行观察变量
 * （F10是逐过程：遇到方法时不会进入方法体中执行
 *   F11是逐语句：遇到方法时能够进入方法体中执行
 *   跳出：可以跳出正在执行的方法
 *   F5继续：不会调试当前语句，直接跳到下一条语句
 * ）
 * ③观察变量：观察的是左下的变量列表，也可以选中一块右击快速监视
 *（2）输出大法：（推荐）
 * 利用输出语句，在认为错误的代码块中加输出语句，如果输出不符，说明这块代码不对，用于确定错误位置
 *
 *注意：
写代码时尽量不要重现一大段重复代码，这就是叫代码冗余
尽量不要让代码冗余
标志旗帜法 经常用来解决代码冗余
例：
            string username;
            string password;
            do
            {
                Console.WriteLine("请输入用户名:");
                username = Console.ReadLine();
                Console.WriteLine("请输入密码:");
                password = Console.ReadLine();
                if (username != "admin" || password != "888888")
                {
                    Console.WriteLine("用户名或密码错误，请重新输入！");
                }

            } while (username != "admin"||password!="888888");
            Console.WriteLine("登录成功");
            Console.ReadKey();

修改后：
            string username;
            string password;
            bool flag = false;
            do
            {
                flag = false;
                Console.WriteLine("请输入用户名:");
                username = Console.ReadLine();
                Console.WriteLine("请输入密码:");
                password = Console.ReadLine();
                if (username != "admin" || password != "888888")
                {
                    Console.WriteLine("用户名或密码错误，请重新输入！");
                    flag=true;
                }

            } while (flag);
            Console.WriteLine("登录成功");
            Console.ReadKey(); 

 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 程序调试
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            while(i<=10)
            {
                Console.WriteLine(i);
                i++;
            }
            Console.ReadKey();

        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

7.判断结构

/*
 * 判断结构（分支结构）：语句在满足条件下执行
 * 
 * 一、if单分支
 * 1、形式：
 * if(条件)
 * {
 *      语句1;
 *      语句2;
 *      语句3;
 * }
 * 
 * 2、执行过程：
 * 首先判断条件的结果，如果条件为true,则执行语句.如果条件为false，则跳过语句，执行后面的语句
 * 
 * 3、注意:
 * (1)if后面括号中的条件(是关系、逻辑表达式)，要能计算成一个bool类型的值
 * (2)和if语句有关系的语句只有后面大括号中的内容
 * 
 * 二、if-else双分支
 * 1、形式：
 * if(条件)
 * {
 *      语句; //1
 * }
 * else
 * {
 *      语句;//2
 * }
 * 
 * 2、执行过程：
 * 如果条件结果为true,执行if后语句1，否则条件为false，执行else后语句2
 * 根据判断条件结果，总要执行一个
 * 
 * 
 * 三、if-else-if多分支
 * 1、形式：
 * if(条件1)
 * {
 *      //1
 * }
 * else if(条件2)
 * {
 *      //2
 * }
 * else
 * {
 *      //3
 * }
 * 2、执行流程：
 * 第一个条件不成立才会进入下一个，一旦有一个条件成立，就会执行当前后的语句，执行完跳判断
 * 3、注意：
 * 判断语句也可以进行嵌套
 * if()
 * {
 *      if()
 *      {
 *      
 *      }
 *      else
 *      {
 *      
 *      }   
 * }
 * 
 * 四、switch-case语句
 * 
 * 1、形式：
 * 
 * switch(表达式)
 * {
 *      case 值1:
 *      语句1;
 *      break;
 *      
 *      case 值2:
 *      语句2;
 *      break;
 *      
 *      //...
 *      
 *      default:
 *      语句;
 *      break;
 * }
 * 
 * 2、执行过程：
 * 首先计算表达式，然后根据计算结果匹配case后面的值
 * 如果有匹配项，则执行匹配后面的语句，知道break语句跳出判断
 * 如果所有的case值都不匹配，那么有default则执行default后面的语句，直到break结束
 *                               如果没有default,则跳出switch-case什么都不执行
 *                               
 * 3、if-else-if与switch-case语句的比较
 * （1）相同点：
 * 都可以实现分支结构
 * （2）不同点：
 * switch-case:一般只能用于等值比较
 * if-else-if：可以处理范围
 * 
 * 
 * 4、例： 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 第三题
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入俩数和一个运算符："); 
            int a=Convert.ToInt32(Console.ReadLine());  //输入
            int b=Convert.ToInt32(Console.ReadLine());
            string c=Console.ReadLine();

            switch(c)          
            {
                case "+":  
                    Console.WriteLine(a + b);  
                    break;
                case "-":
                    Console.WriteLine(a - b);
                    break;
                case "*":
                    Console.WriteLine(a * b);
                    break;
                case "/":   
                    if (b == 0)
                    {
                        Console.WriteLine("0不能做除数");
                    }
                    else
                    {
                        Console.WriteLine(a/ b);
                    }
                    break;
                default:
                    Console.WriteLine("不能识别运算符");
                    break;
            }
            
            Console.ReadKey();
        }
    }
}
 * 
 * 
 * 五、三元表达式
 * 1、作用：可以代替if-else，有时使用更简便
 * 2、形式：
 * 表达式1 ? 表达式2: 表达式3
 * 例：
 * int a=100,b=20;
 * int max = a>b? a:b
 * Console.WriteLine(max);
 * 
 * 3、执行过程：
 * 首先计算表达式1，表达式1应该是一个能够计算成bool类型的值 （相当于if后的条件）
 * 如果表达式1的值为true，则表达式2的值作为整个表达式的值
 * 如果表达式1的值为false，则表达式3的值作为整个表达式的值
 * 4、注意：
 * 表达式2和表达式3的类型一定要相同或者相容（能够发生自动转换）
 * 
 */


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 判断
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

8.循环结构

/*
 * 循环结构：语句在满足条件下执行多次
 * 
 * 一、while循环
 * 1.特点：先判断，再执行
 * 2.形式：
while(循环条件)
{
    循环体;
}
 * 3.执行过程：
 * 先判断循环条件，如果条件为true，则执行循环体，循环体执行完，再去执行循环条件；
 * 如果条件为false，则跳出循环，循环结束
 * 
 * 二、do-while循环 
 * 1.特点：先执行，再判断
 * 2.形式：
do
{
    循环体；
}while(循环条件);
 * 
 * 3.执行过程：
 * 先执行循环体，
 * 执行完循环体再判断循环条件是否成立，如果条件为true，则执行循环体，如果条件为false，则跳出循环
 * 
 * 注意：
 * 假如循环条件一开始就不成立，对于while循环，一次都不会执行，对于do-while循环体会执行一次
 * 所以：do-while循环体至少会执行一次，while循环体可能一次都不会执行
 * 所以一般要求先输入一次的循环一般都考虑用do-while循环  
 *   
 * 扩展：  
 * （1）try-catch的使用：
 * 1.作用：检测异常，可以用try-catch来调试代码块
 * 2.格式：
try //检测
{
    //有可能出现异常的代码
}
catch
{
    //出错后的处理
}
 *
 *3.执行过程：
 *如果try中的代码没有出现异常，则不会执行catch中的代码
 *如果try中的代码出现异常，则程序立即跳到catch中
 *4.常用于输入出现异常时
 *例：
try
{
    int age = Convert.ToInt32(Console.ReadLine());  
    Console.WriteLine("你刚刚输入的年龄为："+age);
}
catch {
    Console.WriteLine("输入错误！");
}   
Console.ReadLine(); 
 *
 *
 *（2）通过循环限制只能输入某些值
例：
while(answer!="y"&&answer!="n")
{
    Console.WriteLine("只能输入y和n，请重新输入！");
    answer=Console.ReadLine();
}
 *
 * 三、for循环
 * 1.特点：一般用于已知循环次数的循环
 * 2.形式：
for(1循环初始化;2循环条件;3用于改变循环变量的值)
{
    4循环体;
}
 * 
 * 3.执行过程：
 * 首先执行1循环变量初始化，用于定义循环变量和对循环变量赋初值
 * 然后执行2循环条件，如果为true，执行4循环体，如果为false，跳出循环
 * 然后4循环体执行完，再去执行3用于改变循环变量的值
 * 然后再执行2循环条件，依次类推
 * 
 * 注意：1 2 3 4都可以省略,如果省略2循环条件，将是一个死循环
 * 
 * 4.循环的嵌套
 * 例：输出九九乘法表
            for (int i = 1; i <= 9; i++)//外层循环：循环9次
            {
                //写在这里的代码属于外层循环
                for (int j = 1; j <= i; j++) //内层循环：外层循环每执行1次，内层循环执行i次
                {
                    //写在这里的代码属于内层循环
                }
                //写在这里的代码属于外层循环
            }
 * 总结：
 * 三种循环可以相互转化，没有说用哪个循环对错，只能说用哪个循环更方便一些、逻辑更清晰一些
 * 已知循环次数的一般用for循环，
 * 循环条件比较复杂，跟循环次数无关的一般用while和do-while循环
 * 
 * 四、break和continue 跳转语句
 * 1.break：
 * (1)可以用于switch-case判断中，用于跳出switch
 * (2)用于循环中，立即跳出(终止)break所在的循环，一般和if配合使用
 * 2.continue：
 * 用于循环中，结束本次循环，继续下一次循环
 * 3.goto:
 * 不建议使用，来回跳，因为会破坏结构不便于阅读，要慎重使用
 * 

 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 循环
{
    class Program
    {
        static void Main(string[] args)
        {
            //格式1：
            //for(int i=1;i<=9;i++)  //i控制行
            //{
            //    for(int j=1;j<=i;j++)  //j控制列
            //    {
            //        Console.Write("{0}*{1}={2} ", j,i,i*j);
            //    }
            //    Console.WriteLine();
            //}
            //Console.ReadKey();

            //格式2：
            //for(int i = 1; i <= 9; i++)  //外层循环：i控制行数
            //{
            //    for (int j = i; j <= 9; j++)  //内层循环：j控制列数，表示第i行的第j个式子
            //    {
            //        Console.Write("{0}*{1}={2} ", i, j, i * j);
            //    }
            //    Console.WriteLine();
            //}
            //Console.ReadKey();



        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

9.常量、枚举类型

/*
 * 常量、枚举类型
 * 
 * 一、常量
 * 常量与变量对应，常量是指值不可以改变的(变)量
 * 1、定义：
 * const 数据类型 常量名 = 常量值;
 * 和变量定义形式很像，只是在前面加上了一个const修饰符
 * 
 * 例：
 *          const double PI = 3.14;  //定义常量赋初值
            PI = 3.1415;//错误
 * 
 * 注意：
 * 在定义时赋值，在其他时候不允许修改这个值
 * 
 * 2、常量的作用
 * ①可以重复使用
 * ②在写程序的时候，可以防止被恶意的修改掉
 * 
 * 二、枚举类型
 * 
 * 1、概念：
 * 枚举类型：可以自己重新定义一种类型，在定义这种类型的时候一起定义了这种类型所有的值
 * 
 * 2、定义：
enum 自己起的类型名称
{
    值1，
    值2，
    ...
    值n
 };
 * 注意：
 * 枚举的定义一般和类的定义在同一个级别，这样在同一个命名空间下的所有类就都可以使用这个枚举了。（方法中/类中也可以）
 * 
 * 3、作用
 * ①限制用户不能随意赋值，只能在定义枚举时列举的值中选择（枚举变量 = 枚举类型名.值）
 * ②不需要死记每一个值是什么，只需要选择相应的值（在vs中，使用枚举类型先点空格，会提示作用，方便程序员使用）
 * 
 * 4、注意：
 * ①枚举类型内的值不需要加双引号
 * ②定义枚举类型时,其中的值不能是int类型
 * ③枚举类型都可以强制转换成int类型
 * ④枚举类型的值在定义时是有一个默认编号的，依次从0开始
 *          sex = Gender.女;  
            Console.WriteLine(sex);
            Console.WriteLine((int)sex);
 * 注意：可以在枚举类型中的值中修改编号，修改一个值的编号，后面的会是前面的编号+1，但是尽量出现重复编号
 *  enum Gender
    {
        男=0,  //编号是0  
        女,    //编号是1
        a=1,   //编号是1，尽量不要出现这种情况
        b      //编号是2
    }
 *
 *  ⑤如何把一个字符串转换成字符类型？
 *  //枚举类型 枚举变量 = (自枚)(Enum.Parse(typeof(自枚),"待转换的字符串");
 *  注意：如果让用户输入枚举的值，最好使用try-catch防止输入的不是枚举列表中的值
 *  
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 常量_枚举
{
    /// <summary>
    /// 定义了一个类型叫Gender的枚举类型，他的值有两个：男和女
    /// </summary>
    enum Gender
    {
        男, //枚举类型内的值不需要加双引号
        女
    }
    internal class Program
    {
            static void Main(string[] args)
            {
                    Gender sex; //定义Gender类型的变量，变量名叫sex
                    Console.WriteLine("请输入你的性别：");
                    //sex = Gender.女;  //赋值,不能赋枚举之外的值
                    //Console.WriteLine(sex);
                    //Console.WriteLine((int)sex);

                    //枚举类型 枚举变量 = (自枚)(Enum.Parse(typeof(自枚),"待转换的字符串");

                    string s = Console.ReadLine();
                    try
                    {
                            sex = (Gender)(Enum.Parse(typeof(Gender), s));
                            switch(sex)
                            {
                                    case Gender.男:
                                            Console.WriteLine("男性");
                                            break;
                                       
                                    case Gender.女:
                                            Console.WriteLine("女性");
                                            break;
                                   
                            }
                           
                    }
                    catch
                    {
                            Console.WriteLine("你输入的性别有误上！");   
                    }
                    Console.ReadKey();
            }
           
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

10.结构体类型

/*
 * 结构体类型
 * 注意：C#中的结构比C语言中的结构体扩展了很多用法，只看C的结构体的话就局限了
 * C#中的结构体成员不仅可以是变量，还可以是方法
 * 
 * 1.作用
 * 可以解决：
 * ①比如为了存储一个人的信息，要声明一组变量，当我们要存储n个人的信息时，就要声明n组变量 的问题
 * （解决了变量名重复定义的问题）
 * ②存储一个信息的这几个变量间没有关系，容易记乱
 * （不会再把变量记混了）
 * 
 * 2.定义 
 * 
 * 访问修饰符 struct 自己起的结构体类型名称
 * {
 *      //定义结构成员：可以是变量，也可以是方法
 *      //注意：定义结构体成员前也要加访问修饰符
 * 
 * } //{}后没有分号;
 * 
 * 定义好一个结构后，就可以直接声明相应的变量了，
 * 声明好变量后，通过变量名.成员名 来访问结构的成员
 * 
 * 3、扩展——计算机的单位
 * 0~255 一共256个数 2的八次方=256 是一个字节
 * 
 * 二进制表示 0 和 1 
 * 计算中的最小单位叫 “位” ，bit ， 比特， 0101就是4个比特 b
 * 一个一个位处理太慢了，就把8个二进制位分成一组，那么8个二进制位叫做字节Byte B ，B是计算机能够处理的处理的最小单位
 * 1KB(千字节) =1024B
 * 1MB(兆字节) = 1024KB
 * 1GB(吉字节） = 1024MB
 * 1TB(太字节） = 1024GB
 * 
 * Bps 传输速度 bit per second
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 结构
{
    public enum Gender
    {
        男,
        女,
    }
    public struct Person
    {
            public string name;
        public Gender sex;
        public int age;
    }

    class Program
    {
            static void Main(string[] args)
            {
                    Person onePerson;
                    onePerson.name = "zhangsan";
                    onePerson.age = 20;
                    onePerson.sex = Gender.男;

                    Person secPerson;
                    secPerson.name = "lisi";
                    secPerson.age = 26;
                    secPerson.sex = Gender.女;

                    Console.WriteLine("随意输出一个{0}", secPerson.name);
                    Console.ReadKey();
            }  
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

11.数组

/*
 * 数组
 * 
 * 一、数组的作用
 * ①可以帮我们一次声明多个同类型的变量
 * ②这些变量在内存中是连续存储的
 * 
 * 二、数组的声明(定义)、赋值与取值、遍历、输出
 * 
 * 1、形式：
 * ① 数据类型[] 数组名 = new 数据类型[数组长度]
 * 例：int[] score = new int[5];  //声明了一个长度为5的数组，数组名叫score
 * 通俗点说：声明了一个数组，里面包含了5个int类型的变量，数组名叫score，里面5个int类型的变量叫做数组的元素
 * 并且对这5个元素从0依次开始编号到4  score[0]~score[4]
 * 注意：
 * int、double、decimal等类型的数值数组一旦声明，里面的每一个元素都被初始化成0，
 * 而char类型的字符数组、string类型的字符串数组编译器不会对其进行初始化，为Null空
            int[] score = new int[5];  //声明了一个长度为5的数组，数组名叫score
            score[0] = 10;
            score[4] = 20;
            Console.WriteLine(score[0]);
            Console.WriteLine(score[4]);
            Console.WriteLine(score[3]);
            Console.ReadKey();
 * 
 * ② 数据类型[] 数组名 = {下标为0的元素值,下标为1的元素值，......}; //中间元素用逗号,隔开
 * 例：int[] score = {1,3,8}; //score数组长度为3，其中score[0]=1,score[1]=3,score[2]=8
 * string[] names={"zhangsan","lisi","wangwu"};
 * 
 * ③ 数据类型[] 数组名 = new 数据类型[]{}   例：int[] score = new int[]{1,3,8};
 *    数据类型[] 数组名 = new 数据类型[数组长度]{下标0,下标1...} 例：int[] score = new int[3]{1,3,8};
 *    例： int[] score = new int[5]{1,2,3}//错误
 * 
 * 2、如何访问数组：
 * 通过下标(索引)来访问数组：数组名[下标]，下标从0开始
 * 例：score[0] = 10;
 * 注意：
 * 数组长度：通过 数组名.Length 可以获得数组的长度（即数组中有几个元素）
 * 
 * 3、数组的赋值与取值：
 *          for(int i=0;i<score.length;i++)
 *          {
 *              console.writeline("请输入第{0}个人的成绩",i);
 *              score[i]=Convert.ToInt32(Console.ReadLine());//对数组中的元素进行赋值
 *              sum+=score[i];// 遍历数组，求数组中所有元素的和
 *          }
 * 4、数组的遍历：
 * for(int i=0;i<score.length;i++)
 * 三、数组的应用
 * 1、前后交换
 * int=temp;
 * temp=a[i];
 * a[i]=a[a.Length-1-i];
 * a[a.length-1-i]=temp; 
 * 
 * 2、冒泡排序
 * (1)思路：
 * 让数组中的n个元素依次进行两两比较(第i个数与第i+1个数比较)，
 * 经过n-1趟的两两比较，第t趟的比较次数是n-t，每趟比较完都让当前最值排到当前最后
 * 核心点：
 * ①
 * 趟数：n个数需要排n-1趟，
 * 每趟次数：第t趟的比较次数是n-t次(趟数i是从0开始数，所以t=i+1
 * ②要从大到小排序，两两比较的时候使用<;从小到大排序用>
 * 
 * (2)模板:
 * for(int i=0;i<n.length-1;i++)// 控制比较趟数：共n-1趟(i+1表示当前是第几趟)
 * {    
 *      for(int j=0;j<n.Length-(i+1);j++)//控制每趟的两两比较次数：每趟比较 n-t次，t表示当前是第t趟，因为i是从0开始数，t=i+1
 *      {
 *          if(n[j]<n[j+1]) // 从大到小，用<，从小到大，用>
 *          {
 *              //交换变量
 *              int temp = n[j];
 *              n[j]=n[j+1];
 *              n[j+1]=temp;
 *          }      
 *      }
 * }
 * 
 * 四、二维数组
 *          int[,] a = new int[3, 4]   //二维数组初始化
            {
                { 100,90,80,70},
                { 90,90,80,60 },
                { 50,70,40,80},
            };
            for(int i=0; i <3; i++)  //求和遍历二维数组，并且输出平均值
            {
                int sum = 0;
                for(int j=0;j<4;j++)
                {
                    sum += a[i, j];
                }
                Console.WriteLine("{0}班的平均分是{1}",i+1,sum/4.0);  //除以4.0防止精度缺失
            }
            Console.ReadKey();
        }
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 数组
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //int[] score = new int[5];  //声明了一个长度为5的数组，数组名叫score

            //score[0] = 10;
            //score[4] = 20;
            //Console.WriteLine(score.Length);
            //Console.WriteLine(score[0]);
            //Console.WriteLine(score[4]);
            //Console.WriteLine(score[3]);
            //Console.ReadKey();

            int sum = 0;
            //定义数组
            int[] score = new int[10]; 
            //对数组中的元素进行赋值
            for(int i=0;i<score.Length;i++)   
            {
                Console.WriteLine("请输入第{0}个人的成绩",i+1);
                score[i] = Convert.ToInt32(Console.ReadLine());
                //sum+=score[i];  
            }
            //遍历数组，求数组中所有元素的和
            for (int i = 0; i <score.Length; i++)   
            {
                    sum += score[i];
               
            }
            //输出：输出数组中的每一个元素的值
            for (int i = 0; i <score.Length; i++)             
            {
                    Console.WriteLine("第{0}个人学生的成绩为{1}分", i + 1, score[i]);
               
            }
            Console.Clear();  //清屏
            //输出平均成绩
            Console.WriteLine("{0}个人的平均成绩为:{1}", score.Length, sum / score.Length);
            Console.ReadKey();

        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

12.方法

/*
 * 方法、参数、返回值
 * 
 * 一、方法（函数）
 * 在C#中函数、方法统一称为方法，有的人称静态为函数，非静态的为方法，在这我们统一称为方法
 * 方法就一堆代码进行重用的一种机制。方法就是一段代码，这段代码可能有输入的数据叫做参数，可能会有返回的执行结果叫做返回值
 * 
 * 1、作用：
 * 用来复用代码的，当我们在一个程序中反复的写了同样的代码，那一般情况下，我们可以把需要重复写的代码定义在一个方法中，用的时候只需要调用就行了
 * 比如Console.WriteLine();就是一个方法
 * 
 * 2、定义：
 * [访问修饰符] [static] 返回值类型 方法名([参数列表]) //[]内的表示可以省略
 * {
 *      方法体;
 *      [return 返回值];
 * }
 * 
 * 注意：
 * （1）方法一般要定义在类中，一般写在Main()方法后面
 * （2）如果方法没有返回值，则返回值类型写void
 * （3）方法的命名规则：方法名开头大写，参数名开头小写，参数名、变量名要有意义
 * （4）如果方法没有参数，()不能省略
 * 
 * 3、方法的调用：
 * （1）对于静态方法（有static修饰的都是静态方法）：
 * ①不在同一个类中，通过 类名.方法名();调用
 * ②如果是在本类中调用本类的方法，可以只写方法名(); 也可以通过类名.方法名();调用
 * 
 * 4、return可以立即退出本方法
 * 
 * 二、参数
 * 1、变量的作用域（声明周期）
 * 在方法中定义的变量成为局部变量，其作用域从定义开始，到其所在的大括号（语句块）结束为止
 * 注意：
 * ①字段：一个变量一旦定义在方法外，类的里面，就叫做类的字段，这个变量就可以被本类的所有方法所访问
 * 但是要注意，静态方法只能访问静态字段
 * ②由const修饰的常量不能定义为静态的
 * 
 * 2、在一个方法中想要访问另一个方法中的变量，怎么办？
 * 通过 参数和返回值
 * 
 * 3、形参和实参 
 * 在方法名后面的括号内定义变量，叫作这个方法的参数，这里定义的变量用于接收调用者传过来的数据
 * 注意：
 * ①如果一个方法一旦有参数，那么调用者就必须传参数，并且传参数的个数、类型与对应位置上的个数、类型必须一致
 * ②参数的作用域就是下面的方法体中
 * ③当形参是数组的时候，我们传数组名
 * 
 * 三、返回值
 * 当调用者想访问我们方法中的变量时，可以通过返回值返回
 * 只要在方法中使用了返回值，那么在调用方法中，前面就应该用一个变量来接收方法的返回值
 * 例：
 * string s = Console.Readline();
 * int x = Convert.ToInt32("32");
 * 
 * 注意：
 * ①一个方法可以多个参数，但是只能有一个返回值，也可以没有
 * ②一旦一个方法有返回值，那么在这个方法中，就必须通过return语句返回一个值，并且这个值要与返回值类型是相同的
 * 
 * 四、例：ReadInt()用法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ReadInt__用法
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入一个数：");
            int x = ReadInt();
            Console.WriteLine(x);
            Console.ReadKey();
        }

        public static int ReadInt()
        {
            int number = 0;
            do
            {
                try
                {
                    number = Convert.ToInt32(Console.ReadLine());
                    return number;
                }
                catch
                {
                    Console.WriteLine("输入有误，请重新输入！");
                }
            }
            while (true);
        }


    }
}
 * 
 * 
 * 五、方法的重载
 * 一般在同一个类中，方法名相同，但方法的参数的个数不同，或者对应位置上的参数类型不同，才能构成方法的重载
 * 注意：
 * 方法重载和返回值没有关系
 * 
 * 
 * 
 * 
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 方法
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //string s = "123";
            int a = Convert.ToInt32(s);
            //int a = int.Parse(s);
            
            //调用者
            Add1(10, 20);  //实参
            int b = Add2(10, 20);
            Console.WriteLine(b);
            Console.ReadKey();
        }

        //被调用者
        public static void Add1(int a, int b)  //形参
        {
                Console.WriteLine("a+b={0}", a + b);

        }
        public static int Add2(int a, int b)
        {
                return a + b;
           
        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

13.outref用法

/*
 * 
 * out的用法 
 * 作用：当一个方法想返回多个值的时候，可以通过out实现 
 * 例：下方代码
 * 实现步骤：
 * （1）在方法的参数类型前加out，那么传参数的时候也必须在number前加out
 * 表明这个参数不是传入的，而是用来传出值的
 * 
 * （2）如果参数是以out形式传入的，那么在传入前可以不赋初值
 * 
 * （3）在方法中对于由out修饰的参数，必须赋值，并且必须在使用前赋值
 * 
 * out和ref：
 * out用于传出值，方法中必须对out修饰的传数进行赋值
 * ref可以理解成双向的，既可以传入，又可以传出
 * 在传参数的过程中，如果参数有out或ref修饰的话，那么改变方法中的参数变量的值，调用者方法中的变量的值也会相应的改变
 * 
 */



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace outref用法
{
    internal class Program
    {
        static void Main(string[] args)
        {

            int number;
            int result = Test(out number);
            Console.WriteLine("number={0} result={1}", number, result);
            Console.ReadKey();
        }

        static int Test(out int a)    
        {
                a = 10;
                a = a + 1;
                return 200;
           
        }
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

14.常用方法

/*  
 *  常用类和方法;
 *  1、Math类  
 *  Math.Round(); //四舍五入函数  
 *  Math.Sqrt(); //开平方函数  
 *  例1：输入等边三角形的边长求面积,保留2位小数 
using System; namespace 求等边三角形面积 
{     
    class Program     
    {         
        static void Main(string[] args)      
        {             
            Console.WriteLine("请输入等边三角形的边长：");       
            string a=Console.ReadLine(); //输入边长为字符串类型         
            double x = Convert.ToDouble(a); //转化为浮点型           
            double ans = Math.Round(x * x * Math.Sqrt(3) / 4.0 , 2); //计算面积公式，并保留两位小数    
            Console.WriteLine(ans); //输出面积          
            Console.ReadKey();       
        }   
    } 
}  
* 
* 例2：编一个程序，输入一个正数，对该数进行四舍五入到个位数的运算。
* 例如，实数12.56经过四舍五入运算，得到结果13；而12.46经过四舍五入运算，得到结果12。 
using System; 
namespace 第六题
{     
    internal class Program   
    {         
        static void Main(string[] args)   
        {             
            double a=Convert.ToDouble(Console.ReadLine()); //输入       
            Console.WriteLine(Math.Round(a,0)); //四舍五入到个位输出       
            Console.ReadKey();     
        }    
    }
}  
* 2、Random类 随机数 
* 例：编写一个掷骰子100次的程序，并输出各个点数出现的次数 
using System; 
namespace 第6题 
{     
    internal class Program     
    {         
        static void Main(string[] args)       
        {
            int[] a = new int[7];          
            Random random = new Random(); //定义随机数对象       
            for(int i=0;i<100;i++)        
            {               
                int res=random.Next(1,7); //能随机生成[1,7)范围内的数，注意不会到7，即区间范围是[1,6]   
                a[res]++; //利用"桶"的思想         
            }           
            Console.WriteLine("掷骰子100次后：");        
            for(int i=1;i<=6;i++)       
            {              
                Console.WriteLine("{0}出现的次数为{1}", i, a[i]);          
            }             
            Console.ReadKey();  
        }    
    } 
 }  
*/ 

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/272491