C#学习记录

---

前言

主要是近期学习C#的记录，主要是一些基础语法

---

提示：以下是本篇文章正文内容，还有一些案例

内容

一、计算机语言

1.计算机语言（编程语言）（程序设计语言）
人类交流（自然语言）
计算机语言的发展
机器语言——01010101二进制语言
汇编语言——add，mov等符号语言
高级语言——+，- 等

经过编译最终会编译成机器语言，机器最终才能读懂

各种语言的特点与应用
1.c：底层开发，贝尔实验室
面向过程，执行效率高，应用：单片机，嵌入式

2.c++：应用程序开发 贝尔实验室
面向对象，应用：ui，工业软件

3.java：it编程主流语言 美国sun公司
面向对象，应用：几乎涉及所有it领域

4.c#：微软
面向对象，应用：上位机

二、Helloworld

1 .命名空间Using三种用法

1.调用
案例：

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

调用命名空间(using)
先用一个要的类必须先调用引用命名空间

2.创建别名
案例：

//Using spacege = System.Collections.Generic;//通过赋值方式

作用方便简洁管理

3.using，数据库/文件流
定义一个范围 用于using结束后自动销毁 释放资源

补充；不一定只能用using来调用命名空间，可以在类前加命名空间实现调用
//System.console
命名空间可以嵌套

2 .控制台框架

A.Program类
解释：
启动类前面用class关键字引用，可以修改名称

B.Main
解释：程序入口（主线程），
规范：
1.每个项目必须有一个Main，也只能只有一个，不能同名出现Main
2.如果非要保留多个，要设置：项目属性–应用程序–启动对象在里面设置对应的入口函数（玩玩，真实项目不会这样做）
3.Main建议不要修改，区分大小写
4.属于静态的函数static
5.可以修改类的返回类型只能 void int
6.参数列表可以为空
案例：

//static void Main(string[] args)

C.标识符
解释：相当于一个个名称(命名空间/类名/对象/变量名/方法名/等）
规范：
1.首个字符必须是字母或者下划线，其余可以是字母数字符号
2.不能使用关键字
3.不能同名
4.区分大小写

D.语句
解释：是一行行的代码
规范：
必须；结尾

F.注释
解释：解释内容

基本框架
解决方案–多个项目–命名空间–类--Main函数/自定义函数/关键字/标识符/执行语句/注释

3 .Console类解读

解释：
Console类是控制台标准输入输出的类

快捷键键：
ctrl+j实现召唤快捷智能提示菜单
Console.WriteLine–cw+tab+tab

1.各种console类：
输出：

Console.WriteLine（）//按下回车光标出现在下一行
Console.Write（）//按下回车光标出现在后面
Console.WriteLine("helloword");//光标在下一行
Console.Write("helloword");//光标在后面

输入：

Console.ReadKey() 为了使控制台暂停，按下任意一个键程序继续运行
Console.ReadLine()读取用户输入内容，回车后光标停留下一行
Console.Read()

2.连接字符串：
+：

Console.WriteLine("李老师"+"早上好");//连接字符串
Console.WriteLine("李老师" +66666);

占位符：

Console.WriteLine("我叫{0}，我擅长{1}","梁锦豪", "plc");注意坑位必须小于对应的参数个数

$ ;

Console.WriteLine($"我叫{变量1}，我擅长{变量2}

3.设置控制台属性

Console.BackgroundColor = ConsoleColor.Black;//背景颜色
Console.ForegroundColor = ConsoleColor.White;//字体颜色
Console.Clear();//必须清楚缓存区

三、.NET概述

PART1 .Net是用于各类应用的框架和程序运行环境

解释:
微软搭建技术平台
在该平台可以运用多种语言c#，vb net开发软件
程序运行在。Net平台上

平台主要包含两部分:
.Net framework
Vs（集成开发工具）

举例：
.Net平台相当于车间 framework相当于车间里面各种组成设备

PART2 .Net framework框架包括 CLR公共语言运行时 , .Net类库

1.CLR公共语言运行时
是.Net可由多种编程语言的运行环境

2.CTS通用类型系统
案例：
CTS:int32 ,
C#:Int ,
VB.NET:integer
是定义统一的统一的数据类型系统，尽管不同的语言不一样，但是编译后，却是一样的（公共语言的数据类型）

3.CLS通用语言规范
消除不同语言之间语法的差别

补充
运行c#开发程序时，必须安装net framework
如果不需要编写代码不需要安装vs
Vs2019需要netframewrok4.7.2
PART3 两种交互式模式
解释：
可以理解成开发软件的类型模式

1.c/s 客户机/服务器模式
客户端需要安装专用的客户端软件
如qq，微信，包括后面的工业软件

2.B/S
浏览器/服务器模式
客户机需要安装浏览器
这种结构下完全通过www浏览器实现

四、编码及其调试技巧

PART1 集成开发环境就是一个一系列开发工具组合套装

1.解释组成
1.编辑器：在vs上编写代码
2.编译器：将高级语言编译成计算机语言
3.链接器：将中间文件及其第三方库的链接可执行的文件
4.调试器：调试软件bug
5.项目管理工具：对程序涉及到的所有资源进行管理，包括源文件，图片，第三方库等；ui各种界面
这些工具通常被打包在一起就是visul studio2019,visul c++6.0，pycharm 等通常统称集成开发环境（IDE，integrated Development Environment)

2.程序开发流程
编辑程序
编译程序
链接程序
调试程序
运行程序
打包程序

PART2 编辑程序

解释：
需要用到编辑器，用来编写代码
如：记事本，visul studio2019, vscode等

如何编码？
运用英文的标点符号
为了提高效率 vs可以简写tab快速输入
Ctrl+滚轮调整画面大小
鼠标某个变量/函数，点击右键可以转到定义，或者查找所有引用然后弹出调用窗口，或者按f1跳到帮助文档
折叠代码器#region
自动对齐代码ctrl+a(全部选择) ctrl+k–ctrl+d(自动对齐)

注释功能
解释：作用就是注销+解释
1.函数注释///
///
/// 解释：两数相加
/// 变量1
/// 变量2
/// 返回值：变量1+变量2
///
这个格式是自定义 ，因为自动生成那种不那么的完美

2.单行注释//
以开头//进行注释
声明局部变量后面进行解释或者有很长的一些不太直观大的逻辑进行备注解释
（快捷键：ctrl+k,crtl+c)

3.多行注释/…/
进行多行注释

4.文件型修饰（自定义注释）
一般放在头部
案例：
//***************************************
// …
//文件：
//作者：
//日期：
//引用（using）
//修改日志：
// 修改人员：
// 修改日期：
// 修改内容：
//…
//****************************************
注释提高代码的可读性，并不会被执行
工具栏快捷，或快捷键
可以注释无效代码

