C#和.Ne学习第六天

摘要: （主要是传智播客的赵剑宇老师上课的笔记自己在加上一点自己的理解，在此感谢赵剑宇老师）

1、变量类型
int double string char bool decimal
变量的使用规则：先声明再赋值最后使用

int number;
number=10;
number=20;
Console.WriteLine(number);

2、Camel Pascal

Camel：

主要用于变量的命名

骆驼式命名法就是当变量名或函式名是由一个或多个单词连结在一起，而构成的唯一识别字时，第一个单词以小写字母开始；第二个单词的首字母大写或每一个单词的首字母都采用大写字母，例如：myFirstName、myLastName，这样的变量名看上去就像骆驼峰一样此起彼伏，故得名。

Pascal：

主要用于函数和方法类的命名

单字之间不以空格断开或连接号（-）、底线（_）连结，第一个单字首字母采用大写字母；后续单字的首字母亦用大写字母，例如：FirstName、LastName。每一个单字的首字母都采用大写字母的命名格式，被称为“Pascal命名法”，源自于Pascal语言的命名惯例，也有人称之为“大驼峰式命名法”（Upper Camel Case），为驼峰式大小写的子集。

3、运算符
赋值运算符：=
复合赋值运算符：+= -= *= /= %= sum+=age; sum=sum+age;
算数运算符： + - * / % ++ --
关系运算符： > < >= <= == !=
逻辑运算符： && || !

4、c#中的语法结构
分支结构：
if if-else
选择结构：
while do-while for

5、常量
声明的常量的语法：
const 变量类型 变量名=值;
什么时候会用到常量？

6、枚举
语法：
[public] enum 枚举名
{
值1,
值2,
值3,
........
}
public:访问修饰符。公开的公共的，哪都可以访问。
enum：关键字，声明枚举的关键字
枚举名：要符合Pascal命名规范

将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用这个枚举。

枚举就是一个变量类型 ，int--double string decimal.
只是枚举声明、赋值、使用的方式跟那些普通的变量类型不一样。

我们可以将一个枚举类型的变量跟int类型和string类型互相转换。
枚举类型默认是跟int类型相互兼容的，所以可以通过强制类型转换的语法互相转换。
当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来。

枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用ToString().
如果将字符串转换成枚举类型则需要下面这样一行代码：
(要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),"要转换的字符串");
如果转换的字符串是数字，则就算枚举中没有，也会不会抛异常。
如果转换的字符串是文本，如果枚举中没有，则会抛出异常。
实例：
public enum Gender
{
男,
女
}
使用：
Gender gender = Gender.男;
注意：最后一个枚举中的元素可以加,也可以不加

枚举类型转换

7、所有的类型都能够转换成string类型，调用ToString()。

8、结构
可以帮助我们一次性声明多个不同类型的变量。
语法：
[public] struct 结构名
{
成员;//字段
}
变量在程序运行期间只能存储一个值，而字段可以存储多个值。

字段前面加_线

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

namespace ConsoleApplication4
{
    class Program
    {
        public struct Color
        {
            public int _red;
            public int _green;
            public int _blue;
        }
        static void Main(string[] args)
        {
            Color color;
            color._red = 255;
            color._green = 0;
            color._blue = 0;

            Console.WriteLine("红:{0}绿:{1}蓝:{2}", color._red, color._green, color._blue);
            Console.ReadKey();
        }
    }
}

输出结果：
红:255绿:0蓝:0

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

namespace ConsoleApplication5
{
    struct Person
    {
        public string name;
        public Gender gender;
        public int age;
    }
    public enum Gender
    {
        男,
        女
    }
    class Program
    {
        static void Main(string[] args)
        {
            Person zsPerson;
            zsPerson.name = "张三";
            zsPerson.gender = Gender.男;
            zsPerson.age = 19;

            Person xlPerson;
            xlPerson.name = "小兰";
            xlPerson.gender = Gender.女;
            xlPerson.age = 16;

            Console.WriteLine("姓名:{0}性别:{1}年龄:{2}", zsPerson.name, zsPerson.gender, zsPerson.age);
            Console.WriteLine("姓名:{0}性别:{1}年龄:{2}", xlPerson.name, xlPerson.gender, xlPerson.age);
            Console.ReadKey();
        }
    }
}

输出结果：
姓名:张三性别:男年龄:19
姓名:小兰性别:女年龄:16

9、数组
一次性存储多个相同类型的变量。
语法：
数组类型[] 数组名=new 数组类型[数组长度];

