「C# 入门基础」4、复杂数据类型

• 学习笔记 • 阅读 1150

常量

特点：常量不能够被重新赋值。
语法：const 变量类型 变量名 = 值;

const int number = 20;

枚举

语法：
[public] enum 枚举名
{
    值1,
    值2,
    值3,
    ........
}

public：访问修饰符。公开的，哪都可以访问。
enum：关键字，声明枚举的关键字
枚举名：要符合 Pascal 命名规范

public enum QQState
{
    OnLine,
    OffLine,
    Leave,
    Busy,
    QMe
}

枚举类型强转成 int 类型

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

QQState s = QQState.OnLine;
int n = (int)s;
Console.WriteLine((int)QQState.OffLine);
Console.WriteLine((int)QQState.Leave);
Console.WriteLine((int)QQState.Busy);
Console.WriteLine((int)QQState.QMe);
Console.ReadKey();

int 类型强转成枚举类型

int n = 3;
QQState state = (QQState)n;
Console.WriteLine(state);
Console.ReadKey();

枚举类型转换成 string 类型

枚举可以跟 string 类型互相转换
如果将枚举类型转换成 string 类型，则直接调用 ToString()

QQState state = QQState.OnLine;
string s = state.ToString();
Console.WriteLine(s);
Console.ReadKey();

string 类型转换成枚举类型

语法：
(要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),"要转换的字符串");

如果转换的字符串是数字，则就算枚举中没有，也会不会抛异常。
如果转换的字符串是文本，如果枚举中没有，则会抛出异常。

string s = "ABCDEFG";   //将s转换成枚举类型
Convert.ToInt32() int.parse() int.TryParse()  //调用Parse()方法的目的就是为了让它帮助我们将一个字符串转换成对应的枚举类型
QQState state = (QQState)Enum.Parse(typeof(QQState), s);
Console.WriteLine(state);
Console.ReadKey();

结构

语法：
[public] struct 结构名
{
    成员;  //字段(字段名称在前面加_，用来和变量相区分)
}

可以一次性声明多个不同类型的变量。
变量在程序运行期间只能存储一个值，而字段可以存储多个值。

publice struct Person
{
    public string _name;
    public int _age;
    public char _gender;
}
Person zsPerson
zsPerson._name = "张三";
zsPerson._age = 21;
zsPerson._gender = '男';

枚举和结构的使用

publice struct Person
{
    public string _name;
    public int _age;
    public Gender _gender;
}
publice enum Gender
{
    男,
    女,
}
Person zsPerson
zsPerson._name = "张三";
zsPerson._age = 21;
zsPerson._gender = Gender.男;

数组

语法：
数组类型[] 数组名=new 数组类型[数组长度];

一次性存储多个相同类型的变量。
数组的长度一旦固定了，就不能再被改变了

int[] nums = new int[10]
for(int i = 0;i < nums.Length;i++)
{
    nums[i] = i;
}

数组的声明方式

int[] nums2 = {1,2,3,4,5,6};
int[] nums3 = new int[3] {1,2,3};
int[] nums4 = new int[] {1,2,3,4,5};

冒泡排序

就是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。

int[] nums={9,8,7,6,5,4,3,2,1,0};

第一趟比较：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 次 i=4 j=nums.Length-1-i
第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了 4 次 i=5 j=nums.Length-1-i
第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了 3 次 i=6 j=nums.Length-1-i
第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了 2 次 i=7 j=nums.Length-1-i
第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了 1 次 i=8 j=nums.Length-1-i

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;
        }
    }
}
Array.Sort(nums);   //对数组做一个升序排列
Array.Reverse(nums);   //对数组做一个反转

方法

函数就是将一堆代码进行重用的一种机制。

语法：
[public] static 返回值类型 方法名([参数列表])
{
    方法体；
}

如果不需要写返回值，写 void。

public static int GetMax(int n1, int n2)
{
    return n1 > n2 ? n1 : n2;
}