编码规范
一行只写一行变量
尽量局部变量靠近要使用的地方进行定义声明
使用空行将一段段的代码分割开，提高可读性（距离产生美），局部变量与方法间空行分隔
一行代码不要太长，控制合适长度，尽量屏幕视角可以全部看到
{}尽量单独一行，提升美观
代码的自动缩进（工具选项——文本编辑器——c#-制表符）
关键语句写注释
别在变量直接用固定的数值，尽量用常量代替

PART3 编译程序(Compile)

解释：
编译器(Compiler)他就是翻译官，把代码翻译成机器能读懂的语言

补充：
1.C#编译器就是csc.exe
路径C:\Windows\Microsoft.Net\Framework64\v4.0.1…
代码的对错，编译器说了算
把程序编译成机器语言exe文件，运行时不需要重新编译，直接使用编译结果就行，但是c#不适宜有点区别。
可以用记事本打开sln解决方案文件修改路径文件的命名

A.预处理指令（预编译指令）
解释：
在编译器进行编译之前对代码进行初步的转换
预处理过程先与编译器对源代码进行编译处理

规范：
所有的预处理指令都是以#开始，加上空格
预处理指令不是语句，所以他们不以分号结束

案例：
如 # region #

为什么需要预处理指令?
1.可以选择性的编译与屏蔽代码，节省内存，用于在项目开发前构思框架预先编写的时候使用或者测试时候,不会被编译进exe文件中， 如#if #else #endif
2.与一些系统信息的参数的调用与执行等等 #warnin，#pragma warning disable

C.警告warning与错误error
#warning 发出一条警报
#error 发出一条错误
#pragma warning disable屏蔽警告的代号
属性-生成-取消警告 效果与上面一样

D…NET两次编译
第一阶段：把 c# 编写成编译器上通过 CLS 转换在中间语言 IL 或者 MSIL 形成 exe
第二阶段：当 exe 要执行时会在 CLR 进行即时编译 JIT 成当前机器可以执行的语言

PART4 .托管代码与非托管代码

1.托管代码
需要托管CLR进行二次编译才能执行的代码
托管语言：C#，java
优点：跨语言集成，跨语言异常处理，增强的安全性（不会对系统造成损害）

2.非托管代码
直接编译成特定操作系统运行，如果跟换系统要重新编译
非托管语言：C，C++
优点：执行效率块

区别
1.托管代码时中间语言，运行在clr上
2.非托管被编译在机器上，运行在机器上

例如垃圾自动回收

PART5 链接程序（link）

解释：
又称链接器，将多个由编译器生成库文件，链接为一个可执行程序exe

PART6 调试程序（debug）重要

解释：
在程序运行中监制程序是否能达到预期要求与效果

1.编译与调试区别
编译时编译器在程序没有运行时帮你检查语法错误
调试时运行调试器在程序运行时，根据结果检查运行的结果是否错误

2.调试代码

快捷键：
F5开始调试
F9设置断点 打在要监视的变量语句下一条语句下面
F10逐过程 遇到函数调用不进入函数
F11逐单行 单行走
F12转到定义

调试技巧：
1.鼠标方上去
2.鼠标右键 添加监视
3.局部变量窗口（调试窗口里面）
4.断点窗口
5.引用（调用）窗口的运用
6.调试窗户

3.Debug与Release x86 x64

解释：
Debug：调试文件 较大，不做优化，包含调试信息，便于程序员调试程序，运行速度慢
Release：发布文件 相对小，优化过，没有调试信息，运行速度快

一般debug没有bug就可以发布release
Debug才可以打断点，包含调试信息

4.常见bug总结

PART7 运行程序

执行机制步骤:
进程需要执行机构，就是cpu，当程序编译后存在硬盘（外存），一般exe存在外存里 ，数据存在内存里
我们以计算机为例：
1.双击计算器图案
2.发送指令给操作系统，操作系统会在硬盘中找到你安装的计算机软件，操作系统将相关指令和数据加载到内存对应的地址，而在内存放着一条条的指令和数据中运行
3.等待cpu开始调度计算器程序，软件启动运行，开始执行Main函数
补充：linux不是exe文件

五、计算机硬件

PART1．计算机硬件

解释：
一套完整的计算机系统分为：计算机硬件，操作系统，应用程序

硬件：执行机构与显示机构，用于输入输出存储数据显示数据操作数据，需要与操作系统配合
操作系统：是管理计算机硬件与软件资源的计算机程序，用于接受外部指令，控制用剑和应用软件
应用软件：认为编写的人机操作实现功能的软件

硬件组成：
1.控制器：
计算机指挥系统

2.运算器：
实现算法逻辑运算，对信息进行处理运算的部件（Arithmetic and Logical,ALU)
控制器+运算器=cpu,处理器

3.存储器：
存储记忆两部分
内存：运行内存
外存：硬盘
存储器由若干个存储单元组成，每个存储单元都有一个地址，计算机通过地址崔存储单元数据读写
容量：b，kb，ma，gb，tb

4.输入设备：
输入信息（程序，文本，文本数据，图像）
键盘鼠标等
硬盘也是一种输入设备

5.输出设备：
由外部输出信息
显示器 打印机
硬盘也是一种输出设备

PART2.主板

解释：
主板是计算机最重要的组成部分
主板承载 cpu，内存，扩展卡， 网卡等（载体）

PART3.CPU (Central Processing Unit)

解释：
控制器+运算器=cpu,处理器
cpu主要职责管理与运算

如何挑选cpu？
1.看核心数量
2.是否支持超线程技术
3.是否可超频
4.默认主频
5.最大睿频等参数

PART4.内存条（）

解释：
内存分内存芯片，电路板，金手指组成
内存：CPU与硬件的桥梁，缓存CPU与硬件数据，承上启下
先将硬件等外部存储器或输入设备中的数据加载内存
CPU进行控制运算时，直接的读取内存相应地址数据

随机存储器（RAM）
1.既可以从中读取也可以写入
2.关机时，存储器会数据丢失

如何挑选内存？
1.看大小
2.看频率：1600mhz和1333mhz
3.看拥有几个内存条插槽
4.金士顿 三星 影驰

PART5.硬盘

硬盘分类：
1.机械硬盘HDD
优点：便宜，稳定
缺点：抗震能力弱，噪音大，读写速度慢

2.固态硬盘SSD
优点：读写速度更快，安静
缺点：贵

一线品牌:
机械硬盘：西数，希捷
固态硬盘：三星 日立 东芝 Toshiba

