C#课件知识点整理

第一章:C#简介

一、C#的发展历史

    C#是.net开发平台支持的多种语言中的一门编程语言。是Microsoft专门为.net
    平台开发的一种新的编程语言，语法类似于C语言。
    1998年，Delphi设计的第一个C#语言版本
    2002年，发布了第一个C#版本(1.0)

二、C#能干什么

1.Windows窗口应用程序。Microsoft office，Windows外观应用程序(按钮，工具)
2.web应用程序(邮箱、论坛、网站)
3.网络数据库等应用程序
4.web服务以及各种分布应用程序

三、C#程序结构

一个C#程序主要包括以下部分:
   1.命名空间声明
   2.一个class
   3.方法
   4.属性
   5.Main方法
   6.语句,表达式
   7.注释

using System;-->引入System命名空间(C语言：#include<stdio.h>)
using System.Collections.Generic;-->引入C#泛型命名空间
using System.Linq;-->主要作用是对集合进行查询
using System.Text;-->输出文本类型
using System.Threading.Tasks;-->异步操作

namespace cxsw-->创建命名空间
{
    class demo1-->创建一个名为demo1的类
    {
        static void Main(string[] args)-->main方法，程序的入口
        {
        }
    }
}

main方法的四种写法：
1)static void Main(){}string[] args
2)static void Main(){}
3)static int Main(String[] args){}
4)static int Main(){}

注意：
C#的主方法名第一个字母必须大写:Main(),且必须有static关键字

四.从控制台输出：

1.输出字符串常量
Console.WriteLine("字符串常量");
2.输出单个变量
Console.WriteLine(变量);
3.使用连接符(+)混合输出字符串和变量
Console.WriteLine("字符串"+变量);
4.使用格式占位符混合输出字符串和变量
Console.WriteLine("字符串{0},{1}",表达式1,表达式2);

五.从控制台输入：

1)输入字符串类型
定义一个字符串类型的变量，接受用户输入的字符串
String name;
给用户一个提示，提示用户进行输入
Console.WriteLine("请输入姓名：");
将用户输入的内容存入变量中
name=Console.Readline();
2)把字符串转化成数字
age=int.Parse(Console.Readline());

六.注释

注释方式：
单行注释：//
多行注释：/*……*/
文档注释：///  xml注释

using System;
namespace cxsw { //创建命名空间
    class Test101HelloWorld { //创建类
         static void Main(string[] args) { //主函数
            //输出
            Console.WriteLine("今天第一天"); //控制台输出
            int i = 1;
            Console.WriteLine(i); //输出变量
            Console.WriteLine("i的值为:"+i);
            Console.WriteLine("1+1={0},2*2={1}",1+1,2*2);
            //输入
            string name;
            Console.WriteLine("请输入你的名字:");
            name = Console.ReadLine();
            Console.WriteLine("用户输入的姓名为:"+name);
            //把字符串转换为数字
            Console.WriteLine("请输入要转换为字符串的数字:");
            int age = int.Parse(Console.ReadLine());
            Console.WriteLine("被转换为数字的字符串为:"+age);

            //Console.ReadKey();//针对VS.NET用户的
            //这使得程序会等待一个按键的动作,防止程序从VisualStudio.NET
            //启动时屏幕会快速运行并关闭的问题
            //也就是说加上他程序执行最后会等待你按键才退出
        }
    }
}

第二章:数据类型常量变量

一.数据类型

  （1）整数类型
         数学上的整数可以从负无穷到正无穷，但是计算机的存储单位是有限的，
		 所以计算机语言提供的整数类型的值总是一定范围之内的。
		 C#有八种数据类型：
		 短字节型（sbyte），字节型（byte），短整型（stort），无符号短整型（ustort），
		 整型（int），无符号整型（unit），长整型（long），无符号长整型（ulong）。

  （2）字符类型
         除了数字，计算机处理的信息还包括字符。字符主要包括数字字符，英文字符，
		 表达式字符等，C#提供的字符类按照国际上公认的标准，采用Unicode字符集。
		 字符型书数据占用两个字节的内存，可以用来存储Unicode字符集当中的一个字符（
		 注意，只是一个字符，不是一个字符串）。

  （3）实数类型
        C#有三种实数类型：float（单精度型），doudle（双精度型），decimal（十进制小数型）。

  （4）布尔类型
         布尔类型是用来表示“真”和“假”两个概念的，在C#里用true和false来表示。

1.常用数据类型		 
	整数：(4种)
		int(32位整数)、short(16)、long(64)、byte(8)
	浮点型：(3种)
		float(32位浮点数，精确到小数点后7位)
		double(64位浮点数，精确到小数点后15~20位)
		decimal(128位浮点数，精确到小数点后28~29位)
	布尔型：bool true、false
	字符型：char(单个字符，用单引号存储)
	字符串类型：string(双引号)

2.数据类型转换
	数据类型之间的大小关系：
	byte-->short-->int-->float-->double-->decimal
	1.隐式类型转化
		由低类型向高类型的转化
		注意：转化的两种数据类型之前必须兼容
	2.显式类型转化(强制类型转化)
		由高类型向低类型的转化
		1)利用Parse方法进行转化
			double d1=2.23;
			int i1=int.Parse(d1);
		2)使用convert提供的类进行强制转化
			语法：
				ToDouble(变量)

				double d = 23.5;
				int i;
				i = (int)d;

3.引用类型

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

namespace Csp个人课程备课.第二章数据类型变量
{
    class Test201数据类型
    {
		static void Main(string[] args)
		{
			//数据类型
			int age;//用来表示年龄
			double score;//用来表示分数
			char gender;//用来表示性别
			bool b;//用来表示真假
		}
	}
}

二.常量

语法：
const 数据类型 变量名 = 常量值；
在声明和初始化变量的时候，在变量前加上关键字const，就可以把一个变量指定为常量。
在使用过程当中，常量值不会发生变化，后期不允许修改常量值，常量的命名规范和变量是一样的。

using System;
namespace Csp个人课程备课.第二章数据类型变量
{
    class Test202 {
        const double pi = 3.14; //定义常量
        static void Main(string[] args) {
            Console.WriteLine(pi);
        }
    }
}

三.变量

1.变量的声明
	变量类型 变量名;
	int num;
	变量类型 变量名 = 变量值；
	房间类型 房间号 = 入住客人；
2.变量的命名
	1)驼峰命名法：最中间单词的首字母是大写的
	demodirect-->demoDirect
	2)帕斯卡命名法：每个单词的首字母都大写
	demodirect-->DemoDirect
3.变量的命名规则
	1)由字母、数字、下划线组成，不能以数字开头
	2)不能用保留字作为变量名(console)
	3)建议用英文单词
	4)变量名区分大小写
4.注意事项：
	1)未经声明的变量不能使用
	2)未经赋值的变量不能输出
	3)可以一次性声明多个变量
	4)可以先声明再赋值，也可以声明的同时初始化

using System;
namespace Csp个人课程备课.第二章数据类型变量
{
    class Test203 {
        static void Main(string[] args) {
			//定义在函数体当中的变量为局部变量 只能在当前函数体内使用
			//定义变量
			int a;
			a = 10;
			Console.WriteLine("变量a的值为:"+ a);
			int b = 20;
			Console.WriteLine("变量b的值为:"+b);
			b = 40;
			Console.WriteLine("变量b修改后的值为:"+ b);
			int c, d;
			c = 3;
			d = 4;
			Console.WriteLine("变量c的值为:"+c+",变量d的值为:"+d);
			int e = 1, f = 2;
			Console.WriteLine("变量e的值为:"+e+",变量f的值为:"+f);
		}
    }
}

using System;
namespace Csp个人课程备课.第二章数据类型变量
{
    class Test204 {
		static int i; //定义在函数体外的变量为全局变量 可以在当前文件中使用
		static void Main(string[] args)
        {
			//定义在函数体当中的变量为局部变量 只能在当前函数体内使用
			//定义变量
			int a = 10;
			Console.WriteLine("变量a输出:"+a);

			i = 30;
			Console.WriteLine("常量输出:"+i);
		}
		void eat(){
			//a = 11; //提示未定义访问不到
			i = 31; //不提示错误证明可以访问到
		}
	
    }
}

四.注意事项

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

namespace Csp个人课程备课.第二章数据类型变量
{
    class Test205{
		static void Main(string[] args)
		{
			short s = 1;
			int i = 2;
			long l = 3;
			char ch = 'a';
			Console.WriteLine(s + " " + i + " " + l + " " + ch);
			//i = 2200000000;//选用数据类型时 注意是否超出范围
			//如果超出范围则错误

			float ff = 3.14f; //浮点数类型后面加f
			double dd = 3.14;
			Console.WriteLine(ff + " " + dd);

			//char类型
			char cs = 'a';//char类型的值要用单引号引起来
			char cc = ' ';//char类型的值不能啥也没有哪怕是一个空格也可以
			char ccc = '\n';//表示转义字符
			char c1 = (char)97;//ASCII码
			Console.WriteLine(cs+" "+cc+" "+ccc+" "+c1);

			//数据类型转换
			short st1 = 2;
			int it1 = st1;//隐式转换
			Console.WriteLine("it1的值为:"+it1);
			double db1 = 25.5;
			int it2 = (int)db1;//强制转换
			Console.WriteLine("it2的值为:"+it2);
		}
	}
}

五.ASCII码表

六.转义字符

第三章:运算符

一.算数运算符

 + - * / % ++ --
+号的用法：
	1)对两个数字进行相加
	2)字符串的连接
++、--复合运算：
	1)++在前：先运算，后赋值
	2)++在后：先赋值，后运算

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

