12表达式的概念

表达式由操作数和运算符构成。运算符的示例包括+ - * /和new。操作数单位示例包括文本、字段、局部变量和表达式。

C#运算符

13作用域简介

变量名不能重复，不管什么类型

在一个大括号内，必须声明变量以后才能使用
可以声明一个变量在整个类内使用，但是如果在方法内声明了同一个名称的变量，那么在整个方法内，在这个变量声明之后才能使用。

14自增-自减

++x
x++
统称为自增量
—x
x—
统称为自减量

  1. int x = 1;
  2. MessageBox.Show(x.ToString());   
  3. MessageBox.Show((++x).ToString());    
  4. MessageBox.Show((--x).ToString());
  5. MessageBox.Show((x++).ToString());
  6. MessageBox.Show(x.ToString());
  7. MessageBox.Show((x--).ToString());
  8. MessageBox.Show(x.ToString());

输出：
1
2
1
1
2
2
1

15-20四则运算-取余、字符串也有加法运算、判断相等、字符串比较、且或运用、三元-复合赋值-非运算

四则运算-取余

image.png

字符串也有加法运算

image.png
字符串会拼接在一起

判断相等

  1.             bool b;
  2.             b = 1 > 2;
  3.             MessageBox.Show(b.ToString());
  4.             b = 2 == 1;
  5.             MessageBox.Show(b.ToString());
  6.             b = 2 != 1;
  7.             MessageBox.Show(b.ToString());

输出：
false
false
true

字符串比较

  1.             bool b;
  2.             b = "hello" == "world";
  3.             MessageBox.Show(b.ToString());
  4.             b = "hello" != "world";
  5.             MessageBox.Show(b.ToString());

输出：
false
true

且或运用

  1.             bool b;
  2.             bool b1 = true, b2 = false, b3 = true, b4 = false;
  3.             b = b1 && b2;
  4.             MessageBox.Show(b.ToString());
  5.             b = b1 || b2;
  6.             MessageBox.Show(b.ToString());
  7.             b = b1 && b3;
  8.             MessageBox.Show(b.ToString());
  9.             b = b2 || b4;
  10.             MessageBox.Show(b.ToString());

x && y 仅当x为true时，才对y求值
x || y 仅当x为false时，才对y求值
输出：
false
true
true
false

  1.             string s1, s2, s3;
  2.             s1 = null;
  3.             s2 = "hello";
  4.             s3 = s1 ?? s2;
  5.             MessageBox.Show(s3);

s1 ?? s2：如果s1为null则结果为s2,否则结算结果为s1。
输出：
hello

  1.             string s1, s2, s3;
  2.             s1 = "world";
  3.             s2 = "hello";
  4.             s3 = s1 ?? s2;
  5.             MessageBox.Show(s3);

输出：
world

三元-复合赋值-非运算

x?y:z 如果x为true，对y求值；如果x为false则对z求值;

  1.             string x = "a", y = "hello", z = "world",m;
  2.             m = x == "a" ? y : z;
  3.             MessageBox.Show(m);
  4.             m = x == "b" ? y : z;
  5.             MessageBox.Show(m);

输出：
hello
world

  1.             int i = 1,j=2;
  2.             i = i +j;
  3.             MessageBox.Show(i.ToString());

输出：
3

  1.             bool b = true;
  2.             MessageBox.Show((!b).ToString());
  3.             string x = "西瓜";
  4.             MessageBox.Show((!(x == "西瓜")).ToString());

输出：
false
false

21-24分支语句（条件语句）和循环语句

分支语句

  1. //if语句
  2. if(i > 1){
  3. }
  5. //if-else语句
  6. int i = 1;
  7. if (i == 0)
  8. {
  9.     MessageBox.Show("i确实是0啊！");
  10. }
  11. else if(i>0 && i < 2)
  12. {
  13.     MessageBox.Show("i在1到2之间");
  14. }
  15. else
  16. {
  17.     MessageBox.Show("i不是0！");
  18. }
  1. //switch语句
  2. int i = 3;
  3. switch (i)
  4. {
  5.     case 1:
  6.         MessageBox.Show("这是1号门");
  7.         break;
  8.     case 2:
  9.         MessageBox.Show("这是2号门");
  10.         break;
  11.     case 3:
  12.         MessageBox.Show("这是3号门");
  13.         break;
  14.     default:
  15.         MessageBox.Show("你全都对不上");
  16.         break; 
  17. }