方法写好后，如果想要被执行，必须要在 Main() 函数中调用。

方法的调用语法：
类名.方法名([参数]);
int max = Program.GetMax(n1, n2);

在某些情况下，类名是可以省略的，如果你写的方法跟 Main() 函数同在一个类中，
这个时候，类名可以省略。

return

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

静态字段

我们在 Main() 函数中，调用 Test() 函数，我们管 Main() 函数称之为调用者，管 Test() 函数称之为被调用者。

如果被调用者想要得到调用者的值：
1)、传递参数；
2)、使用静态字段来模拟全局变量。

pubilc static int _number = 10;

如果调用者想要得到被调用者的值：
1)、返回值

out 参数

如果你在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组。
但是，如果返回多个不同类型的值的时候，返回数组就不行了，那么这个时候，我们可以考虑使用 out 参数。
out 参数就侧重于在一个方法中可以返回多个不同类型的值。

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int max1;
int min1;
int sum1;
int avg1;
bool b;
string s;
Test(numbers, out max1, out min1, out sum1, out avg1, out b, out s, out d);
Console.WriteLine(max1);
Console.WriteLine(min1);
Console.WriteLine(sum1);
Console.WriteLine(avg1);
Console.WriteLine(b);
Console.WriteLine(s);
Console.WriteLine(d);
Console.ReadKey();

out 参数要求在方法的内部必须为其赋值。

public static void Test(int[] nums, out int max, out int min, out int sum, out int avg, out bool b, out string s, out double d)
{
    max = nums[0];
    min = nums[0];
    sum = 0;
    for (int i = 0; i < nums.Length; i++)
    {
        if (nums[i] > max)
        {
            max = nums[i];
        }
        if (nums[i] < min)
        {
            min = nums[i];
        }
        sum += nums[i];
    }
    avg = sum / nums.Length;
    b = true;
    s = "123";
    d = 3.13;

ref 参数

能够将一个变量带入一个方法中进行改变，改变完成后，再讲改变后的值带出方法。
ref 参数要求在方法外必须为其赋值，而方法内可以不赋值。

static void Main(string[] args)
{
    double salary = 5000;
    JiangJin(ref salary);
    Console.WriteLine(salary);
    console.ReadKey();
}
public static viod JiangJin(ref double s)
{
    s += 500;
}

params 可变参数

将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理。
params 可变参数必须是形参列表中的最后一个元素。

static void Main(string[] args)
{
    Test("张三", 98, 88, 77);
    Console.ReadKey();
}
public static void Test(string name,params int[] score)
{
    int sum = 0;
    for (int i = 0; i < score.Length; i++)
    {
        sum += score[i];
    }
    Console.WriteLine("{0}的考试总成绩为{1}", name, sum);
}

方法的重载

概念：方法的重载指的就是方法的名称相同给，但是参数不同。

参数不同，分为两种情况
1)、如果参数的个数相同，那么参数的类型就不能相同。
2)、如果参数的类型相同，那么参数的个数就不能相同。
*** 方法的重载跟返回值没有关系。

方法的递归

方法自己调用自己。
找出一个文件夹中所有的文件。

static void Main(string[] args)
    {
        TellStory();
        Console.ReadKey();
    }
public static int i = 0;
public static void TellStory()
    {
        Console.WriteLine("从前有座山");
        Console.WriteLine("山里有座庙");
        Console.WriteLine("庙里有个老和尚和小和尚");
        Console.WriteLine("有一天，小和尚哭了，老和尚给小和尚讲了一个故事");
        i++;
        if (i >= 10)

        {
            return;
        }
         TellStory();
    }
本文为原创文章，著作权归作者所有：来自「KOBIN 技术随笔」作者的原创作品，转载请标明出处。
「C# 入门基础」4、复杂数据类型
https://blog.kobin.cn/notes/468.html
赞 (0)
0 0

相关文章

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注

CAPTCHAis initialing...