c#入门（一）基本语法

一、visual studio的安装网址

https://visualstudio.microsoft.com/zh-hans/free-developer-offers/

二、基本知识

1、第一个hello world程序

using System;
//引入命名空间
namespace c_sharp_rumen
    //定义命名空间
{
    class Program
    {//定义类
        static void Main(string[] args)
            //定义一个Main方法
        {
            Console.WriteLine("Hello World!");
            //方法体
        }
    }
}

using System 告诉编译器使用System命名空间中的类型。

namespace c_sharp_rumen 声明一个新的命名空间，名字为c_sharp_rumen,下面的类属于这个命名空间。

class Program 声明一个新的类类型，名字叫做Program。

static void Main(string[] args) 声明一个方法，名称为Main，Main方法就是类的一个成员,Main是一个特殊函数，编译器把它作为程序的起始点。

语句以分号结束；这个语句使用命名空间System下的Console类把一个字符串输出到控制台；没有第一行的using语句，编译器就找不到Console类。

2、标识符，关键字，命名规范

标识符：字母 下划线 可以用在任何位置，数字不能放在首位， @字符只能放在标示符的首位。

标识符不能与关键字重复，

保留关键字
abstract	as	base	bool	break	byte	case
catch	char	checked	class	const	continue	decimal
default	delegate	do	double	else	enum	event
explicit	extern	false	finally	fixed	float	for
foreach	goto	if	implicit	in	in (generic modifier)	int
interface	internal	is	lock	long	namespace	new
null	object	operator	out	out (generic modifier)	override	params
private	protected	public	readonly	ref	return	sbyte
sealed	short	sizeof	stackalloc	static	string	struct
switch	this	throw	true	try	typeof	uint
ulong	unchecked	unsafe	ushort	using	virtual	void
volatile	while
上下文关键字
add	alias	ascending	descending	dynamic	from	get
global	group	into	join	let	orderby	partial (type)
partial (method)	remove	select	set

Camel命名法： 首个单词的首字母小写，其余单词的首字母大写(enemyHp)。

Pascal命名规范： 每个单词的第一个字母都大写(EnemyHp)，如果使用到英文单词的缩写，全部使用大写(PI HP MP)。

变量使用Camel命名，方法和类使用Pascal命名规范。

3、Main方法，语句，块

每个c#程序必须带一个Main方法（函数），Main方法首字母大写。

语句是描述一个类型或告诉程序去执行某个动作的一条源代码指令，语句以分号结束。

int var1 = 5;

System.Console.WriteLine("The value of var1 is {0}",var1);

块是一个由大括号包围起来的0条或多条语句序列，它在语法上相当于一条语句。

{

int var1 = 5;

System.Console.WriteLine("The value of var1 is {0}",var1);

}

块的内容：

1，某些特定的程序结构只能使用块

2，语句可以以分号结束，但块后面不跟分号

4、输出文本到控制台，格式化输出