namespace Csp个人课程备课.第三章运算符和表达式{
    class Test301算数运算符{
        static void Main(string[] args) {
			int A = 10, B = 5;
			//算数运算符的各种运算
			Console.WriteLine("A=10,B=5");
			Console.WriteLine("A+B="+(A + B));
			Console.WriteLine("A-B="+(A - B));
			Console.WriteLine("A*B="+(A * B));
			Console.WriteLine("A/B="+(A / B));
			//取模,表达式中书写了A%%B,其中两个%表示输出一个%
			Console.WriteLine("A%B="+(A % B));

			int a = 1, b = 2, c = 3, d = 0;
			Console.WriteLine("a,b,c的值为:"+a+" "+b+" "+c);
			Console.WriteLine("a++的值为:"+(a++));
			Console.WriteLine("a的值为:"+a);
			Console.WriteLine("++a的值为:"+(++a));
			Console.WriteLine("a的值为:"+a);
			a = 1; b = 2; c = 3; d = 0;
			//a = 3; b = 3; c = 3;
			//   1    2    3    3    3
			d = a++ + a + ++b + b + ++a;  //在下一次计算时才会得到所有加一后的值
			Console.WriteLine("d的值为:"+d);//12
		}
	}
}

二.关系运算符

(比较是否相等) != > < >= <=

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/**
 * 关系运算符
 * ==	!=	>	<	>=	<=
 **/
namespace Csp个人课程备课.第三章运算符和表达式
{
    class Test302关系运算符
    {
        static void Main(string[] args) {
			int a = 20; int b = 20; int c = 30;
			Console.WriteLine(a == b);//true
			Console.WriteLine(a != b);//false
			Console.WriteLine(a > b);//false
			Console.WriteLine(a > c);//false
			Console.WriteLine(c > b);//true
			Console.WriteLine(a < c);//true
			Console.WriteLine(a >= c);//false
			Console.WriteLine(a <= c);//true
		}
    }
}

三.逻辑运算符

&& || !

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/**
 * 逻辑运算符
 * 	&&(与):符号两边同时成立  则  成立
 *  ||(或):只要有个成立          则  成立
 *  !(非): 结果相反
 **/
namespace Csp个人课程备课.第三章运算符和表达式
{
    class Test303逻辑运算符
    {
        static void Main(string[] args) {
			bool a = true;
			bool b = false;
			bool c = true;
			Console.WriteLine(a && b);//false
			Console.WriteLine(b || c);//true
			Console.WriteLine(!c);//false
			int d = 1;
			int e = 2;
			int f = 3;
			Console.WriteLine(d > e && f < e);//false
			Console.WriteLine(e < f || d > f);//true
			Console.WriteLine(!(f > d));//false
		}
    }
}

四.赋值运算符

 (赋值) +=  -=  *= /= %=

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/**
 * 赋值运算符
 * 	=	+=	-=	*=	/=	%=
 **/
namespace Csp个人课程备课.第三章运算符和表达式
{
    class Test304赋值运算符
    {
        static void Main(string[] args) {
			int a = 10;
			int b = 20;
			int c;
			c = a + b;
			Console.WriteLine(c);//30
			c += a;
			Console.WriteLine(c);//40
			c -= a;
			Console.WriteLine(c);//30
			c /= 1;
			Console.WriteLine(c);//30
			b %= 2;
			Console.WriteLine(b);//0
		}
    }
}

五.位运算

&(按位与)	|(或)	^(异或)	~(非)   <<(左移)	>>(右移)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/**
 * 位运算符
 * 		&(按位与)	   |(或)		^(异或)	~(非)   <<(左移)	>>(右移)	 >>>(无符号右移)
 * 		
 * 		二进制
 * 			十进制转换二进制
 * 
 * 		13	二进制	1101
 * 
 * 		2048	1024	512	  256	128	 64	 32	  16   8  4  2  1 权次方
 * 													   1  1  0  1
 * 		154							1     0   0    1   1  0  1  0
 * 		685				1       0   1     0   1    0   1  1  0  1
 * 		1250	1       0       0   1     1   1    0   0  0  1  0
 * 		243                         1     1   1    1   0  0  1  1
 * 		684             1       0   1     0   1    0   1  1  0  0
 * 		60                                    1    1   1  1  0  0
 * 		//如243可以减128用得到就是1余数再往后减可以减就是1,不够减就是0
 * 		符号位  1代表负数   0 代表 正数
 **/
namespace Csp个人课程备课.第三章运算符和表达式
{
    class Test305位运算符
    {
        static void Main(string[] args) {
			int a = 60;
			//二进制:111100
			int b = 13;//二进制:001101  1101前面的0是补上去的   正数补0负数补1  为了和要比较的二进制位数一致
			int c = 0; //
			c = a & b; // 二进制:001100 相对应的位都为1时结果为1  
			Console.WriteLine(c);//12    

			c = a | b;//二进制:111101相对应的只要有一个为1结果为1 	111101
			Console.WriteLine(c);//61

			c = a ^ b;//二进制:110001相对应的位 相同为0 不同为1
			Console.WriteLine(c);//49

			c = ~a;   //二进制:000011 相对应的位  取反
			Console.WriteLine(c);//-61

			c = a << 2; //二进制:11110000
			Console.WriteLine(c);//240

			c = -a >> 60;//二进制:二进制 32个1
			Console.WriteLine(c);//-1
		}
    }
}

六.条件运算符

(三元运算符) 表达式1?表达式2:表达式3 ->	3>2?3:2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/**
 * 三目运算符  如果  否则
 * 		1? 2: 3
 * 		1:条件	2:条件成立的话要做的事	3.条件不成立要做的事**/
namespace Csp个人课程备课.第三章运算符和表达式
{
    class Test306三元运算符
    {
        static void Main(string[] args) {
            int a = 10;
            int b;
            b = (a > 10) ? 100 : 50;  //如果a大于10 条件 则 成立为100,否则 为 50.
            Console.WriteLine(b);//条件不成立所以50
        }
    }
}

第四章:分支语句

一.条件语句

1.单分支if语句
	如果...就...
	if(条件){条件成立后我们要做的事}
2.if-else语句
	如果...就...否则...
	if(条件){条件成立后我们要做的事}else{条件不成立我们要做的事}

需求:判断用户年龄    如果年龄满18我们就输出  欢迎光临  否则输出  谢绝入内

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

namespace Csp个人课程备课.第四章条件语句
{
    class Test401单分支if和ifelse语句
    {
        static void Main(string[] args) {
			//需求:判断用户年龄    
			//如果年龄满18我们就输出  欢迎光临  
			//否则输出  谢绝入内s
			Console.WriteLine("请输入年龄:");     //给用户一个提示
			//获取用户在控制输入的值,并将读取的字符转换为int给age赋值
			int age = int.Parse(Console.ReadLine());
			if (age >= 18)
			{
				Console.WriteLine("欢迎光临");
			}
			else
			{
				Console.WriteLine("谢绝入内");
			}
		}
    }
}

3.if-esle if语句
	如果...就...否则  如果(可能有多个)...就 ...否则...
	 if(条件1){条件1成立后我们要做的事}
	 else if(条件2){条件2成立后我们要做的事}
			.可以有多个
	 else(前面所有条件都不满足我们要做的事)
需求:判断春夏秋冬

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

namespace Csp个人课程备课.第四章条件语句
{
    class Test402多条件ifelseif语句
    {
        static void Main(string[] args) {
			//需求:判断春夏秋冬
			// 1 2 3春
			// 4 5 6夏
			// 7 8 9秋
			// 10 11 12冬
			// 要求 : 用户输入的形式
			// 至少三种方式实现
			Console.WriteLine("请输入月份:");
			int month = int.Parse(Console.ReadLine());
			if (month <= 3)
			{
				Console.WriteLine("春天在这里");
			}
			else if (month >= 4 && month <= 6)
			{
				Console.WriteLine("最爱的夏天来了");
			}
			else if (month >= 7 && month <= 9)
			{
				Console.WriteLine("落叶秋");
			}
			else if (month >= 10 && month <= 12)
			{
				Console.WriteLine("冻感超人");
			}
			else
			{
				Console.WriteLine("月份错误");
			}
		}
    }
}

4.if嵌套
需求:如果分数大于60输出及格
	 否则如果小于60输出挂科
	 否则输出 谢天谢地

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

namespace Csp个人课程备课.第四章条件语句
{
    class Test403if语句嵌套
    {
        static void Main(string[] args) {
			//需求:如果分数大于60输出及格
			//否则如果小于60输出挂科
			//否则输出 谢天谢地
			int score = int.Parse(Console.ReadLine());
			if (score > 60 && score <= 100)
			{
				Console.WriteLine("及格");
			}
			else if (score < 60 && score >= 0)
			{
				Console.WriteLine("挂科");
			}
			else
			{
				if (score > 100 || score < 0)
				{
					Console.WriteLine("成绩错误");
				}
				else
				{
					Console.WriteLine("谢天谢地");
				}
			}
			Console.WriteLine("==============================");
			if (score > 60)
			{
				if (score <= 100)
				{
					Console.WriteLine("及格");
				}
				else
				{
					Console.WriteLine("成绩错误");
				}
			}
			else if (score < 60)
			{
				if (score >= 0)
				{
					Console.WriteLine("挂科");
				}
				else
				{
					Console.WriteLine("成绩错误");
				}
			}
		}
    }
}

5.switch case
switch (值) {//整型 字符 Enum枚举
	case 值:语句; break;
	...
	...
	...
	default:语句; break;
}
需求:判断春夏秋冬
	1 2 3春
	4 5 6夏
	7 8 9秋
	10 11 12冬

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