容量：
越大越好，在相同价位段，机械硬盘更大，更稳定，性价比高

接口分类：
机械硬盘：SATA3
固态硬盘：SATA3 ，PCI-E ，M.2

尺寸：

PART6.总线(bus）

解释：
说连接计算机系统的各功能部件（内存，CPU）互相连接的线路

计算机总线三类：
1.Address Bus 地址总线
2.Data Bus 数据总线
3.Control Bus 控制总线

PART7.电源

PART8.输入设备

解释：
采集的数据送到计算机去
字符输入，图像输入，语音输入等

设备：
键盘鼠标
硬盘也是输入
运动控制卡和io板卡也是输入设备

PART9.输出设备

解释：
把计算机处理的结果以人为或其他设备输出

设备：
打印机，显示器
硬盘也是输出设备
运动控制卡和io板卡也是输出设备

总结：
比作计算机为学员
CPU:大脑
内存：记忆力，临时存储
硬盘：笔记文件，永久存储
输出设备：鼻子眼睛
输出设备：嘴巴
总线：神经网络

六、操作系统（operating system,os)

PART1操作系统介绍

解释：
软件必须运行在操作之上，我们要控制计算机，就要有操作系统
硬件基础上，计算机安装一层软件，这层软件能通过响应用户输入的指令达到控制硬件的作用，成为操作系统

职能：
管理计算机硬件与软件资源的计算机程序
提供人机界面
接收高级语言转换机器语言
管理内存
控制系统资源优先调度
管理文件系统

系统种类：
Windows，Linux，macOS

PART2.DOS操作系统与cmd

解释：
磁盘操作系统DOS(Disk Operating System)
是面向磁盘的系统软件，是一层套在硬件外部的外壳

命令提示符cmd
解释：
提示用户进行输入的一种提示符
指令：
ipconfig查询本地ip
ping 测试通讯

常用软件
1.notepad记事本
2.calc计数器
3.osk屏幕键盘

编译C#代码文件（判断c#环境是否搭建）
1.复制文件夹路径C:\Windows\Microsoft.NET\Framework64\v4.0.30319
2.电脑属性-高级设置-环境变量-path变量-新建-粘贴路径
3.打开cmd 检查c#环境是否搭建成功输入csc.exe
4.编写一个简单程序是否可以编译成功
csc 11.cs
Exe

在vs中可以通过右键在终端打开实现cmd的控制

PART3.其他：

Linux操作系统
免费 开源 成本低 功能强大
Ubuntu/diebin

PART4.名词释义

1.IDE
集成开发环境

2.驱动
1.驱动程序是设备驱动程序根据操作系统编写的配置文件，是添加到操作系统
中的特殊程序

2.可以说没有驱动程序，计算机硬件无法工作
3.不同操作系统驱动会不一样（32/64位 windows/linux）

3.SDK
Software Development Kit 软件开发工具包
包括辅助软件开发的相关文档，类库/范例demo和工具的集合统称SDK
SDK被开发出来为了减少程序员工作量

4.API
Application Programming interface 应用程序接口
理解成是一个个函数接口

5.搬砖
辛苦，重复性高

6.算法
算法一系列的计算方法
实际上就是用自然语言对一个问题描述方式，而编写计算机程序就是通过编程语言实现算法功能
用来将输入数据转化成输出结果
算法的每一个步骤都是必须严格规定，能被计算机识别并执行

7.数据结构
数据类型是一种计算机组织/存储数据类型
常见数据类型：
整数/浮点
数据结构就是各个数据类型之间的组织关系
常见的数据结构：
栈数/链表/队列/图

8.语法与语句
语法：语言规则
语句：敲的代码

---

## 七、进制 ### PART1 初始进制 解释： 进位计数制 常见：十进制，八进制，二进制，十六进制

运算法则：
对于任何一种进制（q进制）q=2，8，10，16
加法运算：每一位都是逢q进1位
减法运算：借1当q使用

进制的种类
1.十进制0-9

2.二进制0-1

3.八进制0-7

4.十六进制 (hexadecimal)0-F不区分大小写
通常C#以 0X开头

PART2 字节byte（8位）简称B

解释
内存条：一个元器件 0v/5v 0/1 内存中一个元器件为1位——bit
8个元器件
01010101
2^8=256范围：0—255

（16位）
16个元器件就是2byte，32个位4个byte

单位换算：
1byte = 8bit
1kb = 1024byte
1mb = 1024kb
1gb =1024mb
1tb=1024gb
1pb=1024tb
1eb=1024pb

八、变量与运算符

PART1.什么是变量

解释：
变量最早来自数学
是计算机中存储数据或表示值的一种抽象概念，用于存放内存中存放程序与数据

总结：
内存地址不好记，为了方便高效，使用变量对应内存数据
内存条用来存储数据，不同变量不同存储地址
根据变量类型申请合适大小内存空间
变量是先声明再赋值最后使用

PART2.变量声明

解释：
对变量取名字

语法：
1.变量数据类型 变量名
2.一行同时声明多个变量用逗号隔开

变量赋值——初始化

先声明再赋值
int iNum;
iNum = 10;

声明是直接赋值
int iMoney = 20;

3.同时给多个变量赋值
nt idog = 2, icat = 3;

总结：
编码是习惯赋值初始值
全局变量不赋值编译也不报错，它是会系统自动赋值为0
编译时的运行与访问

常见问题
未赋值就使用
未声明就使用
变量重复同名，不能使用关键名
赋值跟数据类型不一致

变量访问

补充
变量三要素：类型，名称，值
变量可以确定对应内存中的大小/内存存储位置（编译时确定/运行时确定）
变量根据需要可以随时改变数值（常量不行）
变量可以通过变量名访问，变量名访问内存地址
变量需要分配内存，不需要时要释放内存，有借有还，c#有GC垃圾回收

PART3变量地址

如何看内存地址？
方法1
先打断点
开始运行
依次点击调试——窗口——内存——内存1
打上&+变量名称回车（每次编译或者重新打开软件内存地址会刷新）

方法2
1.先打断点
2.开始运行
3.查看即时窗口
4.打上&+变量名称回车

方法3
写代码实现
static unsafe void Main(string[] args)//不安全声明
{
int iNum;
Console.WriteLine(" iNum 对应的地址：0x{0:X}", (int)&iNum);
}
然后在项目属性中 生成 启动不安全代码

拓展：
32位寻址有4gb,当物理内存小于4gb，操作系统会应用虚拟内存技术
把硬盘的一部分跨分出来当作RAM

PART4内存的组成

解释：
内存由栈与堆组成