Console.Write(""Hello world1.");

System.Console.WriteLine("Hello world2.");

Console.WriteLine("两个数相加{0}+{1}={2}",3,34,34);

Write是Console类的成员，它把一个文本字符串发送到程序的控制台窗口，WriteLine是Console的另外一个成员，它和Write实现相同的功能，但会在每个输出字符串的结尾添加一个换行符。

下面的语句使用了3个标记，但只有两个值

Console.WriteLine("Three integers are {1},{0} and {1}",3,5);

但是标记不能引用超出替换值列表长度以外位置的值

三、变量与表达式

1.变量

;

type表示使用什么类型的变量来存储数据，name表示存储这个变量的名字

int age; int hp; string name;

类型	描述	范围	默认值
bool	布尔值	True 或 False	False
byte	8 位无符号整数	0 到 255	0
char	16 位 Unicode 字符	U +0000 到 U +ffff	‘\0’
decimal	128 位精确的十进制值，28-29 有效位数	(-7.9 x 1028 到 7.9 x 1028) / 100 到 28	0.0M
double	64 位双精度浮点型	(+/-)5.0 x 10-324 到 (+/-)1.7 x 10308	0.0D
float	32 位单精度浮点型	-3.4 x 1038 到 + 3.4 x 1038	0.0F
int	32 位有符号整数类型	-2,147,483,648 到 2,147,483,647	0
long	64 位有符号整数类型	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0L
sbyte	8 位有符号整数类型	-128 到 127	0
short	16 位有符号整数类型	-32,768 到 32,767	0
uint	32 位无符号整数类型	0 到 4,294,967,295	0
ulong	64 位无符号整数类型	0 到 18,446,744,073,709,551,615	0
ushort	16 位无符号整数类型	0 到 65,535	0

赋值变量

using System;

namespace _002_bian_liang
{
    class Program
    {
        static void Main(string[] args)
        {
            byte myByte = 12;
            float number = 12.5f; //注意赋值时的浮点数默认是double类型，所以需要加上f
            double number1 = 12.6;
            Console.WriteLine("byte:{0} float:{1}  double:{2}",myByte,number,number1);
            char myChar = 'a';
            string muString = "a";
            bool muBool = true;
        }
    }
}

2、转义字符

转义序列	含义
\	\ 字符
’	’ 字符
"	" 字符
?	? 字符
\a	Alert 或 bell
\b	退格键（Backspace）
\f	换页符（Form feed）
\n	换行符（Newline）
\r	回车
\t	水平制表符 tab
\v	垂直制表符 tab
\ooo	一到三位的八进制数
\xhh . . .	一个或多个数字的十六进制数

使用@不识别转义字符

如果我们不想去识别字符串中的转义字符，可以在字符串前面加一个@符号（除了双引号其他转义字符都不在识别）

举例：string sentence = @“I’m a good man. " " You are bad girl!” ,使用两个引号表示一个引号

@字符的两个作用示例：

1，默认一个字符串的定义是放在一行的，如果想要占用多行

2，用字符串表示路径

“c:\xxx\xx\xxx.doc”

使用@"c:\xxx\xx\xxx.doc"更能读懂

多变量赋值

string name1,name2;

3、表达式

算术运算符

下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

更详细的可以参考这个网址

https://www.runoob.com/csharp/csharp-operators.html

数据类型转换

序号	方法 & 描述
1	ToBoolean 如果可能的话，把类型转换为布尔型。
2	ToByte 把类型转换为字节类型。
3	ToChar 如果可能的话，把类型转换为单个 Unicode 字符类型。
4	ToDateTime 把类型（整数或字符串类型）转换为 日期-时间 结构。
5	ToDecimal 把浮点型或整数类型转换为十进制类型。
6	ToDouble 把类型转换为双精度浮点型。
7	ToInt16 把类型转换为 16 位整数类型。
8	ToInt32 把类型转换为 32 位整数类型。
9	ToInt64 把类型转换为 64 位整数类型。
10	ToSbyte 把类型转换为有符号字节类型。
11	ToSingle 把类型转换为小浮点数类型。
12	ToString 把类型转换为字符串类型。
13	ToType 把类型转换为指定类型。
14	ToUInt16 把类型转换为 16 位无符号整数类型。
15	ToUInt32 把类型转换为 32 位无符号整数类型。
16	ToUInt64 把类型转换为 64 位无符号整数类型。

程序示例

using System;

namespace convertType
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;
            
            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());

            string readContent = Console.ReadLine(); //接收用户输入的一行
            int contentConvert = Convert.ToInt32(readContent);
            Console.WriteLine(contentConvert);
        }
    }
}

四、流程控制

1、if语句

bool var1 = true;
	if(var1)
		Console.WriteLine(var1);

if (score > 50)
            {
                score++;
                Console.WriteLine("您输入的分数大于50"+score);
            }
            else
            {
                score--;
                Console.WriteLine("您输入的分数小于等于50"+score);
            }

2、？：

? :

  int myInterger = 100;
            string res = (myInterger < 10) ? "less than 10" : "more than 10";
            Console.WriteLine(res);

3、switch

 int state = 0;
            switch (state)
            {
                case 0:
                    Console.WriteLine("游戏开始！");
                    break;
                case 1:
                    Console.WriteLine("游戏结束！");
                    break;
               case 2:
                   Console.WriteLine("游戏胜利");
                    break;
                default:
                    Console.WriteLine("未知错误");
                    break;
            }

4、while 循环

                    int i=1,j = 1;
                    while (i < 10 )
                    {
                        while (j <= i)
                        {
                          Console.Write("{0}×{1}={2} ", i, j, i * j);
                           j++;
                       }
                       Console.WriteLine();
                      i++;
                        j = 1;
                    }

5、do while循环

            int index = 1;
            do
            {
                Console.WriteLine(index);
                index++;
            } while (index < 10);