namespace Csp个人课程备课.第四章条件语句
{
    class Test404使用switch语句
    {
        static void Main(string[] args) {
			Console.WriteLine("请输入月份:");
			int month = int.Parse(Console.ReadLine());
			switch (month)
			{//整型 字符 Enum枚举
				case 1:
				case 2:
				case 3: Console.WriteLine("春"); break;
				case 4:
				case 5:
				case 6: Console.WriteLine("夏"); break;
				case 7:
				case 8:
				case 9: Console.WriteLine("秋"); break;
				case 10:
				case 11:
				case 12: Console.WriteLine("冬"); break;
				default: Console.WriteLine("没有当前月"); break;
			}
		}
    }
}

第五章:循环

一.循环

循环语句是由循环体及终止语句两部分组成,循环体就是要重复执行的操作

1.while循环
    while(循环条件){循环操作}
    特点:先判断,再执行

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

namespace Csp个人课程备课.第五章循环
{
    class Test501使用While循环
    {
        static void Main(string []args) {
            //需求:输出10次我正在打怪升级
            int i = 0;
            while (i<10) {
                Console.WriteLine("我正在打怪升级");
                i++;
            }
        }
    }
}

2.do while循环
    do{循环操作}while(循环条件);
    特点:先执行一次,再判断

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

namespace Csp个人课程备课.第五章循环
{
    class Test502使用dowhile循环
    {
        static void Main(string[] args) {
            //需求:输出10次我正在打怪升级
            int i = 0;
            do {
                Console.WriteLine("我正在打怪升级");
                i++;
            }while(i<10);
        }
    }
}

3.for循环
	    for(1;2;3){4}
	    1.初始值(从几开始循环)
	    2.条件(boolean类型的结果)
	    3.每次循环对初始值的改变
	    4.循环体(重复要做的事情)
    执行顺序:1 2 4 3 2 4 3 2 4 3 ...直到2条件不成立  循环结束

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

namespace Csp个人课程备课.第五章循环
{
    class Test503使用for循环
    {
        static void Main(string[] args) {
            //需求:输出1~100的 偶数
            for (int i = 1;i<=100;i++) {
                if (i%2==0) {//算出偶数
                    Console.WriteLine("当前i的值为:"+i);
                }
            }
        }
    }
}

foreach循环(数组)
4.continue和break(通常与条件语句同时使用)
    continue:继续下一次循环
    break:跳出整个循环

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

namespace Csp个人课程备课.第五章循环
{
    class Test509循环控制
    {
        static void Main(string[] args) {
			//1:50层楼 模拟电梯 (第8楼和第9楼位同一家公司  电梯 只停8楼 9楼 不停 直到10楼往后)
			//2:40层及以上为私人住所电梯不上去
			for (int i = 1; i <=50; i++) {
				if(i==9) {
					continue;
				}else if(i>39){
					break;
				}
				Console.WriteLine("电梯当前在第"+i+"层");
			}
		}
	}
}

5.各循环的无限循环
    while(true){循环操作}
    do{循环操作}while(true);
    for(;;){循环操作}

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

namespace Csp个人课程备课.第五章循环
{
    class Test508各循环的无限循环
    {
        static void Main(string []args) {
			/*for (;1==1;) {
				Console.WriteLine("a");
			}*/
			/*for (;true;) {
				Console.WriteLine("a");
			}*/
			/*for (;;) {
				Console.WriteLine("a");
			}*/
			/*while (1==1) {
				Console.WriteLine("a");
			}*/
			/*while (true) {
				Console.WriteLine("a");
			}*/
			/*do {
				Console.WriteLine("a");
			} while (1==1);*/
			/*do {
				Console.WriteLine("a");
			} while (true);*/
		}
	}
}

小练习

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

namespace Csp个人课程备课.第五章循环
{
    class Test504计算100以内数字之和
    {
        static void Main(string[] args) {
            //需求:计算1+2+3+4+...100的结果
            int sum = 0;
            for (int i=1;i<=100;i++) {
                sum += i;
                Console.WriteLine(sum);
            }
        }
    }
}

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

namespace Csp个人课程备课.第五章循环
{
    class Test505找到100到999之间的水仙花数
    {
        static void Main(string []args) {
            //需求:找出100到999之间的水仙花数(153=1*1*1+5*5*5+3*3*3)
            int g, s, b;
            for (int i = 100; i < 1000; i++)
            {
                g = i % 10;
                s = i % 100 / 10;
                b = i / 100;
                if (i==g*g*g+s*s*s+b*b*b) {
                    Console.WriteLine(i);
                }
            }
        }
    }
}

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

namespace Csp个人课程备课.第五章循环
{
    class Test506打印99乘法表
    {
        static void Main(string[] args) {
            //需求:打印99乘法表
            for (int y = 1; y <= 9; y++) {
                for (int x=1;x<=y;x++){
                    Console.Write(x+"*"+y+"="+x*y+"  ");
                }
                Console.WriteLine("");
            }
        }
    }
}

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

namespace Csp个人课程备课.第五章循环
{
    class Test507计算学生成绩
    {
        //需求:输入5个学生成绩计算5个学生的总分及平均分
        static void Main(string[] args) {
            double sum = 0;
            for (int i = 1;i<=5;i++) {
                Console.Write("请输入第"+i+"个学生的成绩:");
                double score = double.Parse(Console.ReadLine());
                sum += score;
            }
            Console.WriteLine("总分为:"+sum);
            Console.WriteLine("平均分为:"+sum/5);
        }
    }
}

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

namespace Csp个人课程备课.第五章循环
{
    class Test510猜拳游戏
    {
        static void Main(string[] args) {
			Random r = new Random();
			while (true)
			{
				int numWj;//玩家出的拳（数字）
				int numDn = r.Next(1,4); //电脑随机出拳（数字）
				Console.WriteLine("请出拳:1-石头 2-剪刀 3-布 0-退出");
				numWj = int.Parse(Console.ReadLine());
				if (numWj > 3 || numWj < 0)
				{
					Console.WriteLine("请正确出拳！\n");
				}else if (numWj == 0){
					break;
				}else{
					/*  1 2 3
						-1 */
					if (numWj - numDn == -1 || numWj - numDn == 2)
					{//玩家赢的局
                        Console.WriteLine("你出的是:" +
                            (numWj == 1 ? "【石头】，" : numWj == 2 ? "【剪刀】，" : "【布】，")
                            + "电脑出的是:" + (numDn == 1 ? "【石头】，" : numDn == 2 ? "【剪刀】，" : "【布】，")
                            + "恭喜你，你赢了！");
                    }
					else if (numWj - numDn == -2 || numWj - numDn == 1)
					{//玩家输的局
						Console.WriteLine("你出的是:" +
							(numWj == 1 ? "【石头】，" : numWj == 2 ? "【剪刀】，" : "【布】，")
							+ "电脑出的是:" + (numDn == 1 ? "【石头】，" : numDn == 2 ? "【剪刀】，" : "【布】，")
							+ "再接再厉哦，你输了！");
					}
					else
					{
						Console.WriteLine("你出的是:" +
							(numWj == 1 ? "【石头】，" : numWj == 2 ? "【剪刀】，" : "【布】，")
							+ "电脑出的是:" + (numDn == 1 ? "【石头】，" : numDn == 2 ? "【剪刀】，" : "【布】，")
							+ "太有默契了，你们打平了！");
					}
				}
			}
		}
    }
}

第六章:数组

一.数组

概念:连续等大的存储空间,类型相同的数据集合
	定义:类型 数组名 [数组大小]
		int arr[3];				//只定义不赋值
		int arr1[3]={1,2,3};	//完全列举法
		int arr2[3]={1,2};		//部分列举法
		int arr3[]={1,2,3,4};	//省略大小列举法
	如何访问数组元素:
		通过数组下标来访问,数组下标从0开始

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

namespace Csp个人课程备课.第六章数组
{
    class Test601数组
    {
        static void Main(string[] args) {
            int []arr = new int[3];
            int []arr1 = new int[3] { 1, 2, 3 };
            int []arr2 = new int[] { 1, 2, 3 ,4};
            int []arr3 = { 1, 2, 3 };
            //通过数组下标访问数组元素
            Console.WriteLine("arr1数组下标为1的元素为:"+arr1[1]);
            //给数组赋值
            arr[0] = 1;
            arr[1] = 2;
            Console.WriteLine("没有赋值的arr数组空间元素为:"+arr[2]);
            Console.WriteLine("arr2数组长度为:"+arr2.Length);
            //数组遍历
            Console.WriteLine("======数组遍历======");
            for (int i=0;i<arr3.Length;i++) {
                Console.WriteLine(arr3[i]);
            }
            Console.WriteLine("======数组遍历======");
            foreach (int a in arr3) {
                Console.WriteLine(a);
            }
        }
    }
}

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

namespace Csp个人课程备课.第六章数组
{
    class Test602求数组中的最大最小值
    {
        static void Main(string[] args) {
			//num[5]存放要排序的数字
			//max,min 最大值，最小值
			//i 循环变量
			int []num = new int[5];
			int max, min, i;
			/*循环输入5个数字*/
			Console.WriteLine("请输入5个数字:");
			for (i = 0; i < 5; i++){
				num[i]=int.Parse(Console.ReadLine());
			}
			//默认将最大值、最小值均设置为数组的第一个元素
			max = num[0];
			min = num[0];
			/*
			 *循环遍历数组
			 *将max与每个数组元素相比较，求出最大值
			 *将min与每个数组元素相比较，求出最小值
			 *i从1开始，即从数组第二个元素开始，是因为我们默认了max=min=num[0]
			 *所以不需要与数组第一个元素比较
			 */
			for (i = 1; i < 5; i++){
				//如果当前数组元素比当前max还大，则将该数组元素设置为最大值
				if (max < num[i]){
					max = num[i];
				}
				//如果当前数组元素比当前min还小，则将该数组元素设置为最小值
				if (min > num[i]){
					min = num[i];
				}
			}
			//输出最大值和最小值
			Console.WriteLine("最大值为:"+ max);
			Console.WriteLine("最小值为:"+ min);
		}
    }
}

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

