C#基礎入門第六天（複雜數據類型）

總複習
1、變量類型
int double string char bool decimal float
變量的使用規則：先聲明再賦值最後使用
int number;
number=10;
number=20;
Console.WriteLine(number);
命名規範：Camel Pascal

2、運算符
賦值運算符：=
複合賦值運算符：+= -= = /= %= sum+=age; sum=sum+age;
算數運算符： + - / % ++ --
關係運算符： > < >= <= == !=
邏輯運算符： && || !

3、c#中的語法結構
分支結構：
if if-else
選擇結構：
while do-while for

第六天新內容
1、常量(不可被重複賦值)
聲明的常量的語法：
const 變量類型 變量名=值;
何時會用到常量？
如：收銀項目，折扣是不但願被別人改變的，因此這樣的須要用經常使用

2、枚舉
語法：
[public] enum 枚舉名
{
值1,
值2,
值3,
........
}
public:訪問修飾符。公開的公共的，哪均可以訪問。
enum：關鍵字，聲明枚舉的關鍵字
枚舉名：要符合Pascal命名規範

將枚舉聲明到命名空間的下面，類的外面，表示這個命名空間下，全部的類均可以使用這個枚舉。

枚舉就是一個變量類型 ，int--double string decimal.
只是枚舉聲明、賦值、使用的方式跟那些普通的變量類型不同。

咱們能夠將一個枚舉類型的變量跟int類型和string類型互相轉換。
枚舉類型默認是跟int類型相互兼容的，因此能夠經過強制類型轉換的語法互相轉換。
當轉換一個枚舉中沒有的值的時候，不會拋異常，而是直接將數字顯示出來。

枚舉一樣也能夠跟string類型互相轉換，若是將枚舉類型轉換成string類型，則直接調用ToString().
若是將字符串轉換成枚舉類型則須要下面這樣一行代碼：
(要轉換的枚舉類型)Enum.Parse(typeof(要轉換的枚舉類型),"要轉換的字符串");
若是轉換的字符串是數字，則就算枚舉中沒有，也會不會拋異常。
若是轉換的字符串是文本，若是枚舉中沒有，則會拋出異常。

重點：全部的類型都可以轉換成string類型，調用ToString()。

namespace _03枚舉類型和string以及int類型之間的轉換
 {
public enum QQState
{
    OnLine,
    OFFline,
    Leave=9,
    Busy,
    QMe
}
class Program
{
    static void Main(string[] args)
    {
        #region 將枚舉類型強轉成int類型
        QQState state = QQState.OnLine;
        //枚舉類型默承認以跟int類型相互轉換，枚舉類型跟Int類型是兼容的
        int n = (int)state;
        Console.WriteLine(0);
        Console.WriteLine((int)QQState.Leave);
        Console.ReadKey();
        #endregion

        #region 將int類型強轉成枚舉類型
        int n1 = 1;
        QQState state = (QQState)n1;
        Console.WriteLine(state);
        Console.ReadKey();
        #endregion

        #region 枚舉轉換string類型
        QQState state = QQState.OnLine;
        string s = state.ToString();
        Console.WriteLine(s);
        Console.ReadKey();
        #endregion

        #region 將字符串轉換爲枚舉類型
        string s = "OnLine";
        //將s轉換成枚舉類型
        //convert   parse   Tryparse
        //調用parse方法的目的：就是讓他幫助咱們將一個字符串轉換成對應的枚舉類型
        //拿到這個枚舉的類型  參數
        QQState state = (QQState)Enum.Parse(typeof(QQState), s);
        Console.WriteLine(state);
        Console.ReadKey();
        #endregion
    }
}

}

枚舉的轉換的聯繫：//提示用戶選擇一個在線狀態，咱們接受並將用戶的輸入轉換成枚舉類型，再次打印到控制檯
先聲明一個枚舉出來：
public enum QQZhuangTai
{
在線=1,
離線,
忙碌,
隱身
}

Console.WriteLine("請選擇你的QQ在線狀態 1--在線 2--離線 3--忙碌 4--隱身");
        string input = Console.ReadLine();
        switch (input)
        {
            case "1":QQZhuangTai s1 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在線狀態是{0}", s1);
                break;
            case "2":QQZhuangTai s2 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在線狀態是{0}", s2);
                break;
            case "3":QQZhuangTai s3 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在線狀態是{0}", s3);
                break;
            case "4":QQZhuangTai s4 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在線狀態是{0}", s4);
                break;
        }
        Console.ReadKey();