1.栈–stack 搭积木/蒸笼（内存）
意义：
程序编译时就确定对象的内存大小与分配释放

两个概念要区分：
1.内存 栈
2.数据结构 栈

栈的解释：
1.一片连续的内存 区域空间有限 ，一般为1MB
2.编译时候已经确定好分配的内存
3.先执行的内存地址会先生成地址，由高地址向低地址分配 先分配的为高地址，后分配为低地址
（有序分配）
4.栈顶元素使用完后，立马释放，释放顺序是先进后出，先释放后分配的地址，后释放先分配的地址
5.由操作系统自动分配与释放，不受GC垃圾回收管理
6.保存在栈中的变量称为值类型，称为直接存储

2.堆–heap 晾衣架/衣柜
意义：
程序运行时确定对象的内存大小与分配释放

在c#里面其实时托管堆，而说的堆栈就是栈
堆是程序运行期间动态分配内存大小，程序的运行情况决定分配的大小
存储区很大的自由存储，无限的，不连续的分配（无序分配）
可以用户自己来控制释放，如果不释放，内存达一定值，在C#受GC管理释放
在栈上存储的是对象的引用地址（对象在托管堆上的地址）
保存在堆中的变量是引用类型,称为间接存储

PART5垃圾回收器GC

解释：
GC是c#内存垃圾管理功能

什么是垃圾？
1.对象引用区域超过了，不再需要
2.或者对象赋值为null

工作机制：
在进行垃圾回收时，在引用这个对象时会标为有效，如果没有，会被垃圾回收，最后重新这里内存对象使得地址缝隙变小，更加节省资源，提升系统的工作效能

补充：
1.定期执行垃圾回收没有引用的对象内存
2.当可用剩余内存不能满足请求时，gc会自动回收
3.一个对象被定义回收不会立即回收，gc会在合适时机回收
4.可以手动调用gc

PART6作用域与生命周期

1.作用域scope–空间维度
解释：
作用域是指变量的使用范围
变量的作用域由声明它的位置决定

如果只有该方法在方法内部局部声明，就只能在方法调用
如果在方法外部类声明，则该变量就会被整个类使用
变量超出作用域时后编译报错

2.生命周期–时间维度
解释：
变量只存在内存中，从声明分配到回收的过程

类的成员变量
生命周期：类对象创建开始 对象被回收
作用域；整个类内部

局部变量
生命周期；方法调用，声明变量开始，方法调用完成
作用域：方法内部

九、变量命名

PART1变量命名规则

做到见名知意
规则：
基于方便原则
必须字母，数字，下跨线组成，不能由其他组成
必须以下跨线与字母开头，不能数字开头
不能取关键字命名
不能命名空间与类名重复
区分大小写
字符要紧挨着
在相同作用域不能重复命名（哪怕变量变量的数据类型不同，也不要这样
C#允许汉字，不要这样使用，会被鄙视

PART2常用命名方法

1.匈牙利命名法
变量名=作用域描述+数据类型+对象描述

1.a.作用域描述
g_全局变量goobal
m_/_c#类成员
什么都不带就是局部

1.b.数据类型
int i
小数float f
数组array arr
方法function fn

1.c.对象描述
最大年龄 MaxAgo
最小宽度 MinWeight
To 2

2.驼峰命名法 小骆驼法 camel
第一个单词以小写字母开头
后面每一个单词首字母用大写
例如：Int myHeight;

3.pascal 大驼峰法
所有单词首字母是大写
不用_

PART3命名拓展

1.解决方案命名

2.项目的命名

3.命名空间命名
建议使用pascal方法
可以使用.分隔

4.类命名
建议使用pascal

5.成员字段命名
建议使用匈牙利名法

6.属性的命名
建议使用pascal

7.方法命名（动宾结构）–动作
建议使用pascal命名，
方法需要获得参数 Get+成员
方法需要修改参数 Set+成员
方法返回bool 一般ls为前缀

8.方法的参数列表
建议使用匈牙利名

9.方法局部变量
建议使用匈牙利

10.接口命名interface
建议使用Pascal命名 首字母加I

十、数据类型

Part1什么是数据类型

解释：
主要用于指定变量与常量存储数据的类型

要点：
1.不同数据类型，用途不一样
2.不同数据类型的变量存储在不同内存中（值/引用/栈/托管堆）
3.不同数据类型变量占用内存空间不一样

数据类型的分类

存储的位置
值类型局部变量在栈上存储
引用类型变量的值在托管堆存储，而在栈上是存储变量的引用地址

补充
数据类型首字母大小写取别
大写是框架的数据类型CTS
小写是c#关键字，编译器会最终编译成CTS
c#语言强类型语言，要求每个变量开辟的空间与定义类型

1.整型
解释：
没有小数的纯数字的数字形式
整型默认为0
类型 注释 所占字节 CTS类型 范围
byte 8位有符号整数 1 System.Byte 0——255
sbyte 8位无符号整数 1 System.Sbyte -128——127
ushort 16位有符号整数 2 System.UInt16 0——2^16-1
short 16位无符号整数 2 System.Int16 -2^15——215-1
uint 32位有符号整数 4 System.UInt32 0——2^32-1
int 32位无符号整数 4 System.Int32 -2^31——231-1
ulong 64位有符号整数 8 System.UInt64 0——2^64-1
long 64位无符号整数 8 System.Int64 -2^63——263-1

查看整型信息的代码:
查看对应的CTS:typeof
Console.WriteLine($“sbyte 对应的CTS类型——{typeof(sbyte)}”);

Console.WriteLine($“short 对应的CTS类型——{typeof(short)}”);

Console.WriteLine($“int对应的CTS类型——{typeof(int)}”);

Console.WriteLine($“long 对应的CTS类型——{typeof(long)}”);

查看对应的占用字节大小:sizeof
Console.WriteLine($“sbyte所占的内存大小 (字节数)–{sizeof(sbyte)}”);

Console.WriteLine($“short所占的内存大小 (字节数)–{sizeof(short)}”);

Console.WriteLine($“int所占的内存大小 (字节数)–{sizeof(int)}”);

Console.WriteLine($“long所占的内存大小 (字节数)–{sizeof(long)}”);

查看对应的取值范围:MinValue，MaxValue
Console.WriteLine($“sbyte数值取值范围{sbyte.MinValue}到{sbyte.MaxValue}”);

Console.WriteLine($“short数值取值范围{short.MinValue}到{short.MaxValue}”);

Console.WriteLine($“int数值取值范围{int.MinValue}到{int.MaxValue}”);

Console.WriteLine($“long数值取值范围{long.MinValue}到{long.MaxValue}”);