namespace Csp个人课程备课.第六章数组
{
    class Test603冒泡排序
    {
     /*
     * 冒泡排序:相邻的两个数字两两比较   较大的放在后面
     * 	int [] x = {6,3,8,2,9,1};
     * 	从小到大排序:6 3 8 2 9 1-->1 2 3 6 8 9
     * 	
     * 	第一趟:6 3 8 2 9 1 
     * 		第一次:3 6 8 2 9 1
     * 		第二次:3 6 8 2 9 1
     * 		第三次:3 6 2 8 9 1
     * 		第四次:3 6 2 8 9 1
     * 		第五次:3 6 2 8 1 9
     * 	第二趟:3 6 2 8 1 9
     * 		第一次:3 6 2 8 1 9
     * 		第二次:3 2 6 8 1 9
     * 		第三次:3 2 6 8 1 9
     * 		第四次:3 2 6 1 8 9
     * 	第三趟:3 2 6 1 8 9
     * 		第一次:2 3 6 1 8 9
     * 		第二次:2 3 6 1 8 9 
     * 		第三次:2 3 1 6 8 9 
     * 	第四趟:2 3 1 6 8 9
     * 		第一次:2 3 1 6 8 9
     * 		第二次:2 1 3 6 8 9 
     * 	第五趟:2 1 3 6 8 9
     * 		第一次:1 2 3 6 8 9
     * */
        static void Main(string[] args) {
            int[] x = { 6, 3, 8, 2, 9, 1 };
            for (int i = 0; i < x.Length - 1; i++) {
                for (int j = 0; j < x.Length - 1 - i; j++) {
                    if (x[j] > x[j + 1]) {
                        //借助第三块空间
                        /*int n = x[j];
                        x[j] = x[j+1];
                        x[j+1] = n;*/
                        //    c      a       b
                        x[j] = x[j] ^ x[j + 1];
                        //	  a       c      b  
                        x[j + 1] = x[j] ^ x[j + 1];
                        //	  b	      c		 a
                        x[j] = x[j] ^ x[j + 1];
                    }
                }
            }
            foreach (int i in x) {
                Console.Write(i + " ");
            }
        }
    }
}

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

namespace Csp个人课程备课.第六章数组
{
    class Test604二维数组
    {
        static void Main(string []args) {
            int[,] arr = new int[3,2];
            int[,] arr1 = new int[2,1] { { 1 },{ 2 } };
            int[,] arr2 = new int[2,3] { { 1,2,3},{ 4,5,6} };
            int[,] arr3 = { {1,2 },{ 3,4},{ 5,6}};
            //通过数组下标访问数组元素
            Console.WriteLine("arr1数组下标为1的元素为:" + arr1[0,0]);
            //给数组赋值
            arr[0,0] = 1;
            arr[0,1] = 2;
            Console.WriteLine("没有赋值的arr数组空间元素为:" + arr[1,0]);
            Console.WriteLine("arr2数组长度为:" + arr2.Length);
            Console.WriteLine("arr2数组长度为:" + arr2.GetLength(0));
            Console.WriteLine("arr2数组长度为:" + arr2.GetLength(1));
            //数组遍历
            Console.WriteLine("======数组遍历======");
            for (int i = 0; i < arr2.GetLength(0); i++) {
                for (int j = 0; j < arr2.GetLength(1); j++) {
                    Console.WriteLine(arr2[i,j]);
                }
            }
            Console.WriteLine("======数组遍历======");
            foreach (int a in arr3) {
                 Console.WriteLine(a);
            }
        } 
    }
}

第七章:字符串

一.字符串处理

C#的string类型就是一个字符数组，
得到长度:变量名.Length
也可以通过下标访问具体的数组元素:str[i]

操作字符串常用的方法：
Trim():去掉字符串首尾空格
ToLower():把字符串转化为小写形式
ToUpper():把字符串转化为大写形式
Insert():把一个字符串指定到另外一个字符串的指定索引处
IndexOf():得到字符串中第一次出现指定子字符串的索引位置
LastIndexOf():得到字符串中最后一次出现指定子字符串的索引位置
Join():把两个字符串合并成一个新的字符串
Replace():用字符串替换字符串
CopyTo():复制字符串
split():根据指定的字符，把字符串拆分成指定的字符数组
Substring():在字符串中获取给定位置的字符串
Format():格式化字符串

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

namespace Csp个人课程备课.第七章字符串
{
    class Test701字符串操作
    {
        static void Main(string[] args)
        {
            //声明两个字符串
            string str1 = "Hello";
            string str2 = "CXSW";
            //声明一个大小为三的字符串数组，并进行初始化
            string[] strs = new string[] { "!", "!", "!" };
            //将str1和str2使用+进行连接，再使用Join方法与字符数组strs进行连接
            string str = string.Join(str1 + str2, strs);//!HelloDirect!HelloDirect!
            /*Join在指定string数组的每个元素之间串联指定的分隔符(string)，
            从而产生单个串联的字符串*/
            string str3 = string.Format("字符串1:{0};字符串2:{1};\n连接后的字符串:{2}", str1, str2, str);
            Console.WriteLine(str3);
            //将str3用'!'分割为字符数组，使用split()方法
            string[] str4 = str.Split('!');
            foreach (string st in str4) {
                Console.WriteLine(st);//HelloDirect
            }
            //用substring，取出str字符串中下标为6，开始的6个字符
            /*
             substring(int32):检索子字符串，子字符串从指定的字符位置开始
             substring(int32,int32):检索子字符串，子字符串从指定的字符位置开始且有固定长度
             */
            string str5 = str.Substring(6, 6);

            Console.WriteLine(str5);
            //控制台输入一个字符串
            Console.WriteLine("请输入一个字符串:");
            str = Console.ReadLine();
            Console.WriteLine("字符串的长度为：" + str.Length);
            Console.WriteLine("字符串中第一个字符为：" + str[0]);
            Console.WriteLine("字符串中最后一个字符为：" + str[str.Length - 1]);
            if (str.IndexOf("@") != -1) {
                Console.WriteLine("字符串中含有@，其出现的位置是{0}", str.IndexOf("@") + 1);
            }else{
                Console.WriteLine("字符串中不含有@");
            }
            //插入字符串
            str = str.Insert(1, "@@@");
            Console.WriteLine("新字符串为：" + str);

        }
    }
}

第八章:结构体

一.C# 结构体（Struct）

在 C# 中，结构体是值类型数据结构。
它使得一个单一变量可以存储各种数据类型的相关数据。
struct 关键字用于创建结构体。
struct Users
{
   public string name;
   public int age;
   public string gender;
   public string phone;
}; 

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

namespace Csp个人课程备课.第八章结构体
{
    struct Users  //定义一个结构体
    {
        public string name;     //姓名
        public int age;         //年龄
        public string gender;   //性别
        public string phone;    //电话
    };
    class Test801结构体定义及使用
    {
        static void Main() {
            Users user1;        /* 声明 user1，类型为 Users */
            Users user2;        /* 声明 user1，类型为 Users */

            /* 赋值 */
            user1.name = "小小";
            user1.age = 18;
            user1.gender = "女";
            user1.phone = "120";
            
            user2.name = "红红";
            user2.age = 20;
            user2.gender = "男";
            user2.phone = "110";

            /*输出 */
            Console.WriteLine("user1的姓名为 : {0}", user1.name);
            Console.WriteLine("user1的年龄为 : {0}", user1.age);
            Console.WriteLine("user1的性别为 : {0}", user1.gender);
            Console.WriteLine("user1的电话为 :{0}", user1.phone);

            Console.WriteLine("user2的姓名为 : {0}", user2.name);
            Console.WriteLine("user2的年龄为 : {0}", user2.age);
            Console.WriteLine("user2的性别为 : {0}", user2.gender);
            Console.WriteLine("user2的电话为 :{0}", user2.phone);
        }
    }
}

第九章:面向对象

一.类

种类 分类 
类的定义以关键字 class 开始，后跟类的名称。
类的主体，包含在一对花括号内。

类和结构有以下几个基本的不同点：

类是引用类型，结构是值类型。
结构不支持继承。
结构不能声明默认的构造函数。

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

namespace Csp个人课程备课.第九章面向对象
{
    //定义一个类
    public class User {
        //定义类的属性
        public string name;    //姓名
        public int age;        //年龄
        public string gender;  //性别
        public string phone;   //电话
        //还可定义方法等
    }
    class Test801类
    {
        static void Main() {
            //创建类的对象
            User user1 = new User();
            User user2 = new User();
            /* 赋值*/
            user1.name = "小小";
            user1.age = 18;
            user1.gender = "女";
            user1.phone = "120";

            user2.name = "红红";
            user2.age = 20;
            user2.gender = "男";
            user2.phone = "110";

            /* 输出 */
            Console.WriteLine("user1的姓名为 : {0}", user1.name);
            Console.WriteLine("user1的年龄为 : {0}", user1.age);
            Console.WriteLine("user1的性别为 : {0}", user1.gender);
            Console.WriteLine("user1的电话为 :{0}", user1.phone);

            Console.WriteLine("user2的姓名为 : {0}", user2.name);
            Console.WriteLine("user2的年龄为 : {0}", user2.age);
            Console.WriteLine("user2的性别为 : {0}", user2.gender);
            Console.WriteLine("user2的电话为 :{0}", user2.phone);
        }
    }
}

二.方法

1.理解:一个问题处理的办法
2.为什么使用方法:
	使程序变得更简短而清晰
	有利于程序为维护
	可以提高程序开发的效率
	提高代码的复用性
3.格式
访问修饰符    修饰符    返回值类型    方法名(参数列表) {
	语句块;
}

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