3、結構
能夠幫助咱們一次性聲明多個不一樣類型的變量。
語法：
[public] struct 結構名
{
成員;//字段
}
變量在程序運行期間只能存儲一個值，而字段能夠存儲多個值。

namespace _04結構
     {
public struct Person
    {
    //字段命名前面都加一個下劃線，這是規範
    public string _name;
    public int _age;
    public gender _gender;
}
public enum gender
{
    男,
    女
}
class Program
{
    static void Main(string[] args)
    {
        Person zsPerson;
        zsPerson._name = "張三";
        zsPerson._age = 21;
        zsPerson._gender = gender.女;

        Person lsPerson;
        lsPerson._name = "李四";
        lsPerson._age = 22;
        lsPerson._gender = gender.男;

        Console.WriteLine("學生信息：姓名{0},年齡{1},性別{2}", zsPerson._name, zsPerson._age, zsPerson._gender);
        Console.WriteLine("學生信息：姓名{0},年齡{1},性別{2}", lsPerson._name, lsPerson._age, lsPerson._gender);
        Console.ReadKey();
    }
}

}

namespace _05結構練習
 {
public struct MyColor
{
    public int _red;
    public int _green;
    public int _blue;
}
class Program
{
    static void Main(string[] args)
    {
        //一、定義一個結構叫MyColor,有三個成員，分別定義爲int類型的red,green,blue
        //聲明一個MyColor類型的變量，並對其成員賦值，使MyColor能夠表示稱爲紅色
        MyColor color;
        color._red = 255;
        color._green = 0;
        color._blue = 0;
    }
}
   }

4、數組
一次性存儲多個相同類型的變量。
語法：
數組類型[] 數組名=new 數組類型[數組長度];
訪問數組的某一個元素，須要經過這個元素的下標或者索引去訪問，數組索引默認從0開始
***數組的長度一旦固定了，就不能再被改變了

//聲明數組
        int[] nums = new int[10];
        //數組元素賦值
        nums[6] = 10;
        //經過一個循環給數組賦值，一樣也經過一個循環對數組進行取值
        for (int i = 0; i < nums.Length; i++)
        {
            nums[i] = i + 1;
        }
        for (int i = 0; i < nums.Length; i++)
        {
            Console.WriteLine(nums[i]);
        }
        Console.ReadKey();

                    //數組聲明並賦值的寫法
        int[] nums2 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 90 };

數組的五個練習

static void Main(string[] args)
    {
        //練習1.從一個整數數組中取出最大的整數，最小的整數，總和，平均值
        //聲明一個int類型的數組，而且隨意賦值
        int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        //聲明兩個邊路用來存儲最大值和最小值
        int max = nums[0];
        int min = nums[0];
        int sum = 0;
        //循環的讓數組中的每一個元素跟個人最大值，最小值進行比較
        for (int i = 0; i < nums.Length; i++)
        {
            //關於在循環中nums[i]的理解方式
            //1.表明數組中當前循環的元素
            //2.表明數組中的每一個元素
            //若是素組中當前循環到這個元素，比個人max大，就把當前元素賦值給最大值
            if (nums[i] > max)
            {
                max = nums[i];
            }
            if (nums[i] < min)
            {
                min = nums[i];
            }
            sum += nums[i];
        }
        Console.Write("這個數組的最大值是{0},最小值是{1},總和是{2},平均值是{3}", max, min, sum, sum / nums.Length);
        Console.ReadKey();

        //2.計算一個整數忰的全部元素的和
        int[] numsOne = { 10, 20, 30, 40, 50, 60 };
        int sum = 0;
        for (int i = 0; i < numsOne.Length; i++)
        {
            sum += numsOne[i];
        }
        Console.WriteLine(sum);
        Console.ReadKey();

        //3.數組裏面都是人的名字，分割成例如：老楊|老蘇|老周.....
        string[] names = { "張三", "李四", "王五", "趙六", "二麻子", "狗子" };
        string name = null;
        for (int i = 0; i < names.Length - 1; i++)
        {
            name += names[i] + "|";
        }
        Console.Write(name + names[names.Length - 1]);
        Console.ReadKey();

        //4.將一個整數數組的每個元素進行以下的處理：若是元素是正數則將這個位置的元素的值加1.
        //若是元素是負數則將這個位置的元素的值減1，若是元素是0，則不變
        int[] numsTow = { -2, -4, -6, 0, 1, 3, 5 };
        for (int i = 0; i < numsTow.Length; i++)
        {
            if (numsTow[i] < 0)
            {
                numsTow[i] -= 1;
            }
            else if (numsTow[i] > 0)
            {
                numsTow[i] += 1;
            }
        }
        for (int i = 0; i < numsTow.Length; i++)
        {
            Console.WriteLine(numsTow[i]);
        }
        Console.ReadKey();

        //5.將一個字符串數組的元素的順序進行反轉。{"我"，"是"，"好人"}
        //{ "好人"，"是"，"我"}，第i個和第length-i-1個進行交換
        string[] strs = { "我", "是", "好人" };
        string temp = null;
        for (int i = 0; i < strs.Length/2; i++)
        {
            temp = strs[i];
            strs[i] = strs[strs.Length - 1 - i];
            strs[strs.Length - 1 - i] = temp;
        }
        for (int i = 0; i < strs.Length; i++)
        {
            Console.Write(strs[i]);
        }
        Console.ReadKey();
    }