查看对应的内存地址:0x{0:X}，&，unsafe
sbyte sbNum1 = 1;

        short sNum2 = 1;

        int iNum3 = 1;

        long lNum4 = 1;

        Console.WriteLine(" sbNum1的内存地址0x{0:X}", (int)&sbNum1);

        Console.WriteLine(" sNum2的内存地址0x{0:X}", (int)&sNum2);

        Console.WriteLine(" iNum3的内存地址0x{0:X}", (int)&iNum3);

        Console.WriteLine(" lNum4的内存地址0x{0:X}", (int)&lNum4);

查看整型书写形式:
分别有二进制，10进制，16进制

二进制：0b

iNumShape2 = 0b0000_100;

iNumShape2 = 0b0000100;

十进制：
iNumShape2 = 8;

十六进制：0X
iNumShape2 = 0X8;

超出限制:
赋值的大小必须遵循数据类型的取值范围，不然就会报错
byte byNumsizejudge = 256; //报错
以上超出数据类型的取值范围

两值整数调换:
方法1

        int iPosX1 = 10;

        int iPosY1 = 100;

        int iTPosvaule1 = 0;

        iTPosvaule1 = iPosX1;

        iPosX1 = iPosY1;

        iPosY1 = iTPosvaule1;

        Console.WriteLine($"iPosX的值{iPosX1}");

        Console.WriteLine($"iPosY的值{iPosY1}");





        方法2

        int iPosX2 = 10;

        int iPosY2 = 100;

        iPosX2 = iPosX2 - iPosY2;

        iPosY2 = iPosX2 + iPosY2;

        iPosX2 = iPosY2 - iPosX2;

        Console.WriteLine($"iPosX的值{iPosX2}");

        Console.WriteLine($"iPosY的值{iPosY2}");

要合理分配数据类型，重复利用内存的可运行率

2.浮点型
解释：
浮点数是带有小数的数据类型
使用计算机中基数与指数来表示(科学计数法)
浮点型默认为0，不是0.0
类型 注释 所占字节 CTS类型 小数范围
float 32位单精度浮点型 4 System.Single 最多保留7位小数
double 64位双精度浮点型 8 System.Double 最多保留16位小数
decimal 128位四精度浮点型 16 System.Decimal 最多保留28位小数

float单精度浮点数(4个字节)：F或者f
float fRatio = 2.78F;
赋值结尾必须加上F或者f(强制转换)
浮点型使用科学基数与指数来表示，所以float的表达范围比long还要大

double双精度浮点数(8个字节)：D或者d
double dbRatio1 = 12.66;//可以不加d(无需强制转换)

        double dbRatio2 = 12.66D;

赋值结尾可以不加D或d
不加默认就是double类型

decimal 四精度浮点型(16个字节)：M或者m
decimal deRatio = 13.666m;
赋值结尾必须加上M或者m(强制转换)
范围最大一般用于财务

3.bool类型(1个字节)
解释：
只有两种状态（true，false）的数据类型
通常用于做条件变量
占用一个字节(8位)，其他用0补齐
默认为false

4.char字符类型(2个字节)
解释：
计算机中使用的字母，数字，符号,123abc@#$都是字符
只能存放一个字符
占用两个字节(16位)
用单引号形式赋值’ ’
不能为空白赋值’’
空格属于字符’ ’

字符的表现形势：
char chA1 = ‘A’; //ASCII码（65）
char chA2 = ‘我’;//Unicode码
1.用单引号形式赋值
2.它有2种表现形式：1.字符，2.ASCII或Unicode码表示（重要）

判断字符串的判断指令：
判断数字：char.IsDigit
Console.WriteLine(“chA是否是数字?:{0}”, char.IsDigit(chA));

判断字母：char.IsLetter

        Console.WriteLine("chA是否是字母?:{0}", char.IsLetter(chA));

判断字母大写：char.IsLower

        Console.WriteLine("chA是否是小写?:{0}", char.IsLower(chA));

判断字母小写：char.IsUpper

        Console.WriteLine("chA是否是大写?:{0}", char.IsUpper(chA));

或者直接用if判断ASCII码大小来判断
if (chNum >= 65 && chNum <= 90)

Part2编解码与字符集（charset）

字符编码(character encoding)
解释：
使用该法则，对字符集合，与另一组信息载体进行配对，叫字符编码

字符解码(character decoding)
解释
将计算机二进制数据特定字符集解析，转换成容易理解的字符形式，叫字符解码

字符集
解释
即在符号集合与数字系统对应关系，这个对应的关系表叫字符集

常用的字符集：
1.ASCII字符集
2.Unicode字符集
3.GB2312字符集

ASCII字符集(美工信息互换标准代码)(1个字节)
解释
选出128个常用字符进行字符集排序
占用一个字节（8位就可以组出128个字符,最多256个）
调试char上显示的就是ascii值，char的数值型就是ascii

Unicode码（统一码，标准万国码)(2个字节)
解释：
对于比较特殊的语言如中文，它有几千个常用字符，这样一个字节的ASCII码肯定不够用所以Unicode码诞生
占用两个字节(16位)
C#的char里面两个字节16位 够用Unicode码

转义字符
解释
是一种特俗含义\来表示，通过后面加上其他符号转化成其他意思的字符

转义字符 说明
\n 回车换行
\t 横向跳到下一制表位置
" 双引号
\b 退格
\r 回车
\f 换页
\ 反斜线
’ 单引号
\uxxxx 4位十六进制所表示字符，如\u0052

字符串string(不可变字符串)
连续的多个字符
用双引号进行赋值
可以为空白与空格"“和” "

字符串与数组的关系
某种意义上字符串就是只读属性的数组
string strMySpeck = “我爱c#”;

Console.WriteLine(strMySpeck[1]);
这个数组只读，不能写入修改

两种给字符串赋值空值对托管堆的区别
strMySpeck2 = null; //没有在托管堆赋值

strMySpeck2 = “”;//有在托管堆赋值

strMySpeck2 = " ";//有在托管堆赋值

区别：
字符串赋值为null时候，不会引用托管堆
字符串赋值为"“和” "或者有内容的时候，会引用托管堆

1.字符串的单位格式化
百分比格式化{0:P}
Console.WriteLine(“百分比格式化{0:P}”, 0.56);//百分比percent

Console.WriteLine(“百分比格式化{0:P1}”, 0.56);//p后加数字决定小数位

取小数位{0:F1}

Console.WriteLine(“取小数位{0:F1}{1:F1}”, 0.56, 0.88);//单精度float，会4舍5入

货币单位{0:C}
Console.WriteLine(“货币单位{0:C}”, 1000);