循环语句

  1. //for，注意按tab键位可以自动生成对应基础循环代码
  2. for (int i = 0; i < 5; i++)
  3. {
  4.     MessageBox.Show($"这是第{i+1}次循环,此时i为{i}");
  5. }
  7. //while循环
  8.  int i = 1;
  9. while (i < 5)
  10. {
  11.     MessageBox.Show($"这是第{i}次循环，此时i为{i}");
  12.     i++;
  13. }
  14. i = 1;
  16. //do-while循环
  17. do
  18. {
  19.     MessageBox.Show($"这是第{i}次循环，此时i为{i}");
  20.     i++;
  21. }
  22. while (i < 5);

25数组

  • 数组是一组相同类型的数据
  • 数组中的数据需要通过数字索引来访问

  • Array类

    数组的声明

  • 数组的声明需要使用 new 关键字。

  • 在声明数组时，可以使用{}来初始化数组中的元素。
  • 如果在数组声明之初没有使用大括号来初始化数组中的元素，则需要指定数组的大小。
  • 在声明初始化有元素的数组时，也可以指定数组的大小。 ```csharp //声明没有元素的数组 int[] ints = new int[6]; //注意当没有给数组赋值的时候，数组内的值默认为0

//声明初始化有元素的数组 int[] jnts = new int[] { 1, 3, 4, 5 }; //在声明初始化有元素的数组时，也可以指定数组的大小 //这种情况可以在大括号中给数组赋予任意数量的值

string[] strings = new string[5]{“H”,”E”,”L”,”L”,”O”}; //注意中括号有数组大小的时候，后面给数组赋值的数量不能超过这个

var strings = new string[] { “1”, “2”, “3”, “4” };

  1. <a name="lnhZX"></a>
  2. ## 通过索引获取数组中的元素
  4. - 给数组指定长度时，数组准备存放多少元素，长度就设置为多少。
  5. - 用索引获取数组内的元素时，索引从0开始获取。
  6. - 所以数组中的最大的索引数字，比指定数组长度小1。
  7. ```csharp
  8. int[] ints = new int[] { 1, 3, 4, 5 };
  9. int i1 = ints[0];
  10. ints[0] = 5;
  11. i1 = ints[0];

获取数组信息

  1. int[,] i = new int[4,5];
  2. Console.WriteLine(i.Length);
  3. //获取元素总数
  4. Console.WriteLine(i.Rank);
  5. //获取数组维数
  6. Console.WriteLine(i.GetLength(0));
  7. //获取指定维数中的元素数
  8. Console.WriteLine(i.GetUpperBound(0));
  9. //获取数组中指定维度最后一个元素的索引
  10. Console.WriteLine(i.GetUpperBound(1));
  11. Console.WriteLine(i.GetLowerBound(0));

清空数组

  1. string[] str = new string[2];
  2. for (int i = 0; i < str.Length; i++)
  3.     str[i] = i.ToString();
  4. Array.Clear(str, 0, str.Length);
  5. for (int i = 0; i < str.Length; i++)
  6.     Console.WriteLine(string.IsNullOrEmpty(str[i]) ? "null" : str[i]);
  7. //输出结果:
  8. //null
  9. //null

初始化数组

  1. //只是用于初始化,如果数组子项已经被初始化,那么不会改变它的值.
  2. //(删除下面代码 x[1] = 6; 试试)
  3. int[] x = new int[2];
  4. int[] y = new int[2];
  5. x[0] = 5; x[1] = 6;
  6. x.Initialize();
  7. y.Initialize();
  8. for (int i = 0; i < x.Length; i++)
  9.     Console.WriteLine("x:{0}  y:{1}", x[i], y[i]);
  10. //输出结果:
  11. //x:5   y:0
  12. //x:6   y:0