5、冒泡排序
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次

int[] nums = { 1, 4, 3, 9, 7, 5, 8, 0 };
            //對數組進行升序排列
        Array.Sort(nums);

        //對數組進行反轉
        Array.Reverse(nums);

        //for (int i = 0; i < nums.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;
        //        }
        //    }
        //}
        for (int i = 0; i < nums.Length; i++)
        {
            Console.Write(nums[i]);
        }
        Console.ReadKey();

6、方法（函數）
函數就是將一堆代碼進行重用的一種機制。
函數的語法：
[public] static 返回值類型 方法名([參數列表])
{
方法體；
}
public:訪問修飾符，公開的，公共的，哪均可以訪問。
static：靜態的
返回值類型：若是不須要寫返回值，寫void
方法名：Pascal 每一個單詞的首字母都大些。其他字母小寫
參數列表：完成這個方法所必需要提供給這個方法的條件。若是沒有參數，小括號也不能省略。

方法寫好後，若是想要被執行，必需要在Main()函數中調用。
方法的調用語法：
類名.方法名([參數]);
***在某些狀況下，類名是能夠省略的，若是你寫的方法跟Main()函數同在一個類中，這個時候，
類名能夠省略。

class Program
{
    static void Main(string[] args)
    {
        //int max = Program.GetMax(1, 2);
        //Console.WriteLine(max);
        //Console.ReadKey();

        Program.PlayGame();
        Program.PlayGame();
        Program.PlayWuDi();
        Program.PlayGame();
        Console.ReadKey();
    }

    #region 比較兩個整數之間最大值並返回最大值的方法
    /// <summary>
    /// 比較兩個整數之間最大值並返回最大值
    /// </summary>
    /// <param name="n1">第一個整數</param>
    /// <param name="n2">第二個整數</param>
    /// <returns>將最大值返回</returns>
    public static int GetMax(int n1, int n2)
    {
        return n1 > n2 ? n1 : n2;
    }
    #endregion

    #region 模擬玩遊戲過程的方法
    /// <summary>
    /// 正常完遊戲的過程
    /// </summary>
    public static void PlayGame()
    {
        Console.WriteLine("採蘑菇，走啊走，跳啊跳！");
        Console.WriteLine("採蘑菇，走啊走，跳啊跳！");
        Console.WriteLine("採蘑菇，走啊走，跳啊跳！");
        Console.WriteLine("頂到無敵了！");
    }
    /// <summary>
    /// 頂到無敵後遊戲的變化
    /// </summary>
    public static void PlayWuDi()
    {
        Console.WriteLine("被怪打不掉血！");
        Console.WriteLine("秒怪！");
    }
    #endregion
}

}

關鍵字：return一、在方法中返回要返回的值。二、當即結束本次方法。