namespace Csp个人课程备课.第八章方法
{
    class Test801方法的定义及使用
    {
        static void Main() {
			//方法调用
			Test801方法的定义及使用 t = new Test801方法的定义及使用();
			t.test1();
			t.test2(2);
			t.test3(1, 2);
			int a = t.test4();
			Console.WriteLine("调用test4函数得到的返回值为:"+ a);
			int b = t.test5(2, 3);
			Console.WriteLine("调用test5函数得到的返回值为:"+ a);
		}
		void test1(){
			Console.WriteLine("我是没有参数没有返回值的test1函数");
		}
		void test2(int a){
			a = a + 1;
			Console.WriteLine("我是有1个参数没有返回值的test2函数,a="+ a);
		}
		void test3(int a, int b){
			int c = a + b;
			Console.WriteLine("我是有2个参数没有返回值的test3函数,c="+ c);
		}
		int test4(){
			Console.WriteLine("我是没有参数有返回值的test4函数");
			return 4;
		}
		int test5(int a, int b){
			Console.WriteLine("我是有参数有返回值的test5函数");
			return a + b;
		}
	}
}

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

namespace Csp个人课程备课.第八章方法
{
    class Test802求最大值
    {
        static void Main() {
            Test802求最大值 t =  new Test802求最大值();
            int num = t.max(8,5);
            Console.WriteLine("最大值为:"+num);
        }
        /*求最大值函数*/
        int max(int a, int b){
            if (a > b){
                return a;
            }
            return b;
        }
    }
}

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

namespace Csp个人课程备课.第八章方法
{
    class Test803计算长方形的周长及面积
    {
        static void Main() {
            Test803计算长方形的周长及面积 t = new Test803计算长方形的周长及面积();
            Console.WriteLine("请输入长方形的长:");
            double c = Double.Parse(Console.ReadLine());
            Console.WriteLine("请输入长方形的宽:");
            double k = Double.Parse(Console.ReadLine());
            Console.WriteLine("长方形的周长为:"+t.getGirth(c,k));
            Console.WriteLine("长方形的面积为:"+t.getArea(c, k));
        }
        //定义函数,计算面积
        double getArea(double c, double k){
            //计算，并返回面积
            return c * k;
        }
        //定义函数，计算周长
        double getGirth(double c, double k){
            //计算，并返回周长
            return (c + k) * 2;
        }
    }
}

三.访问控制权限修饰符

类中的成员包括字段、属性、方法。每个类成员在定义时需要指定访问修饰符、修饰符。

类的访问修饰符主要有两个，即 internal 和 public,如果省略了访问修饰符，即为 internal。

类中成员的访问修饰符有 4 个，具体用法如下。
1) public:成员可以被任何代码访问。
2) private:成员仅能被同一个类中的代码访问，
	如果在类成员前未使用任何访问修饰 符，则默认为private。
3) internal:成员仅能被同一个项目中的代码访问。
4) protected:成员只能由类或派生类中的代码访问。
	派生类是在继承中涉及的，将在后面详细介绍。

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

namespace Csp个人课程备课.第八章面向对象
{
    class Test804控制修饰符 {
        //类加载时，会自动为字段赋值
        public string name = "张三";          //公共的   任何地方
        private int age = 30;                 //私有的   当前类中
        internal char gender = '男';          //内部的   当前项目中
        protected string address = "兰州";    //受保护的 当前类和子类
        void show() {
            Console.WriteLine("姓名是:"+name);
            Console.WriteLine("年龄是:" + age);
            Console.WriteLine("性别是:" + gender);
            Console.WriteLine("住址是:" + address);
        }
    }
    class TestA {
        void show(){
            Test804控制修饰符 t = new Test804控制修饰符();
            Console.WriteLine("姓名是:" + t.name);
           // Console.WriteLine("年龄是:" + t.age);  //其他类中不能访问
            Console.WriteLine("性别是:" + t.gender);
            //Console.WriteLine("住址是:" + t.address); //其他类中不能访问
        }
    }
}

四.static , readonly

static 静态的
属性
	静态属性:它不依赖于对象而存在 整个类中只有一份
	使用静态的属性 不通过 对象.属性的形式来访问 
	我们可以直接通过类名.属性来访问
	常量不能使用static修饰
方法
	静态方法:使用静态方法叶不依赖与对象  我们也不通过对象.方法来访问
		可以直接使用类名.方法调用方法

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

namespace Csp个人课程备课.第八章面向对象
{
    class Test805静态的{
		static void Main() {
			Student s = new Student();
			Console.WriteLine(s.age);
			//Console.WriteLine(s.score); //静态属性通过类名访问
			Console.WriteLine(Student.score); //静态属性可以直接通过类名来访问
												  //Console.WriteLine(Student085.age);
			s.eat();
			//s.sleep();					//静态方法通过类名访问
			Student.sleep();                 //静态方法可以直接通过类名来访问
												//Student085.eat();
		}
	}
	class Student{
		public int age = 20;            //非静态的属性
		public static int score = 90;   //静态属性
		const int a = 30;               //常量
		//const static int b = 40;		//常量不能使用static修饰
		public void eat(){
			Console.WriteLine("我是非静态的方法");
			Console.WriteLine(age);   //静态和非静态属性在普通方法中都可以使用
			Console.WriteLine(score);
			Console.WriteLine("常量a的值为:"+a);
		}
		public static void sleep(){
			Console.WriteLine("我是静态的方法");
			Console.WriteLine(score);
			//Console.WriteLine(age);	//静态方法中只能使用静态的属性
			Console.WriteLine("常量a的值为:" + a);
		}
	}
}

readonly 只读
属性
	只读属性:只能读取字段值不能给字段赋值

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace Csp个人课程备课.第八章面向对象
{
    class Test806只读的{
        readonly int age = 10;
		int score = 20;
		const int a = 30;
		//const readonly int b = 40;  //常量不可使用
		void show() {
			//readonly int age = 20; //不能修饰局部变量
			Console.WriteLine("年龄为:" + age);
			Console.WriteLine("成绩为:" + score);
			Console.WriteLine("a为:" + a);
			//age = 25;	//只读字段不能修改值
			score = 35;
			//a = 35;		//常量不能修改值
			Console.WriteLine("成绩为:" + score);
		}
    }
}

五.封装

封装：private私有的
用private关键字将不想被外界访问的属性或者方法都可以隐藏起来
	
封装对于开发者和使用者都有好处
	对于开发者：
		能让数据得到保护 从而更加的安全
		
	对于使用者：
		能够让使用者将自己的精力集中在核心业务逻辑上
		
对于属性  如果把属性设置成了private的  那其他类以及外界就访问不到了
		如果我们还想要让外界去访问 那么我们就要给每一个属性提供一对
		公共的专门用来访问每一个属性的方法 getter  setter
		
		getter主要目的是为了给得到一个属性的值 提供一个统一的方法  
			如果你修改了这个属性的值 那么所有通过getter方法得到的
			这个属性的值都会被修改 从而降低了代码之间的耦合
			
		setter主要目的是为了让类的开发者拿回主动权 
		         让开发者来决定使用者是否可以修改某个属性
		         
对于方法 一个类可能会有很多个方法但是只有一部分是核心的方法
          而其他的方法可能是为核心的方法提供服务的 这样的我们就可以把核心
          的方法都 定义成public公共的 而那些为核心方法提供服务的方法就可以
          定义成private的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Csp个人课程备课.第九章面向对象
{
    class Test807封装对于属性
    {
		static void Main() { 
			Student807 s = new Student807();
			//s.age = 30;
			//Console.WriteLine(s.age);//私有的属性 外界以及其他类无权访问
			Console.WriteLine(s.Age);
			s.Name = "张三";
			Console.WriteLine(s.Name);
			//s.address = 30;
			//Console.WriteLine(s.address);//私有的属性 外界以及其他类无权访问
			s.setAddress("兰州");
			Console.WriteLine(s.getAddress());
		}
	}
	class Student807
	{
		//使用getset访问器
		public string Name { get; set; }
		//也可以这样写
		private int age;
		public int Age{
			get { return age; }
			set { age = value; }
		}
		//java的方式
		private string address;
		public string getAddress()
		{
			return address;
		}
		public void setAddress(string address)
		{
			this.address = address;
		}
	}
}

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

namespace Csp个人课程备课.第九章面向对象
{
    class Test808封装对于方法
    {
        static void Main() {
			Teacher808 t = new Teacher808();
			//t.eat();   私有方法无权访问
			t.teach();
		}
    }
    class Teacher808 {
		private void eat()
		{
			Console.WriteLine("补充体力");
		}
		private void sleep()
		{
			Console.WriteLine("补充精力");
		}
		private void play()
		{
			Console.WriteLine("有个好心情");
		}
		public void teach()
		{
			this.eat();
			sleep();
			play();
			Console.WriteLine("教书");
		}
	}
}

六.继承

存在与两个类之间的一种关系
形成继承关系的两个类 他们之间是一种is a 的关系（是一个什么什么）
被继承继承的那个类可以看做是父类 （子承父业）
    子类(派生类)继承父类(基类)那么也就同时继承了父类所有的方法和属性
    注意：私有的属性和方法 无权访问
               对象调用方法  调用的永远是对象的方法  new 出来的是谁是就是对象
      
     如果父子类中有同名的属性或方法  父类的属性会被隐藏
     
               
    C# 不支持多重继承 (一个类有且只有一个父类)  而父类也可以有父类
 	最终的类可以继承得到所有的方法及属性

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