***数组的长度一旦固定了，就不能再被改变了

10、冒泡排序：就是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。
int[] nums={9,8,7,6,5,4,3,2,1,0}; 0 1 2 3 4 5 6 7 8 9
第一趟比较：8 7 6 5 4 3 2 1 0 9 交换了9次 i=0 j=nums.Length-1-i
第二趟比较：7 6 5 4 3 2 1 0 8 9 交换了8次 i=1 j=nums.Length-1-i
第三趟比较：6 5 4 3 2 1 0 7 8 9 交换了7次 i=2 j=nums.Length-1-i
第四趟比较：5 4 3 2 1 0 6 7 8 9 交换了6次 i=3 j=nums.Length-1-i
第五趟比较：4 3 2 1 0 5 6 7 8 9 交换了5次
第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了4次
第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了3次
第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了2次
第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了1次

for(int i=0;i<number.Length-1;i++)
{
for(int j=0;j<nums.Length-1-i;j++)
{
if(nums[j]>nums[j+1])
{
int temp=nums[j];
nums[j]=nums[j+1];
nums[j+1]=temp;
}
}
}

int数组默认0
bool数组默认flase
string默认是null
数组的几种声明方式：

1、int []a = new int[10];
2、int []a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
3、int []a = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
4、int []a = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

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

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            int []a = {5, 21, 9, 2, 4, 8, 0, 11, 3, 6};


            for (int t = 0; t < a.Length; ++t)
            {
                Console.Write(a[t] + " ");
            }
            Console.WriteLine("\n");
            Console.WriteLine("数组最大值："+Program.ArrayMax(a));
            Console.WriteLine("数组最小值：" + Program.ArrayMin(a));
            Console.WriteLine("数组总和：" + Program.ArraySum(a));
            Console.WriteLine("数组平均值：" + Program.ArrayAverage(a));
            Console.ReadLine();
        }

        /// <summary>
        /// 计算整型数组的当中元素的最大值
        /// </summary>
        /// <param name="a">数组名</param>
        /// <returns>返回数组中最大的元素</returns>
        static int ArrayMax(int []a)
        {
            int Max = a[0];
            for (int t = 1; t < a.Length; ++t)
            {
                if (a[t] > Max)
                {
                    Max = a[t];
                }
            }
            return Max;
        }
        /// <summary>
        /// 计算整型数组的当中元素的最小值
        /// </summary>
        /// <param name="a">数组名</param>
        /// <returns></returns>
        static int ArrayMin(int []a)
        {
            int Min = a[0];
            for (int t = 1; t < a.Length; ++t)
            {
                if (a[t] < Min)
                {
                    Min = a[t];
                }
            }
                return Min;
        }
        /// <summary>
        /// 计算整型数组的总和
        /// </summary>
        /// <param name="a">数组名</param>
        /// <returns>返回数组的总和</returns>
        static int ArraySum(int []a)
        {
            int sum = 0;

            for (int t = 0; t < a.Length; ++t)
            {
                sum +=a[t];
            }

                return sum;
        }
        /// <summary>
        /// 计算整型数组的平均值
        /// </summary>
        /// <param name="a">数组名</param>
        /// <returns>返回这个数组的平均值</returns>
        static int ArrayAverage(int[] a)
        {
            int Max = ArraySum(a);
            return Max / a.Length;
        }
    }
}

输出结果：
5 21 9 2 4 8 0 11 3 6

数组最大值：21
数组最小值：0
数组总和：69
数组平均值：6

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

namespace ConsoleApplication8
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 5, 21, 9, 2, 4, 8, 0, 11, 3, 6 };


            for (int t = 0; t < a.Length; ++t)
            {
                Console.Write(a[t] + " ");
            }
            Console.WriteLine("\n");
            Console.WriteLine("数组总和：" + Program.ArraySum(a));
            Console.ReadLine();
        }
        /// <summary>
        /// 计算整型数组的总和
        /// </summary>
        /// <param name="a">数组名</param>
        /// <returns>返回数组的总和</returns>
        static int ArraySum(int[] a)
        {
            int sum = 0;

            for (int t = 0; t < a.Length; ++t)
            {
                sum += a[t];
            }

            return sum;
        }
    }
}

输出结果：
5 21 9 2 4 8 0 11 3 6

数组总和：69

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