2.字符串的日期时间格式化
显示当前的时间DateTime.Now
DateTime dtur = DateTime.Now;

短日期{0:d}

Console.WriteLine(“短日期------{0:d}”, dtur);

长日期{0:D}

Console.WriteLine(“长日期------{0:D}”, dtur);

长时间{0:D}

Console.WriteLine(“长时间------{0:T}”, dtur);

3.字符串的拼接
1.+
string strText = “npyhing is impossible”;
string strTemp = strText + “just do it”;
两个以上字符串通过+形式拼接

2.占位符
string strTemp =“just do it{0}”,strText;

3.$
string strTemp =$“just do it{strText}”;

4. string.Concat
   strTemp = string.Concat(strText, “just do it”);
   通过string.Concat方法返回实现拼接

4.获取字符串长度Length
int iLength = strTemp.Length;

5.修改字符串
5.1.增Insert
Insert(起始位,增加内容)
strTemp2 = strTemp1.Insert(0, “I LIKE”);

5.2.删Remove
Remove(起始位,删除长度)
strTemp2 = strTemp1.Remove(0, 6);

5.3.改
5.3.1去前后空格Trim
strTemp2 = strTemp1.Trim();

5.3.2转大写ToUpper
strTemp2 = strTemp1.ToUpper();

5.3.3转小写ToLower
strTemp2 = strTemp1.ToLower();

5.3.3代替Replace
strTemp2 = strTemp1.Replace(“w”,“o”);

5.4.查
5.4.1.查存在字符串IndexOf
int Temp5 = Temp2.IndexOf(“w”);

5.4.2.查末尾存在字符串LastIndexOf
int Temp5 = Temp2.LastIndexOf(“w”)

5.4.3.截取字符串Substring
strTemp2 = strTemp1.Substring(0,2);

6.取消转义字符串@
在转义字符串加上@实现取消转义，显示本来的形式
string strPath = @"/"

7.判断字符串是否为空值
7.1.if判断空值法
if (strProduct != “”)

7.2.string.Empty法
if (strProduct != string.Empty)

7.2.if判断长度法
if (strProduct.Length != 0)

8.字符串赋值过程中在栈与托管堆的区别
决定堆：赋值的对象影响堆的地址
决定托管堆：赋值的内容影响托管堆的地址
当字符串的赋值被重新赋值时候托管堆的地址就会改变

for (int i = 0; i < 18; i++)

        {

            string strName = string.Format($"wode{i}");

            Console.WriteLine(strName);

            fixed (char* p = strName) //托管堆p 指针

            {

                Console.WriteLine("0X{0:x}", (int)p); //内容变了托管堆会新开一个空间

            }

        }

9.Tostring用法
字符型转换 转为字符串
12345.ToString(“n”); //生成 12,345.00
12345.ToString(“C”); //生成 ￥12,345.00
12345.ToString(“e”); //生成 1.234500e+004
12345.ToString(“f4”); //生成 12345.0000
12345.ToString(“x”); //生成 3039 (16进制)
12345.ToString(“p”); //生成 1,234,500.00%

10.string.Format用法
1.对数值类型数值格式化
输入必须为数值类型
string str1 =string.Format("{0:N1}",56789);
string.Format("{0:P}", 0.24583) //结果为：24.58% （默认保留百分的两位小数）
string.Format("{0:P1}", 0.24583) //结果为：24.6% （自动四舍五入）

2.对时间日期类型数值格式化
string.Format("{0:d}",System.DateTime.Now) //结果为：2009-3-20 （月份位置不是03）
string.Format("{0:D}",System.DateTime.Now) //结果为：2009年3月20日
string.Format("{0:f}",System.DateTime.Now) //结果为：2009年3月20日 15:37
string.Format("{0:F}",System.DateTime.Now) //结果为：2009年3月20日 15:37:52
string.Format("{0:g}",System.DateTime.Now) //结果为：2009-3-20 15:38
string.Format("{0:G}",System.DateTime.Now) //结果为：2009-3-20 15:39:27
string.Format("{0:m}",System.DateTime.Now) //结果为：3月20日
string.Format("{0:t}",System.DateTime.Now) //结果为：15:41
string.Format("{0:T}",System.DateTime.Now) //结果为：15:41:50

可变字符串字符StringBuilder

解释
StringBuilding可变字符串，使用在类的对象之上，每次修改赋值不用新开空间
string字符串一般创建就不能修改，修改要新开空间

要先建立new对象
StringBuilder stringBuilder = new StringBuilder();

要使用其对象修改指令
添加Append
builder1.Append(“ab”);

清除Clear
builder2.Clear();

追加拼接字符串AppendFormat({0},变量名称)
builder3.AppendFormat(“老师名字：{0}，老师年龄：{1}”, name, age);

插入Inster
builder4.Insert(0, “中国”);

删除Remove
builder4.Remove(0, 2);

枚举函数enum

解释
定义组合类型函数，固定自定义有限选项方便调用

注意
枚举的定义可以在类内部与外部
枚举的属性其实是值类型（类似字符char里的ascii）
如果在不定义属性赋值的情况下,从0升序排列,如下面:大学生为0.高中生为1
可以对属性自定义赋值
枚举内部的属性之间用逗号分隔(,)

定义:
enum enuEducation

{

    大学生,

    高中生,

    初中生

}

调用：
Console.WriteLine(“我是一名{0}今天位{1}”, enuEducation.初中生, DayOfWeek.Saturday);

结构体函数struct
解释
定义不同类型的的复合体
可包含多种不同的数据类型

注意
要先建立new对象
要对结构体所有成员在建立完new对象后一一赋值
对象变量不赋值默认为0

定义
struct stCellPhone//结构体(自定义多种数据类型组成)

{

    public string strBrand;

    public int iPrice;

    public string strColor;

    public bool bHang;//行货



}

//这里的元素要public

调用：
stCellPhone myPhone = new stCellPhone();

        myPhone.strBrand = "华为";

        myPhone.iPrice = 5000;

        Console.WriteLine($"{myPhone.strBrand}");

其他：
string与int等其实都是结构体函数

数组Array
解释：
数组用于存储具有相同数据类型的集合

要素：
1数据类型，2名称，3值 元素，4下标

定义：
1.先声明再确定大小
int[] arrScoes1;

arrScoes1= new int[5];

2.同时声明与确定大小
int[] arrScoes1= new int[5];

赋值：
1.直接给指定元素赋值

arrScoes2[0] = 90;

2.通过new直接同步赋值
int[] arrScoes3 = new int[5] { 90, 50, 70, 50, 40 };

        int[] arrScoes4 = new int[] { 90, 50, 70, 50, 40 };