namespace Csp个人课程备课.第八章方法{
    class Test804{
		static void Main() {
			Bird b = new Bird();
			Console.WriteLine("父类继承得到的性别:"+b.gender);
			//Console.WriteLine(b.age);   //私有的属性和方法 无权访问
			b.gender = "女"; //修改值
			Console.WriteLine("修改后的性别:"+b.gender);
			b.eat();
			//b.run();
			Dog d = new Dog();
			Console.WriteLine(d.gender);//公  //对象调用方法  调用的永远是对象的方法
			d.eat();//狗吃东西的方法
		}
    }
	class Animal071{  //动物
		private int age = 5;     //私有属性
		public string gender = "母";//公共的属性
		public void eat(){
			Console.WriteLine("动物吃东西的方法");
		}
		private void run(){
			Console.WriteLine("动物走路的方法");
		}
	}
	class Bird : Animal071{//鸟

	}
	class Dog : Animal071{
		public new string gender = "公";
		public new void eat(){
			Console.WriteLine("狗吃东西的方法");
		}
	}
}

六.abstract抽象的

在C#中使用关键字 abstract 来定义抽象类和抽象方法。
所谓抽象的就是不具体的,用户定义时还没想好要怎么去实现,对于实现不能具体描述时就会定义成抽象的,
比如:动物吃东西的方法 因为猫吃鱼 狗吃肉 羊吃草 不能把吃东西的方法定死了
所以就可把吃东西的方法写成抽象的具体谁怎么吃,留给继承他的子类来实现,
不同子类实现不同,可以满足不同的需求

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

namespace Csp个人课程备课.第九章面向对象
{
    public abstract class Animal{  //抽象类
        public abstract void eat();//抽象方法
        public void show() {       //普通方法
            Console.WriteLine("是动物");
        }
    }
    public class Dog : Animal
    {
        public override void eat() //子类必须实现抽象方法
        {
            Console.WriteLine("狗正在吃肉");
        }
    }
    public class Cat : Animal
    {
        public override void eat() //子类必须实现抽象方法
        {
            Console.WriteLine("猫正在吃鱼");
        }
    }
    class Test808抽象的abstrict
    {
        static void Main() {
            Dog d = new Dog();
            d.eat();
            d.show();  //继承后会得到父类的方法
            Cat c = new Cat();
            c.eat();
            c.show();
        }
    }
}

七.多态

一个事物的多种形态(一个对象总有多种称呼他的形式)

java中的多态总伴随着一种语法:  父类类型  = 子类的对象

对象调用方法  调用的事对象的方法 new出来的是谁对象就是谁

当我们使用多态的时候要明白  对象使客观存在的  不会因为它的称呼变了  本身就发生变化

调用方法的时候永远看的事 等号右边的

1.方法的重载(方法的过载 Overload)

发生在同一个类中的两个方法
	1.方法名要相同(主要)
	2.返回类型可能不同
	3.参数列表不同(主要)
		a.参数个数不同   show-1	show-2
		b.参数类型不同   show-2    show-3
		c.参数顺序不同   show-4	show-5
		(参数的名字不同 不算不同)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/*方法的重载(方法的过载 Overload)
	发生在同一个类中的两个方法
		1.方法名要相同(主要)
		2.返回类型可能不同
		3.参数列表不同(主要)
			a.参数个数不同   show-1	show-2
			b.参数类型不同   show-2 show-3
			c.参数顺序不同   show-4	show-5
			(参数的名字不同 不算不同)*/
namespace Csp个人课程备课.第八章面向对象
{
    class Test808方法的重载{
		static void Main() {
			Test808方法的重载 d = new Test808方法的重载();
			d.show(3);
		}
		public void show(){
			Console.WriteLine("show-1");
		}
		public void show(int a){
			Console.WriteLine("show-2");
		}
		public void show(String name){
			Console.WriteLine("show-3");
		}
		public void show(int age, String name){
			Console.WriteLine("show-4");
		}
		public void show(String name, int age){
			Console.WriteLine("show-5");
		}
		/*public void show(String n,int a){
			Console.WriteLine("show-5");
		}*/
	}
}

2.方法的重写(方法的覆盖 Override)

方法的重写是发生在有继承关系的子类中

重写方法的目的是因为父类给子类提供的方法  已经不满足现实的状况了 也就是说过时了
那么这个时候  子类要去重写父类的方法   主要目的就是为了  得到新的解决问题的方案

要被重写的方法要加virtual关键字变为可被重写的虚拟方法
重写方法要加override关键字

可以使用new来拓展原始非虚方法，但是不推荐使用

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

namespace Csp个人课程备课.第八章面向对象
{
    class Test809方法的重写{

    }
    class A {
        public void test11(int a) {
            Console.WriteLine("传递过来参数a的值为:"+a);
        }
        //要被重写的方法添加virtual关键字表示虚拟方法可以在子类中重写它的实现
        public virtual void test22(string name) {
            Console.WriteLine("传递过来的参数name的值为:"+name);
        }
    }
    class B : A{
        //public override void test11(int a) {} //未标记的方法无法被重写
        public new void test11(int a) {
            Console.WriteLine("new一般是用来拓展原始非虚方法，但是不推荐使用");
        }
        public override void test22(string name){
            base.test22(name); //调用父类的
            Console.WriteLine("我重写了父类的方法");
        }
    }
}

八.构造方法

1.特点
	a:方法名字和类名完全一致(类名首字母是大写的)
	b:没有返回那一部分 (连void都没有)
	
	public void show(){}
	public 类名(){}
	
2.作用
	用来在创建对象的时候直接给属性赋值用的(第一次我们叫做初始化)

3.什么时候执行
	普通方法必须得用对象去调用 才会执行
	构造方法 创建对象的时候

只要是个类就一定有构造方法  
	如果你不写出来  系统会默认提供给类一个无惨空体的构造方法
	但是如果你写了有参数的构造方法 那么这个系统提供的无参空体的构造方法就没了
	如果还想要使用没有参数的构造方法 那么就得把它自己写出来

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

namespace Csp个人课程备课.第八章面向对象
{
    class Test810构造方法{
		static void Main() { 
			People075 p1 = new People075();
			p1.Name = "张三";
			p1.Age = 30;
			Console.WriteLine("姓名为:"+p1.Name+" 年龄为:"+p1.Age);
			p1.show();
		}
    }
	class People075 {
		private string name;
		private int age;
		//利用get set对属性进行封装 两种写法都可以
        public string Name { get => name; set => name = value; }
        public int Age { get { return age; } set { age = value; } }

        public void show(){
			Console.WriteLine("我是普通的方法");
		}
		public People075(){
			Console.WriteLine("我是构造方法");
			name = "张三";
			age = 30;
		}
	}
}

构造方法也可以重载

构造方法不能被继承得到
	构造方法可以被重载 一个类可以实现多个构造方法
	但是构造方法不能被重写  构造方法根本不能被继承得到

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

namespace Csp个人课程备课.第八章面向对象 {
    /*只要是个类就一定有构造方法
          如果你不写出来  系统会默认提供给类一个无惨空体的构造方法
          但是如果你写了有参数的构造方法 那么这个系统提供的无参空体的构造方法就没了
          如果还想要使用没有参数的构造方法 那么就得把它自己写出来
          构造方法可以被重载 无法继承得到所以不能重写*/
    class Test811 {
        public Test811(){
            Console.WriteLine("我是无参数的构造方法");
        }
        public Test811(int a) {
            Console.WriteLine("我是有一个参数的构造方法,参数a的值为:"+a);
        }
        static void Main() {
            Test811 t1 = new Test811();
            Test811 t2 = new Test811(2);
        }
    }
}

九.析构方法

析构方法是在垃圾回收、释放资源时使用的。
析构方法中不带任何参数，它实际上是保证在程序中会调用垃圾回收方法 Finalize()。
~类名() {
        Console.WriteLine("我是析构方法");
    }

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

namespace Csp个人课程备课.第八章面向对象
{
    class Test812析构方法{
        public Test812析构方法() {
            Console.WriteLine("我是构造方法");
        }
        ~Test812析构方法() {  //程序执行结束后自动执行
            Console.WriteLine("我是析构方法");
        }
        static void Main() {
            Test812析构方法 t = new Test812析构方法();
        }
    }
}

十.接口

1.接口（Interface）就是一种规范
2.接口和抽象类的区别:
相同点
　　1.不能实例化；

　　2.包含未实现的方法声明

　　3.派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）
	 	
不同点		 
　　1.接口可以多继承，抽象类不能实现多继承。

　　2.接口只能定义抽象规则，抽象类既能定义抽象规则也能提供已实现的成员

　　3.接口是一组行为规范，抽象类是一个不完全的类，着重于族的概念

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

namespace Csp个人课程备课.第九章面向对象
{
    interface Animal { //定义一个接口
        void eat(); //定义一个方法
    }
    class Dog : Animal  //Dog实现接口Animal 可以有多个实现
    {
        public void eat() //实现接口中定义的方法
        {
            Console.WriteLine("实现接口必须实现接口中的方法");
        }
    }
    class Test813接口单实现
    {
        static void Main() {
            Dog d = new Dog();
            d.eat();
        }
    }
}

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

namespace Csp个人课程备课.第九章面向对象
{
    interface A {
        void a();
    }
    interface B : A
    {
        void b();
    }
    class AB : B
    {
        public void a()
        {
            Console.WriteLine("实现接口A必须实现接口A中的方法");
        }

        public void b()
        {
            Console.WriteLine("实现接口B必须实现接口B中的方法");
        }
    }
    class Test814接口多实现
    {
    }
}

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

namespace Csp个人课程备课.第九章面向对象
{
    public interface A15 {
        void a15();
    }
    public class B15 {
        public void b15() {
            Console.WriteLine("我是B15类的方法");
        }
    }
    public class C15 : B15, A15
    {
        public void a15()
        {
            Console.WriteLine("必须实现A15接口的方法");
        }
    }
    class Test815继承加实现
    {
        static void Main() {
            C15 c = new C15();
            c.a15();
            c.b15();
        }
    }
}

第十章:异常处理