动态修改数组大小

  1. //处理流程是:先创建一个新的数组,然后把旧数组赋值过去.
  2. int[] x = new int[2];
  3. x[0] = 5; x[1] = 6;
  4. Array.Resize(ref x, x.Length + 2);
  5. for (int i = 0; i < x.Length; i++)
  6.     Console.WriteLine("x[{0}]={1}",i, x[i]);
  7. //输出结果:
  8. //x[0]=5
  9. //x[1]=6
  10. //x[2]=0
  11. //x[3]=0

如果数组较大,性能影响明显,建议用List<>的AddRange方法. [去MSDN查看].aspx)

  1. List<int> lst = new List<int>();
  2. lst.Add(3); lst.Add(4);
  3. int[] x = new int[2];
  4. x[0] = 5; x[1] = 6;
  5. lst.AddRange(x);
  6. for (int i = 0; i < lst.Count; i++)
  7.     Console.WriteLine("lst[{0}]={1}", i, lst[i]);
  8. //输出结果:
  9. //lst[0]=3
  10. //lst[1]=4
  11. //lst[2]=5
  12. //lst[3]=6

关于Array数组复制拷贝,倒叙,排序等,详情参见MSDN.aspx)

26-27总结提升-案例1

image.png

  1. double price = 1.9;//每斤单价
  2. int count = 6;//购买数量
  3. double discount = 0.75;//折扣
  4. double totalprice;//存放总价的变量
  5. //计算折扣前总价
  6. totalprice = price* count;
  7. //判断总价有没有超过10元
  8. if (totalprice >10)
  9. {
  10.     //超过10元折价处理
  11.     totalprice = totalprice * discount;
  12.     //复合赋值
  13. }
  14. MessageBox.Show(totalprice.ToString());
  1. double d = totalprice / 10;
  2. //隐式转换
  4. //显示强制转换，不遵循四舍五入，只截取整数部分,如(int)5.21输出5
  5. //Int.Parse()：只支持将string类型转成int,Parse就是把string类型转换成int,char,double....等
  6. //也就是*.Parse(string)括号中一定要是string类型。
  8. string st = "5.21";
  9. double n = 5.21;
  10. int.Parse(st);//输出5
  11. int.Parse(n);//报错
  12. //而且只能是数字，才能转换成int类型。
  14. //Convert.ToInt32(double value),不完全遵循四舍五入
  15. //如果value为两个整数中间的数字，则返回二者中的偶数。
  16. Console.WriteLine(Convert.ToInt32(4.3));//四舍五入，输出4
  17. Console.WriteLine(Convert.ToInt32(4.5));//4.5为4和5中间的数字，所以输出5
  18. Console.WriteLine(Convert.ToInt32(4.53));//四舍五入，输出5
  20. Console.WriteLine(Convert.ToInt32(5.3));//5
  21. Console.WriteLine(Convert.ToInt32(5.5));//6
  22. Console.WriteLine(Convert.ToInt32(5.53));//6
  24. //注意，convert.toint32()和int.parse()对于空值(null)的处理不同
  25. //convert.toint32(null)会返回0而不会产生任何异常
  26. //但是,int.parse(null)则会产生异常

  • 如果题中要求满几个10元，就在几个10元上打7.5折该如何计算？

    1. double price = 1.9;//每斤单价
    2. int count = 16;//购买数量
    3. double discount = 0.75;//折扣
    4. double totalprice;//存放总价的变量
    5. //计算折扣前总价
    6. totalprice = price* count;
    7. int d = (int)(totalprice / 10);
    8. double totalten = 0;
    9. for(int i = 0; i < d; i++)
    10. {
    11.   totalten =totalten+10*discount;
    12. }
    13. double y = totalprice % 10;
    14. totalprice = totalten + y;
    15. MessageBox.Show(totalprice.ToString());

    28-30案例2

    ctrl+K+C快捷键快速注释代码
    image.png

    1. //for循环
    2. string[] strings = new string[] { "张三", "李四", "王五",
    3.                                "赵六", "田七", "周八" };
    4. int stringscount = strings.Length;
    5. //获取数组长度
    6. for (int i = 0; i < stringscount; i++)
    7. {
    8.   if (strings[i] == "赵六")
    9.   {
    10.       continue;//continue可以直接执行下一个循环
    11.       Console.WriteLine("找到了" + strings[i] + "送她回家," + strings[i] + $"是第{i + 1}位同学");
    12.       break;//退出循环
    13.   }
    14. }
    1. //while循环
    2. string[] strings = {"张三","李四","王五",
    3.                   "赵六","田七","周八"};
    4. int i = 0;
    5. string studnet = "";
    6. bool isfind = true;
    7. while (studnet != "赵六")
    8. {
    9.   if (i >= strings.Length)
    10.   {
    11.       Console.WriteLine("没有找到人");
    12.       isfind = false;
    13.       break;
    14.   }
    15.   studnet = strings[i++];
    16. }
    17. if (isfind) Console.WriteLine("找到了" + studnet + ",送她回家");

    31-34函数初识

    函数的命名规范

  • 函数命名使用大驼峰命名，即首字母大写。

  • 多个单词拼接时，所有单词首字母大写。