3.声明直接同步赋值
int[] arrScoes5 = { 60, 20, 50, 60 };

4.用已赋值的数组给新数组定义赋值
int[] arrScoes6 = arrScoes5;

遍历：
1.for
for (int i = 0; i < arrScoes6.Length; i++)

2.foreach
把数组对象里的元素值给item
foreach (var item in arrScoes6)

常用指令方法：
元素个数Lenght
arrScoes6.Length;

元素地址颠倒Array.Reverse
Array.Reverse(arrScoes6); //元素地址的颠倒
注意：这里不是元素内容排序颠倒是地址位置颠倒

元素内容排序Array.Short
Array.Sort(arrScoes6);

Copy 复制到另一个数组里
CopyTo 从指定目标索引开始，将当前的数组全部复制
Exists 判断是否包含指定元素
GetLength 获取指定维度元素个数
GetValue 获取指定位置的值
Reverse 反转元素位置
SetValue 设置指定位置元素
Short 对一维数组排序
下标上限：
0–arrScoes.Length-1

数组在未赋值与赋值时在栈与堆的区别
数组在声明分配栈，没有被定义大小不引用托管堆地址
数组在声明后分配栈，被定义大小才被引用托管堆地址

        iArr.GetLength(0);//获取维度元素个数

        iArr.GetValue(2);//获取位置的值

        iArr.SetValue(0,4);修改位置的值

二维数组
解释
由两个维度的元素组成的数组

声明：
int[,] iArrPos1 = new int[3, 5];

赋值：
1.逐一元素赋值
iArrPos1[0, 0] = 0;

1.整体元素赋值

        int[,] iArrPos2 = new int[3, 4] { { 2,2,2,2},

                                                          {2,2,2,2},

                                                          {2,2,2,2} };



        int[,] iArrPos3 = new int[,] { { 2,2,2,2},

                                                       { 2,2,2,2},

                                                       {2,2,2,2} };



        int[,] iArrPos4 =  { { 2,2,2,2},

                                      {2,2,2,2},

                                       {2,2,2,2} };

上面的3种方法与一维度数组一模一样

指令方法：
1.总元素个数Length
int iRow = iArrPos4.Length;

2.维度元素个数GetLength

        int iRow1 = iArrPos4.GetLength(0);//一维度个数


        int iCol1 = iArrPos4.GetLength(1);// 二维度个数

遍历方法：
1.for
for (int i = 0; i < iArrPos4.GetLength(0); i++)

 {

     for (int j = 0; j < iArrPos4.GetLength(1); j++)

         {

 iArrPos4[i, j] = iArrPos4[i, j]+ 100;

         }

}

其他
显示当前的时间DateTime.Now
Console.WriteLine($"\t时间:\t{DateTime.Now}");//当前时间
Console.WriteLine(DateTime.Now.Millisecond);//毫秒
DateTime strDate = new DateTime(2018, 5, 3);

1、DateTime数字型 System.DateTime currentTime=new System.DateTime();
1.1 取当前年月日时分秒 currentTime=System.DateTime.Now;
1.2 取当前年 int 年=currentTime.Year;
1.3 取当前月 int 月=currentTime.Month;
1.4 取当前日 int 日=currentTime.Day;
1.5 取当前时 int 时=currentTime.Hour;
1.6 取当前分 int 分=currentTime.Minute;
1.7 取当前秒 int 秒=currentTime.Second;
1.8 取当前毫秒 int 毫秒=currentTime.Millisecond;

交错数组
动态改变数组的每一行长度
适用于二维度数组
数据类型要统一
只能定义一维度的大小(行数)
要单独对每一行进行单独赋值开辟空间

定义：
int[][] iarrTenp = new int[3][];//定义一维度的大小
开辟空间：
iarrTenp[0] = new int[5] { 1, 2, 3, 4, 5 };//单独赋值开辟空间

        iarrTenp[1] = new int[] { 1, 2, 4, 5 };

        iarrTenp[2] = new int[] { 1, 2, 3, 4, 5 };



        交错数组元素的遍历

方法一
for (int i = 0; i < iarrTenp.Length; i++)//这里是Lenght(一维度的长度)

{

  for (int j = 0; j < iarrTenp[i].Length; j++)//每个一维度的遍历

  {

                Console.Write(iarrTenp[i][j] + "\t");

  }

            Console.WriteLine("\n");

}

方法二
foreach (var item in iarrTenp)

{

     for (int i = 0; i < item.Length; i++)

   {

                Console.WriteLine(item[i]);

   }

}

动态数组ArrayList
适用于一维度数组
数据类型不需要统一
数组的大小没有限制
不需要开辟空间
必须加上命名空间 using System.Collections;

定义：
ArrayList lstTemp = new ArrayList();;//引用托管堆

不需要开辟空间：
//

常用的指令
1.add
lstTemp.Add(11);//数据类型没有要统一

        lstTemp.Add("吃了");

        lstTemp.Add(11.2);

        lstTemp.Add(true);

        lstTemp.Add(new object());

2.Remove
lstTemp.RemoveAt(1);

        lstTemp.Remove(11.2);

3.Insert
lstTemp.Insert(1, “nainai”);

1.通过数组赋值
方法1
string[] strArrName = { “乔峰”, “我” };

        ArrayList ArrlstTemp = new ArrayList(strArrName);

方法2

        ArrlstTemp.AddRange(strArrName);

2.通过初始化器赋值
ArrayList ArrlstTemp3 = new ArrayList()

{

 1,2,3,true,'A'

};

3.通过索引单独赋值
ArrlstTemp3[0] = 10;

        ArrlstTemp3[2] = 50;

泛型集合List
适用于一维度数组
数据类型需要统一
不需要开辟空间
数组的大小没有限制
命名空间using System.Collections.Generic;

定义：
List lstn1 = new List();//引用托管堆

            List lstn2 = new List();

            List lstn3 = new List();

常用的指令：
1.add
lstn1.Add(123);

lstn2.Add(true);

1.通过数组赋值
int[] a1 = { 2, 4, 6, 7 };

            List lsda = new List(a1);

2.通过初始化器赋值
List lstn4 = new List

{

 'a',
 'b'

};

3.通过索引赋值
lstn4[0] = ‘A’;