异常与错误区别
	
	异常是不正常的事件,不是错误;程序运行过程中,发生某些意外的事情,
	比如10除以0,文件不存在		
	错误很难处理的,比如内存溢出,不能够通过异常处理机制来解决.
	异常是程序中发生的不正常的时间流,通过处理程序依然可以运行下去,
	但是错误是无法控制的,程序肯定要中断,常用的异常类如下:

常用的系统异常:

一.异常处理

	在 C# 语言中异常与异常处理语句包括三种形式，
	即 try catch、try finally、try catch finally。
	try
	{
	   // 有可能会出现异常的代码
	}
	catch( ExceptionName e1 )
	{
	   // 异常的处理
	}
	catch( ExceptionName e2 )
	{
	   // 异常的处理
	}
	catch( ExceptionName eN )
	{
	   // 异常的处理
	}
	finally
	{
	   // 不管是否有异常都会执行
	}

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

namespace Csp个人课程备课.第十一章异常处理
{
    class Test1101异常
    {
        static void Main() {
			//没有异常的情况下的执行顺序 try  finally
			//发生异常情况后的执行顺序 try(发生异常)   catch   finally
			try
			{
				int a = 10;
				int b = 0;
				int i = a/b;//异常一旦发生  之后的代码将不再执行
				Console.WriteLine("try");
			}
			catch (Exception e) //这里的catch可以有多个
			{
				Console.WriteLine("catch信息为:"+e.Message);
			}
			finally
			{
				Console.WriteLine("finally肯定会执行");
			}
		}
    }
}

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

namespace Csp个人课程备课.第十一章异常处理
{
    class Test1102自定义异常
    {
        static void Main() {
            try {
                int a = 1;
                int b = 0;
                int c = a / b;
            } catch {
                throw new MyException("0不能做分母");
            }
        }
    }
    //编写自定义异常类
    class MyException : Exception {
        //base指定创建派生类实例时应调用的基类构造函数。
        public MyException(string message) : base(message)
        {
            Console.WriteLine(message);
        }
    }
}

第十一章:集合

集合与数组比较类似，都用于存放一组值，
但集合中提供了特定的方法能直接操作集合中的数据，
并提供了不同的集合类来实现特定的功能。

集合简单的说就是数组的升级版。
他可以动态的对集合的长度（也就是集合内最大元素的个数）
进行定义和维护！

所有集合类或与集合相关的接口命名空间都是 using System.Collections;

一.ArrayList动态数组

有序集合
常用属性或方法:

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

namespace Csp个人课程备课.第十章集合
{
    class Test1001ArrayList集合
    {
        static void Main() {
            //集合的创建
            ArrayList listl = new ArrayList();
            //指定实例中复制的元素，并且初始容量与复制的元素个数相同
            ArrayList list2 = new ArrayList(listl);
            //设置其初始容量
            ArrayList list3 = new ArrayList(20);
            //在创建集合实例时向集合中添加元素
            ArrayList list4 = new ArrayList() { 1, 3, 2, 4 };
            //添加元素
            list3.Add(1);
            list3.Add(2);
            list3.Add(3);
            list3.Add(4);
            list3.Add(1);
            //获取集合的长度(元素个数)
            Console.WriteLine("list3元素个数为:"+list3.Count);//2
            //得到某个元素第一次出现的位置
            Console.WriteLine("list4中元素1的索引为:"+list4.IndexOf(1));//0
            //插入元素(索引,元素)
            list4.Insert(4,1);
            //得到某个元素最后一次出现的位置
            Console.WriteLine("list4中元素1的索引为:" + list4.LastIndexOf(1));//4
            //遍历集合
            foreach (var v in list4){
                Console.Write(v+" ");
            }
            Console.WriteLine();
            list4.Sort();//集合排序
            foreach (var v in list4) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //将集合中的元素顺序反转
            list4.Reverse();
            foreach (var v in list4) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            foreach (var v in list3) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //移除元素
            list3.Remove(1);
            foreach (var v in list3) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //移除指定位置的元素
            list3.RemoveAt(1);
            foreach (var v in list3) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
        }
    }
}

二.Queue队列

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