6、for循环

        int i,j;
        for (i = 1; i < 10; i++)
        {
            for (j = 1; j <=i; j++)
            {
                Console.Write("{0}×{1}={2} ", i, j, i * j);
            }
            j = 1;
            Console.WriteLine();
        }

7、continue break

接受用户输入的整数，如果用户输入的是大于0的偶数，就相加，如果用户输入的是大于0的奇数就不相加，如果用户输入的是0，就把和输出并退出程序。

            int sum = 0;
            while (true)
            {
                int num = Convert.ToInt32(Console.ReadLine());
                if (num == 0) //这两个if换顺序就是错误的
                {
                    break;
                }
                if (num % 2 == 1)
                {
                    continue;
                }
                sum += num;
              
            }
            Console.WriteLine("sum = {0}", sum);

插件推荐 resharper

8、编程练习

编程输出1000以内的所有素数

using System;

namespace exercise_xunhuan
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            bool isZhi = true;
            for (int i = 2; i <= 1000; i++)
            {
                for (int j = 2; j < i; j++)
                {
                    if (i%j==0)
                    {
                        isZhi = false;
                        break;
                    }
                }
                if (isZhi)
                {
                    Console.WriteLine(i);
                }
                isZhi = true;
            }
        }
    }
}

判断输入的前5个是否是大写字母

            string str = Console.ReadLine();
            bool isAll = true;
            for (int i = 0; i < 6; i++)
            {
                if ( str[i] > 'A' && str[i] < 'Z')
                {
                   
                }
                else
                {
                    Console.WriteLine("输入的前5个不全是大写字母");
                    isAll = false;
                    break;
                }
            }
            if (isAll)
            {
                Console.WriteLine("输入的前5个都是大写字母");
            }

一个控制台应用程序，求1000之内的所有“完数”。所谓“完数”是指一个数恰好等于它的所有因子之和。例如6是完数，因为6=1+2+3。

            for (int i = 1; i <= 1000; i++)
            {
                int sum = 1;
                string str = "1";
                for (int j = 2; j < i; j++)
                {
                    if (i % j == 0)
                    {
                        sum += j;
                        str += "+" + j;
                    }
                }
                if (sum == i)
                {
                    Console.WriteLine(i + "=" + str + "是完数");
                }
            }

五、变量类型

1、类型转换

• 隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
• 显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。
  
  
  

            int num = Convert.ToInt32(str);//当字符串里面存储的是整数的时候，就可以转化成int double类型，否则出现异常
                                                                //当字符串里面是一个小数的时候，就可以转化成double类型
            int mynum = 234234;
            string str2 = Convert.ToString(mynum);//它可以把一个int float double byte类型转换成字符串
            string str3 = mynum + "";//一个int float double类型直接加上一个空的字符串，相当于把这个数字转化成一个字符串 

2、枚举enum

using System;

namespace ENUM_TYPE
{
    enum GameState：byte//修改该枚举类型的存储类型，默认为int
    {
    { 
    Pause = 100, // 默认代表的是整数0，一般默认不修改
    Failed = 101,// 默认代表的是整数1
    Success=102,// 默认代表的是整数2
    Start=200// 默认代表的是整数3
    };
    class Program
    {
        static void Main(string[] args)
        {
            GameState state = GameState.Start;
            Console.WriteLine(state);
            int num = (int)state;
            Console.WriteLine(num);
        }
    }
}

枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值。默认情况下，第一个枚举符号的值是 0.

3、结构体struct

定义结构体

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

实例

using System;
using System.Text;
     
struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1;        /* 声明 Book1，类型为 Books */
      Books Book2;        /* 声明 Book2，类型为 Books */

      /* book 1 详述 */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali";
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* book 2 详述 */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject =  "Telecom Billing Tutorial";
      Book2.book_id = 6495700;

      /* 打印 Book1 信息 */
      Console.WriteLine( "Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);

      /* 打印 Book2 信息 */
      Console.WriteLine("Book 2 title : {0}", Book2.title);
      Console.WriteLine("Book 2 author : {0}", Book2.author);
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);      

      Console.ReadKey();

   }
}

4、数组 array

//第一种 数组的初始化方式
            int[] scores1 = {23,43,432,42,34,234,234,2,34} ;//使用这种方式赋值的时候，一定要注意 在数组声明的时候赋值

            //第二种数组创建的方式
            int[] scores2 = new int[10];
            int[] scores3;
            scores3 = new int[10];

            int[] scores4 = new int[10]{3,43,43,242,342,4,234,34,234,5};
            Console.WriteLine(scores[10]);//当我们访问一个索引不存在的值的时候，会出现异常exception

            char[] charArray = new char[2]{'a','b'};
            Console.WriteLine(charArray[1]);