函数的参数设置&传参行为

  • 参数可认为是外部需要函数 帮忙处理的数据 。

  • 外部通过传递参数的形式，将需要处理的数据交给函数处理。

    函数返回值的设置

  • 函数返回值可以认为是外部调用某种行为后得到的一种反馈

    1. private void Form1_Load(object sender, EventArgs e)
    2. {
    3.   SendMessage("你好，好久不见？");
    4. }
    5. public void SendMessage(string message)
    6. {
    7.   MessageBox.Show(message);
    8.   //注意定义什么类型就只能传递什么类型的参数
    9.   //如果传递的数值是1就会出错
    10. }
    1. private void Form1_Load(object sender, EventArgs e)
    2. {
    3.   string res = SellHouse(100, 10000);
    4.   MessageBox.Show(res);
    5. }    
    6. public string SellHouse(int area,int price)
    7. {//string表示返回的值的类型
    8.   return "张三想买这套房，愿意出价" + (area*price- 1) + "万";
    9. }

    参数修饰符

    image.png ```csharp private void Form1_Load(object sender, EventArgs e) { string message = “你好李四！”; SendMessage(out message); MessageBox.Show(message); } public void SendMessage(out string message) { message = “好久不见，你还好吗”; MessageBox.Show(message); }

//与无修饰符不同，out可以返回多个值 //out的变量必须在对应方法内给它赋初值，不然会出错。 //而且就算之前给对应变量赋初值，不在对应方法内赋值也会出错。 private void Form1_Load(object sender, EventArgs e) { string res = SellHouse(100, 10000, out string wantprice); MessageBox.Show(res); MessageBox.Show(wantprice); } public string SellHouse(int area,int price,out string wantprice) { wantprice = “愿意出价” + (area * price - 1); return “张三想买这套房”; }

  2. <a name="qjaic"></a>
  3. ## 封装案例一
  4. ```csharp
  5. private void Form1_Load(object sender, EventArgs e)
  6. {
  7.     double totalprice = Buy(1.9, 16, 0.75);
  8.     MessageBox.Show(totalprice.ToString());
  9. }
  10. public double Buy(double price, int count, double discount)
  11. {
  12.     double totalprice;
  13.     totalprice = price * count;
  14.     int d = (int)(totalprice / 10);
  15.     double totalten = 0;
  16.     for (int i = 0; i < d; i++)
  17.     {
  18.         totalten = totalten + 10 * discount;
  19.     }
  20.     double y = totalprice % 10;
  21.     totalprice = totalten + y;
  22.     return totalprice;
  23. }

36-39类和对象

面对对象编程-Object Orient Programming 简写OOP
类和对象是面向对象编程的两个核心概念。

类是对一群具有相同特征或者行为的事物的一个统称，是抽象的。不能直接使用

  • 特征被称为属性
  • 行为被称为方法

类就相当于制造汽车的图纸，是一个模板，是负责创建对象的

对象是由类创造出来的一个具体存在，可以直接使用
由哪一个类创造出来的对象，就拥有在哪一个类中定义的属性和方法
对象就相当于用图纸制造汽车

类是模板，对象是根据类这个模板创建出来的，先有类后有对象
类只有一个，而对象可以有很多个
不同对象之间属性的具体内容可能各不相同
类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

类的设计

  • 类名 这类事物的名称，满足大驼峰命名法
  • 属性
  • 方法