namespace Csp个人课程备课.第十章集合
{
    class Test1102Queue队列
    {
        static void Main() {
            //默认初始容量 32 个元素，使用默认的增长因子
            Queue q1 = new Queue();
            //从指定实例中复制的元素，并且初始容量与复制的元素个数、增长因子相同
            Queue q2 = new Queue(q1);
            //设置其指定的元素个数，默认增长因子
            Queue q3 = new Queue(30);
            //设置其指定的元素个数和增长因子
            Queue q4 = new Queue(30, 2);
            //添加元素
            q3.Enqueue(1);
            q3.Enqueue(2);
            q3.Enqueue(3);
            q3.Enqueue(4);
            q3.Enqueue(5);
            //获取集合的长度(元素个数)
            Console.WriteLine("q3元素个数为:" + q3.Count);
            //查看是否包含指定元素
            Console.WriteLine(q3.Contains(5));
            //队列遍历
            foreach (var v in q3){
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //拿到队列的第一个元素 不删除
            Console.WriteLine(q3.Peek());
            foreach (var v in q3) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //拿到队列第一个元素 并删除
            Console.WriteLine(q3.Dequeue());
            foreach (var v in q3) {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //清空队列
            q3.Clear();
            foreach (var v in q3)
            {
                Console.Write(v + " ");
            }
            Console.WriteLine();
        }
    }
}

三.Stack栈

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

namespace Csp个人课程备课.第十章集合
{
    class Test1103Stack栈
    {
        static void Main() {
            //初始容量创建 Stack 的对象
            Stack sk1 = new Stack();
            //从指定实例中复制的元素，并且初始容量与复制的元素个数、增长因子相同
            Stack sk2 = new Stack(sk1);
            //设置其初始容量
            Stack sk3 = new Stack(20);
            //添加元素
            sk3.Push(1);
            sk3.Push(2);
            sk3.Push(3);
            sk3.Push(4);
            sk3.Push(5);
            //判断是否存在该元素
            Console.WriteLine(sk3.Contains(4));
            //栈遍历
            foreach (var v in sk3)
            {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //取出栈顶元素 不删除
            Console.WriteLine(sk3.Peek());
            foreach (var v in sk3)
            {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //取出栈顶元素 并删除
            Console.WriteLine(sk3.Pop());
            foreach (var v in sk3)
            {
                Console.Write(v + " ");
            }
            Console.WriteLine();
            //清空
            sk3.Clear();
            foreach (var v in sk3)
            {
                Console.Write(v + " ");
            }
            Console.WriteLine();
        }
    }
}

四.Hashtable散列表

Hashtable 类实现了 IDictionary 接口，
集合中的值都是以键值对的形式存取的

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

namespace Csp个人课程备课.第十章集合
{
    class Test1104Hashtable散列表
    {
        static void Main() {
            //创建
            Hashtable ht = new Hashtable();
            //添加元素
            ht.Add(1, "Java");
            ht.Add(2, "C#");
            ht.Add(3, "Python");
            //集合中元素个数
            Console.WriteLine("集合ht的元素个数为:"+ht.Count);
            //判断集合中是否包含指定key的元素
            Console.WriteLine("集合中是否包含key为4的元素:" + ht.ContainsKey(1));
            //删除元素
            ht.Remove(1);
            //判断集合中是否包含指定 value 值的元素
            Console.WriteLine("集合中是否包含value为Java的元素:" + ht.ContainsValue("Java"));
            //获取键的集合 
            ICollection key = ht.Keys;
            foreach (int k in key)
            {
                Console.Write(k+" ");
            }
            Console.WriteLine("");
            //获取值的集合 
            ICollection values = ht.Values;
            foreach (string v in values)
            {
                Console.Write(v + " ");
            }
            Console.WriteLine("");
            //获取键值
            foreach (DictionaryEntry e in ht)
            {
                Console.Write(e.Key + ","+ e.Value+" ");
            }
            Console.WriteLine("");
        }
    }
}

五.SortedList有序列表

C# SortedList 类实现了 IDictionary 接口 ,
集合中的值都是以键值对的形式存取的。

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

namespace Csp个人课程备课.第十章集合
{
    class Test1105SortedList有序列表
    {
        static void Main() {
            //按照 key 值对集合中的元素排序
            SortedList sl = new SortedList();
            //添加元素
            sl.Add(1, "小张");
            sl.Add(2, "小李");
            sl.Add(3, "小刘");
            //集合中元素个数
            Console.WriteLine("集合ht的元素个数为:" + sl.Count);
            //判断集合中是否包含指定key的元素
            Console.WriteLine("集合中是否包含key为4的元素:" + sl.ContainsKey(1));
            //获取键值
            foreach (DictionaryEntry e in sl)
            {
                Console.Write(e.Key + "," + e.Value + " ");
            }
            Console.WriteLine("");
        }
    }
}

六.泛型

用来规定类型,统一类型

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

namespace Csp个人课程备课.第十章集合
{
    class Test1105SortedList有序列表
    {
        static void Main() {
            //按照 key 值对集合中的元素排序
            SortedList sl = new SortedList();
            //添加元素
            sl.Add(1, "小张");
            sl.Add(2, "小李");
            sl.Add(3, "小刘");
            //集合中元素个数
            Console.WriteLine("集合ht的元素个数为:" + sl.Count);
            //判断集合中是否包含指定key的元素
            Console.WriteLine("集合中是否包含key为4的元素:" + sl.ContainsKey(1));
            //获取键值
            foreach (DictionaryEntry e in sl)
            {
                Console.Write(e.Key + "," + e.Value + " ");
            }
            Console.WriteLine("");
        }
    }
}

第十二章:Windows窗体应用程序（WinForm程序）

WinForm 是 Windows Form 的简称，是基于 .NET Framework 平台的客户端（PC软件）开发技术，
一般使用 C# 编程。C# WinForm 编程需要创建「Windows窗体应用程序」项目。

一.创建WinForm程序

在 Visual Studio 2019 软件中，创建新项目 选择Windows窗体应用程序

项目创建成功后会有一个Form1.cs的默认窗体程序
还会生成一个Program.cs的代码文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsForms1
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]//特性：指示COM线程是单线程，如果没有它，是无法工作的
        static void Main()
        {
        	//启动应用程序中可视的样式
            Application.EnableVisualStyles();
            //在应用程序范围制内设置控件显示文本的默认方式
            //(可以设为使zhi用新的GDI+,还是旧的GDI)，
            //true使用daoGDI+方式显示文本,false使用GDI方式显示文本。
            Application.SetCompatibleTextRenderingDefault(false);
            //启动的窗体
            Application.Run(new Form1());
        }
    }
}

程序中默认的控件都在工具箱中,工具箱在菜单 视图-工具箱中
(注意要在Form1.cs应用程序打开的情况下才可以看到)

1、WinForm应用程序 项目层次结构
一个解决方案下可以包含一个或者多个项目
Properties：属性文件
引用：添加引用，提供应用程序所需要的类库
App.config：默认是xml格式，可以配置字符串相关信息
窗体文件：3个
Programe.cs：程序入口
2、解决方案文件夹
FirstWinForm.sln解决方案的文件夹，提供位置应用
bin：存放项目的编译结果Debug（调试、慢）release（发布、快）
obj：编译过程中生成的中间临时文件，加快编译速度
Properties：自动生成的配置文件
App.config
FirstWinForm.csproj:项目文件夹 位置引用 直接双击可以打开项目
.cs:窗体的源代码
Demo2.Designer.cs:窗体布局代码 自动生成控件的代码
Demo1.resx：窗体的资源文件

二.控件

简介：输入或操作的对象
控件三要素：
	属性：控制外观
	方法：控件可用的一些功能
	事件：控件相应的行为
特征：
	可视化的，可以通过控件与用户进行交互，暴露了属性、方法和事件，
	可供开发人员使用，可发布和重用

控件的开发：
	1、复合控件：将各种控件组合起来，形成一种控件
	2、扩展控件：在现有的控件上派生出一个新的控件（为原有控件增加新的功能）
	3、自定义控件：从control类中派生的，提供入门的性能

控件分类
一般控件：
	lable 标签
	TextBox 文本框
	Button 按钮
	RadioButton 单选按钮
	CheckBox 复选框
	ComBox 下拉选
	CheckedListBox 带复选框的列表项
	DateTimePicker日期时间选择控件
	ListBox 列表框
	ListView 以五种不同的视图显示项的集合
	MaskedTextBox 格式化文本框
	MonthCalender 月历
	NumberricUpDown 可以增减数值的显示框PictureBox 图像控件
	ProgressBar 进度条
	RichText 高级文本框
	TreeView 树形控件
 
容器控件：一般用于设置业面的布局
	GroupBox：分组控件，可以设置标题
	Panel 分组控件，可以显示滚动条
	TabControl：选项卡控件
	SplitContainer：面板控件

数据控件：
	DATaGridView：数据显示
	DataSet：内存缓存（报表）

菜单和工具控件：
	菜单：
		ContextMenuStrip：右键菜单
		MenuSrip：菜单栏
	工具栏：
		ToolStrip：工具栏
		StatusStrip：状态栏

组件控件：
	Timer：计时器
	ImageList：图像集合

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace FirstWinForm
{
    public partial class demo2 : Form
    {
        public demo2()
        {
            InitializeComponent();
        }

        private void textNum1_TextChanged(object sender, EventArgs e)
        {
            
        }

        private void jisuan_Click(object sender, EventArgs e)
        {
        	//获取文本内容
            String num1 = textNum1.Text;
            String num2 = textNum2.Text;
            String fuhao = result.Text;
            //计算和并显示
            String input = num1+fuhao+num2;
            MessageBox.Show(input+"="+new DataTable().Compute(input, "").ToString());
        }

        private void clear_Click(object sender, EventArgs e)
        {
        	//将文本框中对的内容设置为空
            textNum1.Text = "";
            textNum2.Text = "";
            result.Text = "";
        }
    }
}

第十三章:进程与线程

程序: 就是存储在物理介质中一段可执行的代码片段
进程: 一个程序执行了,就开启了一个进程
线程: 一个程序中有多个线索每一个线索就是一个线程

CPU在同一时间里只能执行一个线程

多线程
	在宏观上是多线程并发执行的
	在微观上是多线程交替执行的

一.Process进程类

所在的命名空间是 System.Diagnostics
常用属性或方法如图:

右击项目创建窗体应用程序:

拖入所需组建(一个Button一个RichTextBox)

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsForms1
{
    public partial class 查看所有进程 : Form
    {
        public 查看所有进程()
        {
            InitializeComponent();
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            //获取所有运行的进程的信息GetProcesses()方法
            Process[] processes = Process.GetProcesses();
            foreach (Process p in processes)//遍历
            {   //获取每一条进程信息的名字赋值给文本
                richTextBox1.Text = richTextBox1.Text + p.ProcessName + "\r\n";
            }
        }

        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {

        }
    }
}

启动进程
创建一个新的窗体应用程序做一个启动进程的程序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Csp个人课程备课.第十三章线程
{
    class Test1301创建线程
    {
        static void Main() {
            ThreadStart ts = new ThreadStart(Show);
            Thread t = new Thread(ts);
            t.Start();//启动线程
        }
        //定义打印1~10的方法
        private static void Show()
        {
            for (int i = 1; i <= 10; i++)
            {
                //线程睡眠(毫秒)
                Thread.Sleep(1000);//一秒打一个
                Console.WriteLine(i);
            }
        }
    }
}

二.Thread线程

System.Threading 命名空间中
与线程有关的属性或方法如下:

1.ThreadStart 创建线程

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Csp个人课程备课.第十三章线程
{
    class Test1301创建线程
    {
        static void Main() {
            ThreadStart ts = new ThreadStart(Show);
            Thread t = new Thread(ts);
            t.Start();//启动线程
        }
        //定义打印1~10的方法
        private static void Show()
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine(i);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Csp个人课程备课.第十三章线程
{
    class 创建线程2
    {
        static void Main(string[] args)
        {
            ParameterizedThreadStart pts = new ParameterizedThreadStart(Show);
            Thread t = new Thread(pts);
            t.Start(10);
        }
        //打印1~n  方法参数只能是对象类型
        private static void Show(Object n)
        {
            for (int i = 0; i <= (int)n; i++)
            {
                Console.WriteLine(i);
            }
        }
    }
}

三.Priority线程优先级

低到高分别为Lowest、BelowNormal、Normal、AboveNormal、Highest。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Csp个人课程备课.第十三章线程
{
    class Test1303线程优先级
    {
        static void Main(string[] args)
        {
            ThreadStart ts1 = new ThreadStart(Show1);
            Thread t1 = new Thread(ts1);
            //设置打印偶数线程的优先级
            t1.Priority = ThreadPriority.Lowest;
            ThreadStart ts2 = new ThreadStart(Show2);
            Thread t2 = new Thread(ts2);
            //设置打印奇数线程的优先级
            t2.Priority = ThreadPriority.Highest;
            t1.Start();
            t2.Start();
        }
        //打印1~100
        public static void Show1()
        {
            for (int i = 1; i <= 100; i++)
            {
                Console.WriteLine(i);
            }
        }
        //打印a~z
        public static void Show2()
        {
            for (char i = 'a'; i <= 'z'; i++)
            {
                Console.WriteLine(i);
            }
        }
    }
}

四.lock线程锁

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Csp个人课程备课.第十三章线程
{
    class Test1304线程锁
    {
        static void Main(string[] args)
        {
            Test1304线程锁 t = new Test1304线程锁();
            ThreadStart ts1 = new ThreadStart(t.Show1);
            Thread t1 = new Thread(ts1);
            ThreadStart ts2 = new ThreadStart(t.Show2);
            Thread t2 = new Thread(ts2);
            t1.Start();
            t2.Start();
        }
        //打印1~100
        public void Show1()
        {
            lock (this) //加锁保证执行完在执行其他的线程内容
            {
                for (int i = 1; i <= 100; i++)
                {
                    Console.WriteLine(i);
                }
            }
        }
        //打印a~z
        public void Show2()
        {
            lock (this)
            {
                for (char i = 'a'; i <= 'z'; i++)
                {
                    Console.WriteLine(i);
                }
            }
        }
    }

}

五.Mutex

WaitOne() 方法用于等待资源被释放， ReleaseMutex() 方法用于释放资源

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

namespace Csp个人课程备课.第十三章线程
{
    class Test1305互斥锁
    {
        static void Main(string[] args)
        {
            Test1305互斥锁 t = new Test1305互斥锁();
            ThreadStart ts1 = new ThreadStart(t.Show1);
            Thread t1 = new Thread(ts1);
            ThreadStart ts2 = new ThreadStart(t.Show2);
            Thread t2 = new Thread(ts2);
            t1.Start();
            t2.Start();
        }
        private static Mutex m = new Mutex();
        //打印1~100
        public void Show1()
        {
            for (int i = 1; i <= 26; i++)
            {
                Console.WriteLine(i);
                Thread.Sleep(100);
                try {
                    m.WaitOne();//等待资源被释放
                    m.ReleaseMutex();//释放资源
                } catch(Exception e) { 
                
                }
            }
        }
        //打印a~z
        public void Show2()
        {
            for (char i = 'a'; i <= 'z'; i++)
            {
                Console.WriteLine(i);
                Thread.Sleep(100);
                try
                {
                    m.ReleaseMutex();//释放资源
                    m.WaitOne();//等待资源被释放
                }
                catch (Exception e)
                {

                }
            }
        }
    }
}