遍历

        int[] scores = {23, 2, 32, 3, 34, 35, 45, 43, 543};
        //scores.Length//得到数组的长度
        //for (int i = 0; i < scores.Length; i++)
        //{
        //    Console.WriteLine(scores[i]);
        //}

        //int i = 0;
        //while (i
        //{
        //    Console.WriteLine(scores[i]);
        //    i++;
        //}
        foreach (int temp in scores )//foreach会依次取到数组中的值，然后赋值给temp，然后执行循环体
        {
            Console.WriteLine(temp);
        }

5、字符串常用的内置方法

str.ToLower();//把字符串转化成小写 并返回，对原字符串没有影响
string res = str.ToUpper();//把字符串转化成大写 并返回，对原字符串没有影响
string res = str.Trim();//去掉字符串前面和后面的空格，对原字符串没有影响
string res = str.TrimStart();
string res = str.TrimEnd();
string[] strArray=str.Split(’.’);//把原字符串按照指定的字符进行拆分

https://www.runoob.com/csharp/csharp-string.html

6、练习题

找出100到999之间的水仙花数；“153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3”

using System;

namespace bian_laing_exercise
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 100; i <= 999; i++)
            {
                int bai = (int)(i / 100);
                int shi = (int)(i / 10) - bai * 10;
                int ge = i - bai * 100 - shi * 10;
                if (i == (bai*bai*bai) + (shi*shi*shi) + (ge*ge*ge))
                {
                    Console.WriteLine("{0} = ({1} * {1} * {1}) + ( {2} *{2} * {2}) + ({3} * {3} * {3})", i, bai, shi, ge);
                }
            }
        }
    }
}

  for (int i = 100; i < 1000; i++)
            {
                int ge = i%10;
                int shi = (i/10)%10;
                int bai = i/100;
                int res = ge*ge*ge + shi*shi*shi + bai*bai*bai;
                if (res == i)
                {
                    Console.WriteLine(i);
                }
            }

3个可乐瓶可以换一瓶可乐，现在有364瓶可乐。问一共可以喝多少瓶可乐，剩下几个空瓶！

            int sum = 364;
            int yu = 364;
            while (yu > 3)
            {
                sum += yu / 3;
                yu = yu % 3 + yu / 3;
         
            }
            Console.WriteLine("{0},{1}",sum,yu);

编写一个控制台程序，要求用户输入一组数字用空格间隔，对用户输入的数字从小到大输出。

            string[] str = Console.ReadLine().Split(' ');
            int[] numArry = new int[str.Length];
            for (int i = 0; i < str.Length; i++)
            {
                numArry[i] = Convert.ToInt32(str[i]);
            }
            Array.Sort(numArry);
            foreach (int item in numArry)
            {
                Console.Write(item + " ");
            }

输入n(n<100)个数，找出其中最小的数，将它与最前面的数交换后输出这些数。

            string[] str = Console.ReadLine().Split(' ');
            int[] numArry = new int[str.Length];
            for (int i = 0; i < str.Length; i++)
            {
                numArry[i] = Convert.ToInt32(str[i]);
            }
            int min = numArry[0];
            int minNum = 0;
            for (int j = 1; j <numArry.Length; j++)
            {

                if (numArry[j] < min)
                {
                    min = numArry[j];
                    minNum = j;
                }
            }
            if (minNum > 0)
            {
                int temp = numArry[minNum];
                numArry[minNum] = numArry[0];
                numArry[0] = temp;
            }
            foreach (int item in numArry)
            {
                Console.Write(item + " ");
            }

如果每个老师的工资额都知道，最少需要准备多少张人民币，才能在给每位老师发工资的时候都不用老师找零呢？
这里假设老师的工资都是正整数，单位元，人民币一共有100元、50元、10元、5元、2元和1元六种。

            int num = Convert.ToInt32(Console.ReadLine());
            int count100 = num / 100;
            int remain = num % 100;
            int count50 = remain / 50;
            remain = remain % 50;
            int count10 = remain / 10;
            remain = remain % 10;
            int count5 = remain / 5;
            remain = remain % 5;
            int count2 = remain / 2;
            remain = remain % 2;
            Console.WriteLine("100的准备" + count100);
            Console.WriteLine("50的准备" + count50);
            Console.WriteLine("10的准备" + count10);
            Console.WriteLine("5的准备" + count5);
            Console.WriteLine("2的准备" + count2);
            Console.WriteLine("1的准备" + remain);