常用指令
Add 追加元素
Clear 删除所有元素
Contains 查询元素内容是否存在
IndexOf 查询元素内容的位置
LastIndexOf 查询最后元素内容的位置
Insert 插入元素
InsertRange 插入集合
Remove 删除对应元素
RemoveAt 删除对应角标
List liInTemp = new List();

        List lilnTemp2 = new List();

        liInTemp.Add(12);

        liInTemp.Clear();

        liInTemp.Contains(12);//是否存在某元素

        liInTemp.IndexOf(0);//查询位置

        liInTemp.Insert(0, 15);//插入

        liInTemp.InsertRange(0, lilnTemp2);

        liInTemp.LastIndexOf(0);

       liInTemp.Remove(12);//删除匹配项

        liInTemp.RemoveAt(0);//删除下标

字典Dictionary
字典是通过索引号查询的特定数据类型
相当于取消数字角标用其他自定义的键代替
数据类型需要统一
键不能重复，值可以

定义：
Dictionary dicProduct = new Dictionary();//这里的string是键，int是元素内容

变量初始化
1.add
dicProduct.Add(“Pcb001”,1);

dicProduct.Add(“Pcb003”, 2);//键不能重复，值可以

dicProduct.Add(“Pcb004”, 3);

2.直接使用
dicProduct[“Pcb001”] = 2;

        dicProduct["Pcb005"] = 3;  //没有添加的键也可以智能添加

3.用初始化器
Dictionary keyValuePairs = new Dictionary()

        {

            ['a'] = 3, //这用到了[]

            ['b'] = 3

        };

遍历：

1.打印所有的键
foreach (var item in keyValuePairs.Keys)

2.打印所有的值
foreach (var item in keyValuePairs.Values)

3.打印所有的值与值
foreach (KeyValuePair item in keyValuePairs)

{

   Console.WriteLine("Key:"+item.Key+"\t"+item.Value);

}

常用指令
Add 追加元素
Clear 删除元素
ContainsKey 查询是否存在否键
ContainsValue 查询是否存在内容
Remove 删除指定键
Dictionary dicTemp = new Dictionary()

{

  ['A'] = 2,

  ['b'] = 16

};

dicTemp.Add(‘F’,77);

dicTemp.Clear();

dicTemp.ContainsKey(‘u’);//查询匹配的键

dicTemp.ContainsValue(77);//查询匹配的值

dicTemp.Remove(‘b’);//删除指定的键

哈希码Hashtable
字典是通过索引号查询的特定数据类型
相当于取消数字角标用其他自定义的键代替
数据类型不需要统一
键不能重复，值可以

定义
Hashtable hstProduct = new Hashtable();

        hstProduct.Add(12,"小明");

        hstProduct.Add("小pai",13);

十一、类型的转换

强与弱类型
强类型：在定义的时候就已经确定了数据类型
弱类型：在运行时候才去确定数据类型
var Num = 12.3; //=>Sytem.Double Num =12.3 编译器自动推断

//Num =“123”;编译器在声明时候就确定了类型

强类型 不灵活读写效率高
弱类型 灵活 不安全 效率低

类型转换
值类型的转换
2.值类型与string的转换
3.值类型与引用类型的转换 装箱 彩箱
4.引用类型的转换

隐式转换，显示转换

隐式转换：
自动转换小转大
赋值运算符 相互兼容
数值范围的大小从低到高

显示转换：
要人为添加要转换的类型
赋值运算符 相互兼容
造成精度丢失
还有数据丢失
（数据溢出）大水杯——》小水杯
double dbH = 200;

        int iH = (int)dbH;//小范围=（小范围）大范围

通过方法实现类型的转换
1.Parse方法(字符串->数值类型)
double db = double.Parse(b);

1.2捕获异常Int.TryParse
if (!double.TryParse(b,out db))

        {



        }

//这里等价于上面不过可以进行异常捕获

2.Tostring方法(字符串<-数值类型)
int a = 100;

        string b = a.ToString();

3.convert万能方法(万能)
double db1 = Convert.ToDouble(“13.44”);

有数据溢出的检查Try
try

{

   double db2 = Convert.ToDouble("13.44");

}

catch (Exception e)

{

  Console.WriteLine("数据溢出");

  throw;

}

十二、运算符

十三、结构体

顺序结构
实现步进判断执行
如：if else或者?:

方法1.if else
if (A==B)

{

}

else

{

}

方法2.?:
String A = (iSize == 0) ? “Y” : “N”

分支结构
实现多支路判断执行
如：swich或者if elseif else

方法1.swich
switch (a)

{

case 1:

break;

default:

break;

}
swich可以与枚举enum结合使用

特殊应用：
1.可以删除一个或多个case里的break，实现多个case都会执行相同语句，
必须保证最后一个case的break不能删掉
2.swich可以删除default与break；

方法2.if else if else
if (true)

{

}

else if (true)

{

}
else
{
}

循环结构
实现条件循环执行语句
如：for,foreach,while,do while

for循环
实现已知固定次数的循环结构
for(表达1;表达式2;表达式3)
for循环的特殊用法：
可以对条件进行删除或者魔改
情况一：
for(;//全部删掉,表达式2缺失形成死循环

情况二：
for(int i =0;逻辑运算符或关系运算符等;i++)//实现自定义条件判断
foreach循环
实现对数组等空间变量进行循环

while循环
实现未知固定次数的循环结构
先判断后执行
请务必通过循环内修改判断条件，以免产生死循环

do while循环
实现未知固定次数的循环结构
先执行后判断

中断指令
实现循环体的中断
比如：break;continue

区别：
break:结束整个循环，跳出循环
continue:结束这次循环，执行下一次循环

应用范围：
while
do while
swich(一般不会使用continue)
for
foreach
if:不能单独使用，只能嵌套在以上的里面使用，执行中断指令后中断最接近的一个结构体

特殊指令
比如：goto跳转与 :标签
类似于机器人的JAMP

十四、过程与对象

面向过程编程POP(Procedure Oriented Programming)
是以事件的发展顺序作为思想的一种编程手段
例如起床上课： 起床 刷牙 床衣服 下楼 吃早餐 到教室 上课
代表语言：C语言 VB

面向对象编程OOP(Object Oriented Programming)
世界上的所有物体都是对象
把事情分成一个个的对象，关心的是做事的对象以及对象本身的属性，以事情的的对象来特征来作为属性来被外调用赋值，实现多次相同行为不同事物对象的任务重复调用
代表语言：C# Java C++

对象特性分为静态特性与动态特性
例子：
静态特性——属性
你：年龄 性别 身高 爱好

动态特性——行为方法
你：打篮球 吹牛 板砖

思路
1.把处理的事情罗列出一个个对象，属性与行为
2.把数据和行为封装到类中
3.设计类——》创建类的对象——》通过调用类的成员

类的三大特性
1.封装 2.继承 3.多态

总结

主要是一些最简单的学习笔记，后续还会更新