类名的确定：名词提炼法 分析整个业务流程，出现的名词，通常就是找到的类

类和对象的使用

声明类

  1. //右键当前项目——添加,加一个public修饰符
  2. public class person
  3. {
  5. }

声明属性

  • 依旧遵循大驼峰命名法
  • 最常用的书写方法：public int age {get;set;}
  • get关键字，说明可以获取该属性的值。

  • set关键字，说明可以向该属性设置值

    1. public class person
    2. {
    3.   public string Name { get; set; }
    4.   public int Age{ get; set; }
    5.   public int Height{ get; set; }
    7.   public void Eat()
    8.   {
    9.       MessageBox.Show("11");
    10.   }
    11.   public void Run()
    12.   {
    13.       MessageBox.Show("12");
    14.   }
    15. }

    声明方法

    详见函数初识

    实例化

  • 类使用关键字new实例化对象

  • 一个类可以实例化多个对象
  • 对象可以使用类定义的属性和方法 ```csharp new person(); new person().Eat();

//string person = new person(); //因为string也是一个类型，C#中万物皆对象，对象都是有一个类型的，所以string本身就是一个类型 //string可以接受string类型的字符串，所以要接受person类型要用person类型 person zhangsan = new person(); zhangsan.Eat(); zhangsan.Name = “张三”; zhangsan.Run(); zhangsan.Age = 18; zhangsan.Height = 175;

person wangwu = new person() { Age = 18, Height = 170, Name = “张三” }; wangwu.Eat(); wangwu.Run();

  2. <a name="pDcgI"></a>
  3. ## 拓展
  5. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/1315822/1588505873605-14cc1df0-4912-4d93-9a67-21036297a623.png#align=left&display=inline&height=491&margin=%5Bobject%20Object%5D&name=image.png&originHeight=491&originWidth=465&size=162682&status=done&style=none&width=465)```csharp
  6. //新类中
  7. public static string ID { set; get; }
  8. public string mess { get; set; }
  9. //原类中调用静态属性或方法
  10. person.ID = "1234";
  12. /*public void  static Run()
  13. {
  14.     //静态方法中只能使用静态字段
  15.     MessageBox.Show(mess + "12");
  16. }*/
  17. public void  static Run()
  18. {
  19.     //静态方法中只能使用静态字段
  20.     MessageBox.Show(ID + "12");
  21. }
  23. //另外一个类中
  24. person.ID = "你好呀";
  25. person.Run();

40-45数组&字典

ArrayList

  1. using System.Collections;
  3. ArrayList arraylist = new ArrayList();
  4. //将数据新增到结尾处
  5. arraylist.Add("abc");
  6. arraylist.Add(123);
  7. //改数据
  8. arraylist[2] = 345;
  9. //移除指定索引数据
  10. arraylist.RemoveAt(0);
  11. //移除指定数据
  12. arraylist.Remove(123);
  13. //指定位置插入数据
  14. arraylist.Insert(0, "hello world");

ArrayList劣势

  • 在存储数据时使用object类型进行存储的。
  • 不是类型安全的，使用时很可能出现类型不匹配的错误。
  • 就算都有插入了同一类型的数据，但在使用的时候，我们也需要将他们转化为对应的原类型来处理。
  • 存储存在装箱和拆箱操作，导致其性能低下
    1. //装箱
    2. int 1 - 123;
    3. object o = i;
    4. //拆箱
    5. object o = 123;
    6. int i = (int)o;
    正是因为ArrayList存在不安全类型与装箱拆箱的缺点，所以在C#2.0后出现了泛型的概念。
    泛型：限制集合只能够存储单一类型数据的一种手段

    List

    ```csharp List intlist = new List(); //list集合中的中括号表明必须给list集合指明数据类型 int[] ints = new int[5]; //数组中的中括号是表明必须给数组指定长度

intlist.Add(123); intlist[0] = 345; //注意当集合的大小没有那么大的时候，超出范围的赋值会出错 intlist.RemoveAt(0); intlist.Remove(123); intlist.Insert(0, 6668); intlist.Clear();

//可加可不加小括号 List list = new List { 1, 2, 3, };

List lists = new List { 1,2,3, };

  1. <a name="62VJP"></a>
  2. ## List-自定义类型
  3. ```csharp
  4. class NewClass
  5. {
  6.     public int Age { get; set; }
  7.     public int Height { get; set; }
  8.     public string Name { get; set; }
  9. }
  12. List<Person> people = new List<Person>();
  13. Person person1= new Person()
  14. {
  15.     Age = 18,
  16.     Height = 175,
  17.     Name = "张三"
  18.     };
  19. people.Add(person1);
  21. people.Add(new Person
  22.             {
  23.                 Age = 18,
  24.                 Height = 179,
  25.                 Name = "李四"
  26.             });
  27. Person person2 = people[0];
  28. people.RemoveAt(0);
  29. people.Remove(person2);

