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