namespace ConsoleApplication10
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] szName = new String[8];
            szName[0] = "老杨";
            szName[1] = "老苏";
            szName[2] = "老邹";
            szName[3] = "老虎";
            szName[4] = "老牛";
            szName[5] = "老蒋";
            szName[6] = "老王";
            szName[7] = "老马";

            for (int t = 0; t < szName.Length; ++t)
            {
                Console.Write(szName[t]+" ");
            }
            Console.WriteLine("\n");
            Console.ReadKey();
        }
    }
}

输出结果：
老杨 老苏 老邹 老虎 老牛 老蒋 老王 老马

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

namespace ConsoleApplication11
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 5, 21, 9, -2, 4, -8, 0, 11, -3, 6 };
            Program.ArrayOut(a);
            Console.Write("\n");
            Program.Dispose(a);
            Program.ArrayOut(a);
            Console.Write("\n");
            Console.ReadKey();
        }
        /*
         * 将一个整数数组的每一个元素进行如下的处理
         * 如果元素是正数則将这个位置的元素的值加1，
         * 如果元素是负数则将这个位置的元素值减1，
         * 如果元素是0，则不变
         */
        public static void Dispose(int[]a)
        {
            for (int t = 0; t < a.Length; ++t)
            {
                if (a[t] > 0)
                {
                    a[t] += 1;
                }
                else if (a[t] < 0)
                {
                    a[t] -= 1;
                }
                else
                {
                }
            }

                return;
        }
        public static void ArrayOut(int[] a)
        {
            for (int t = 0; t < a.Length; ++t)
            {
                Console.Write(a[t]+" ");
            }
                return;
        }
    }
}

输出结果：
5 21 9 -2 4 -8 0 11 -3 6
6 22 10 -3 5 -9 0 12 -4 7

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

namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        { 
            String []st = new String[3];
            st[0] = "我";
            st[1] = "是";
            st[2] = "好人";

            Program.ArrayStringOut(st);
            Console.Write("\n");

            Program.ArrayReverse(st);
            Program.ArrayStringOut(st);

            Console.Write("\n");
            Console.ReadLine();
        }

        /// <summary>
        /// 反转字符串数组
        /// </summary>
        /// <param name="st">要反转的字符串</param>
        static void ArrayReverse(String []st)
        {
            for (int i = 0, j = st.Length - 1; i != j; ++i, --j)
            {
                String t = st[i];
                st[i] = st[j];
                st[j] = t;
            }

            return;
        }
        /// <summary>
        /// 输出数组字符串
        /// </summary>
        /// <param name="st">要输出的字符串数组</param>
        static void ArrayStringOut(String []st)
        {
            for (int t = 0; t < st.Length; ++t)
            {
                Console.Write(st[t]);
            }

                return;
        }

    }
}

输出结果：
我是好人
好人是我

11、方法
函数就是将一堆代码进行重用的一种机制。
函数的语法：
[public] static 返回值类型 方法名([参数列表])
{
方法体；
}
public:访问修饰符，公开的，公共的，哪都可以访问。
static：静态的
返回值类型：如果不需要写返回值，写void
方法名：Pascal 每个单词的首字母都大些。其余字母小写
参数列表：完成这个方法所必须要提供给这个方法的条件。如果没有参数，小括号也不能省略。

方法写好后，如果想要被执行，必须要在Main()函数中调用。
方法的调用语法：
类名.方法名([参数]);
***在某些情况下，类名是可以省略的，如果你写的方法跟Main()函数同在一个类中，这个时候，
类名可以省略。

例：

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

namespace ConsoleApplication7
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = GetMax(3,6);
            Console.WriteLine(a);
            Console.ReadKey();
        }
        /// <summary>
        /// 计算两个int类型数的最大值
        /// </summary>
        /// <param name="n1">第一个整数</param>
        /// <param name="n2">第二个整数</param>
        /// <returns>返回两个数中的最大整数</returns>
        public static int GetMax(int n1, int n2)
        {
            return n1 > n2 ? n1 : n2;
        }
    }
}

12、return
1、在方法中返回要返回的值。
2、立即结束本次方法。

练习：方法判断是否是闰年

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("请输入要判断的年份：");
            try
            {
                int year = Convert.ToInt32(Console.ReadLine());
                if (Program.Year(year))
                {
                    Console.WriteLine("是闰年！");
                }
                else
                {
                    Console.WriteLine("不是闰年！");
                }
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }
        public static bool Year(int year)
        {
            bool b = (0==year%4&&0!=year%100)||0==year%400;

            return b;
        }
    }
}