输入一个字符串，判断其是否是C#的合法标识符。

            string str = Console.ReadLine();
            bool isRight = true;
            if ((str[0] >= 'a' && str[0] <= 'z') || (str[0] >= 'A' && str[0] <= 'Z') || str[0] == '_' || str[0] == '@')
            {

            }
            else
            {
                isRight = false;
            }
            for (int i = 1; i < str.Length; i++)
            {
                if ((str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z') || str[i] == '_' ||
                    (str[i] >= '0' && str[i] <= '9'))
                {

                }
                else
                {
                    isRight = false;
                }

            }
            if (isRight == false)
            {
                Console.WriteLine("不是合法标识符");
            }
            else
            {
                Console.WriteLine("是合法标识符");
            }

“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。请写一个程序判断读入的字符串是否是“回文”。

           string str = Console.ReadLine();
            bool isHui = true;
            for (int i = 0; i < str.Length / 2; i++)
            {
                //i str.length-1-i;
                if (str[i] != str[str.Length - 1 - i])
                {
                    isHui = false; break;
                }
            }
            if (isHui)
            {
                Console.WriteLine("是回文串");
            }
            else
            {
                Console.WriteLine("不是回文串");
            }

六、函数

1、定义与调用

using System;

namespace HAN_SHU
{
    class Program
    {
        static int Plus(int num1, int num2)//定义一个函数
            //函数定义的时候，参数我们叫做形式参数（形参）,num1跟num2在这里就是形参，形参的值是不确定的
        {
        {
            int sum = num1 + num2;
            return sum;//返回值
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            int res = Plus(1, 2);//当调用函数的时候，这里传递的参数就是实际参数（实参）,实参的值会传递给形参做运算
            Console.WriteLine(res);
        }
    }
}

定义一个函数，用来实现取得一个数字的所有因子，把所有因子返回。

using System;

namespace HAN_SHU
{
    class Program
    {
        static int[] GetDivisor(int number)
        {
            int count = 0;
            for (int i = 1; i <= number; i++)
            {
                if (number % i == 0)
                {
                    count++;
                }
            }
            int[] array = new int[count];
            int index = 0;
            for (int i = 1; i <= number; i++)
            {
                if (number % i == 0)
                {
                    array[index] = i;
                    index++;
                }
            }
            return array;
        }
        static void Main(string[] args)
        {
            int num = Convert.ToInt32(Console.ReadLine());
            int[] array = GetDivisor(num);
            foreach (int temp in array)
            {
                Console.Write(temp + " ");
            }
        }
    }
}

2、参数数组

定义一个函数，用来取得数字的和，但是数字的个数不确定。

解决方案：

1，定义一个函数，参数传递过来一个数组；

2，定义一个参数个数不确定的函数，这个时候我们就要使用参数数组。

除了参数数组，所有函数的参数都是固定的，那么调用的时候，参数是一定要传递的

using System;

namespace HAN_SHU
{
    class Program
    {
        static int Sum(int[] array)//如果一个函数定义了参数，那么在调用这个函数的时候，一定要传递对应类型的参数，否则无法调用（编译器编译不通过）
        {
            int sum = 0;
            for (int i = 0; i < array.Length; i++)
            {
                sum += array[i];
            }
            return sum;
        }

        static int Plus(params int[] array)//这里定义了一个int类型的参数数组，参数数组和数组参数（上面的）的不同，在于函数的调用，调用参数数组的函数的时候，我们可以传递过来任意多个参数，然后编译器会帮我们自动组拼成一个数组，参数如果是上面的数组参数，那么这个数组我们自己去手动创建
        {
            int sum = 0;
            for (int i = 0; i < array.Length; i++)
            {
                sum += array[i];
            }
            return sum;
        }
        static void Main(string[] args)
        {
            int sum = Sum(new int[] { 23, 4, 34, 32, 32, 42, 4 });
            Console.WriteLine(sum);
            int sum2 = Plus(23, 4, 5, 5, 5, 32, 423, 42, 43, 23, 42, 3);//参数数组就是帮我们 减少了一个创建数组的过程 
            Console.WriteLine(sum2);
        }
    }
}

3、结构函数的定义与使用

当我们在结构体中定义一个函数的时候，这个函数就可以通过结构体声明的变量来调用，这个函数可以带有参数，那么调用的时候必须传递参数，这个函数，可以使用结构体中的属性。

namespace Struct_Han_Shu {
    struct  Vector3
    {
        public float x;
        public float y;
        public float z;

        public double Distance()
        {
            return Math.Sqrt(x*x + y*y + z*z);
        }
    }
    class Program {
        static void Main(string[] args)
        {
            Vector3 myVector3;
            myVector3.x = 3;
            myVector3.y = 3;
            myVector3.z = 3;
            Console.WriteLine(myVector3.Distance());
        }
    }
}

4、函数的重载

为什么使用函数重载？

假设我们有一个函数用来实现求得一个数组的最大值

static int MaxValue(int[] intArray){

 ....

 return;

}

这个函数只能用于处理int数组，如果想处理double类型的话需要再定义一个函数

static double MaxValue(double[] doubleArray){

 ...

 return;

}

函数名相同，参数不同，这个叫做函数的重载(编译器通过不同的参数去识别应该调用哪一个函数)，编译器会根据你传递过来的实参的类型去判定调用哪一个函数。

namespace _函数的重载 {

    class Program {
        static int MaxValue(params int[] array)
        {
            Console.WriteLine("int类型的maxvalue被调用 ");
            int maxValue = array[0];
            for (int i = 1; i < array.Length; i++)
            {
                if (array[i] > maxValue)
                {
                    maxValue = array[i];
                }
            }
            return maxValue;
        }

        static double MaxValue(params double[] array)
        {
            Console.WriteLine("double类型的maxvalue被调用 ");
            double maxValue = array[0];
            for (int i = 1; i < array.Length; i++) {
                if (array[i] > maxValue) {
                    maxValue = array[i];
                }
            }
            return maxValue;
        }
        static void Main(string[] args)
        {
            int res = MaxValue(234, 23, 4);//编译器会根据你传递过来的实参的类型去判定调用哪一个函数
            double res2 = MaxValue(23.34, 234.5, 234.4);
            Console.WriteLine(res);
            Console.WriteLine(res2);
            Console.ReadKey();
        }
    }
}

5、委托的定义与使用

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

using System;

namespace _委托的使用 {
    //定义一个委托跟函数差不多，区别在于
    //1,定义委托需要加上delegate关键字
    //2,委托的定义不需要函数体
    public delegate double MyDelegate(double param1, double param2);
    class Program {
        static double Multiply(double param1, double param2)
        {
            return param1*param2;
        }

        static double Divide(double param1, double param2)
        {
            return param1/param2;
        }
        static void Main(string[] args)
        {
            MyDelegate de;//利用我们定义的委托类型声明了一个新的变量 
            de = Multiply;//当我们给一个委托的变量赋值的时候，返回值跟参数列表必须一样，否则无法赋值

            Console.WriteLine(de(2.0, 34.1));
            de = Divide;
            Console.WriteLine( de(2.0,34.1) );
            Console.ReadKey();
        }
    }
}

5、练习

f(n)=f(n-1)+f(n-2) f(0)=2 f(1)=3 ,用程序求得f(40)

using System;

namespace HAN_SHU_EXERCISE
{
    class Program
    {
        static int F(int n)
        {
            if (n == 0) return 2;//递归的结束条件
            if (n == 1) return 3;
            return F(n - 1) + F(n - 2);//函数的递归调用
        }
        static void Main(string[] args)
        {
            Console.WriteLine(F(40));
        }
    }
}

利用递归方法求5!

using System;

namespace HAN_SHU_EXERCISE
{
    class Program
    {
        static int Factorial(int n)
        {
            if (n == 1) return 1;
            return n * Factorial(n - 1);
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Factorial(5));
        }
    }
}

编一个程序，解决百钱买百鸡问题。某人有100元钱，要买100只鸡。公鸡5元钱一只，母鸡3元钱一只，小鸡一元钱3只。问可买到公鸡，母鸡，小鸡各为多少只。把所有的可能性打印出来。

            for (int i = 0; i <= 100/5; i++)
            {
                for (int j = 0; j <= (100 - i*5)/3; j++)
                {
                    int remainMoney = 100 - 5*i - 3*j;
                    int number = remainMoney*3;
                    if ( (i + j + number) == 100)
                    {
                        Console.WriteLine("公鸡"+i+" 母鸡"+j+" 小鸡"+number);
                    }
                }
            }