字典

  • 在声明字典时，需要同时为其声明字典内键与值的类型。 ```csharp Dictionary dictionary = new Dictionary(); //键与值可以是任何类型，但是键必须在设置时是唯一的，而值可以不唯一 //就好比每个学生的学号必须必须是唯一的，而所有成绩可以不唯一

//两种赋值方式 //方式1：Add方法赋值 dictionary.Add(1, “98分”); dictionary.Add(2, “92分”); dictionary.Add(3, “89分”); dictionary.Add(1, “88分”);//系统会报错 //方法二：索引器赋值 dictionary[1] = “88分”;//系统不会报错 dictionary[4] = “99分”; //方法三：对象初始化器 Dictionary dictionary2 = new Dictionary() { {“A”,”aa” }, {“B”,”bb” }, {“C”,”cc” }, }; //注意dictionary[1]方式既可以赋新值也可以修改原来已键有的值 //类似于数组索引器的使用。所以可以使用之前已经使用过的键。但是Add方法不可以添加已有的键值。

//获取键值为1的值 //方法1：索引器取值 string value = dictionary[1]; //方法2：foreach遍历 foreach (KeyValuePair item in dictionary) { string values = item.Value; } //移除键为1的键值对 dictionary.Remove(1);

  2. - 键与值可以是任何类型，但是键必须在设置时是唯一的，而值可以不唯一
  3. - 使用Add()方法添加键值对，不可添加已有的键名
  4. - 索引模式可以新赋值+也可以修改已有的键值
  5. <a name="mI9C2"></a>
  6. ## foreach的使用
  7. ```csharp
  8. int[] ints = { 1, 2, 3, 4, 5, 6, 7 };
  9. foreach (var item in ints)
  10. {
  11.     Console.WriteLine(item);
  12. }
  14. List<int> intlist = new List<int> { 1, 2, 3, 4, 5 };
  15. foreach (var item in intlist)
  16. {
  17.     Console.WriteLine(item);
  18. }
  20. Dictionary<string, string> dictionary2 = new Dictionary<string, string>()
  21. {
  22.     {"A","aa" },
  23.     {"B","bb" },
  24.     {"C","cc" },
  25. };
  26. foreach (KeyValuePair<string, string> item in dictionary2)
  27. {
  28.     string key = item.Key;
  29.     string value = item.Value;
  30. }
  1. //新类中
  2. class Person
  3. {
  4.     public int Age { get; set; }
  5.     public string Name { get; set; }
  6.     public List<Person> GetUserList()
  7.     {
  8.         List<Person> personList = new List<Person>();
  9.         personList.Add(new Person
  10.                        {
  11.                            Age = 1,
  12.                            Name = "A"
  13.                            }) ;
  14.         personList.Add(new Person
  15.                        {
  16.                            Age = 2,
  17.                            Name = "B"
  18.                            });
  19.         personList.Add(new Person
  20.                        {
  21.                            Age = 3,
  22.                            Name = "C"
  23.                            });
  24.         personList.Add(new Person
  25.                        {
  26.                            Age = 4,
  27.                            Name = "D"
  28.                            });
  29.         return personList;
  30.     }
  32. }
  34. //项目中
  35. Person person = new Person();
  36. List<Person> personList =person.GetUserList();
  37. foreach (Person item in personList)
  38. {
  39.     Console.WriteLine(item.Name+"的年龄是："+item.Age);
  40. }