SIKI学习——C#初级教程06

一、函数

为什么使用函数？
1，如果想要重复执行某段代码，那就需要写重复的代码
2，目前我们写的代码，写多了，结构非常混乱，不容易阅读
所以函数来了，函数也叫做方法

二、定义和使用函数

定义函数
static void Write(){
Console.WriteLine(“Text output from function .”);
}
函数的使用
static void Main(){
Write();
}

例子：

namespace 初级教程练习01
{
    class Program
    {
        static void Write()// void表示空的返回值，就是不需要返回值
        {
            //这里是函数体，也叫做方法体，这里可以写0行，一行或者多行语句
            Console.WriteLine("Text output from function");
            return;//这个语句用来结束当前函数
        }
        static void Main(string[] args)
        {
            Write();//函数的调用，函数名加上括号，括号内写参数
            Console.ReadKey();
        }
    }
}

三、返回值

控制台应用程序函数的定义形式如下：
static < returnType > < FunctionName >(){
…
return < returnValue >;
}
这里需要注意的是< returnValue >必须是< returnType >类型的，当< returnType >为void，表示这个函数不需要返回值，函数体不需要return语句，也可以写return；中断函数

四、参数

为什么使用参数。当我们定义一个函数，用来求得两个数字的和，这个时候函数怎么知道求哪两个数字呢？ 答案：通过函数的参数。
结构：
static < returnType > < FunctionName >(< parameType > < paramName >, …){
…;
return < returnValue >;
}
例子：
1，定义一个函数，用来实现两个数字的相加，把和返回。

namespace 初级教程练习01
{
    class Program
    {
        static int Plus(int num1, int num2)//函数定义的时候，参数我们叫做形式参数（形参）num1和num2就是形参，形参的值是不确定的
        {
            int sum = num1 + num2;
            return sum;
        }
        static void Main(string[] args)
        {
            int num1 = 45;
            int num2 = 90;
            int res1 = Plus(num1,num2);//当调用函数的时候，这里传递的参数就是实际参数（实参），实参的值会传递给形参做运算
            int res2 = Plus(45,20);//这里定义了res1和res2来接收方法的返回值
            Console.WriteLine(res1);
            Console.WriteLine(res2);
            Console.ReadKey();
        }
    }
}

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

namespace 初级教程练习01
{
    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 item in array)
            {
                Console.Write(item+" ");
            }
            Console.ReadKey();
        }
    }
}

3，定义一个函数，用来取得一个数组中的最大值。

namespace CSharp初级教程
{
    class Program

    {
        static int Max(int[] array)
        { 
        int max=array[0];
        for (int i = 1; i < array.Length; i++)
        {
            if(array[i]>max)
            {
                max = array[i];
            }
        }
        return max;
        }
        static void Main(string[] args)
        {
            int[] array = { 45456,48,89,156,778461,74,36};
            Console.WriteLine(Max(array));
            Console.ReadKey();
        }
    }
}

五、参数数组

定义一个函数，用来取得数字的和，但是数字的个数不确定。
解决方案：
1，定义一个函数，参数传递过来一个数组；
2，定义一个参数个数不确定的函数，这个时候我们就要使用参数数组。

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

//这里定义了一个int类型的参数数组，参数数组和数组参数（上面的）的不同，在于函数的调用，调用参数数组的函数的时候，我们可以传递过来任意多个参数，然后编译器会帮我们自动组拼成一个数组，参数如果是上面的数组参数，那么这个数组我们自己去手动创建
//参数数组就是帮我们 减少了一个创建数组的过程

namespace 初级教程练习01
{
    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类型的参数数组（params int[] array）参数数组和数组参数（上面的）不同在于函数的调用，调用参数数组的函数的时候，我们可以传递过来任意多个参数，然后编译器会帮我们自动拼成一个数组，参数如果是上面的数组参数，那么这个数组我们自己去手动创建
        {
            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[] { 1, 2, 3, 4, 5, 6 });
            Console.WriteLine(sum);
            int sum2 = Plus(1,2,3,4,5,6);//参数数组就是帮我们减少了一个创建数组的过程
            Console.WriteLine(sum2);
            Console.ReadKey();
        }
    }
}

六、结构函数

1.我们不但在结构中定义数据，还可以包含函数的定义。
struct CustomerName{
public string firstName;
public string lastName;
}
CustomerName myName;
myName.firstName = “siki”;
myName.lastName = “Liang”;
Console.WriteLine("My name is “+myName.firstName+” "+myName.lastName);

扫描二维码关注公众号，回复： 5995566 查看本文章

2.在结构体中定义函数，实现得到名字
struct CustomerName{
public string firstName;
public string lastName;
public string GetName(){
return firstName+" "+lastName;
}
}
当我们在结构体中定义一个函数的时候，这个函数就可以通过结构体声明的变量来调用，这个函数可以带有参数，那么调用的时候必须传递参数，这个函数，可以使用结构体中的属性。

namespace 初级教程练习01
{
    struct CustomerName
    {
        public string fitstName;
        public string lastName;
        public string GetName()
        {
            return fitstName + " " + lastName;
        }
    }
    class Program
    {      
        static void Main(string[] args)
        {
            CustomerName myName;
            myName.fitstName = "贝贝";
            myName.lastName = "钱";
            //Console.WriteLine("My Name Is："+myName.fitstName+" "+myName.lastName);
            Console.WriteLine("My Name Is：" + myName.GetName());
            Console.ReadKey();
        }
    }
}

例子：定义一个Vector3的类（这个类可以用来表示坐标，可以表示向量），在里面定义一个Distance方法，用来取得一个向量的长度的

namespace 初级教程练习01
{
    struct Vector3
    {
        public float x;
        public float y;
        public float z;
        public double Distance()
        {
            return Math.Sqrt(x*x+y*y+z*z);//返回的是一个double值
        }
    }
    class Program
    {      
        static void Main(string[] args)
        {
            Vector3 myVector3;
            myVector3.x = 3;
            myVector3.y = 3;
            myVector3.z = 3;
            Console.WriteLine(myVector3.Distance());
            Console.ReadKey();
        }
    }
}

七、函数的重载overload

为什么使用函数重载？
假设我们有一个函数用来实现求得一个数组的最大值
static int MaxValue(int[] intArray){
…
return;
}
这个函数只能用于处理int数组，如果想处理double类型的话需要再定义一个函数
static double MaxValue(double[] doubleArray){
…
return;
}
函数名相同，参数不同，这个叫做函数的重载(编译器通过不同的参数去识别应该调用哪一个函数)
//编译器会根据你传递过来的实参的类型去判定调用哪一个函数

namespace 初级教程练习01
{

    class Program
    {
        static int MaxValue(params int[] array)
        {
            Console.WriteLine("调用了int类型的方法");
            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类型的方法");
            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(234.34,234.5,234.4);
            Console.WriteLine(res);
            Console.WriteLine(res2);
            Console.ReadKey();
        }
    }
}

八、委托的定义和声明

委托(delegate)是一种存储函数引用的类型。
委托的定义指定了一个返回类型和一个参数列表
定义了委托之后，就可以声明该委托类型的变量，接着就可以把一个返回类型跟参数列表跟委托一样的函数赋值给这个变量。

委托的使用分两步
定义
声明（变量）
结构体，枚举的使用同上都分为定义和声明
整数类型数组类型字符串类型都是直接声明变量的，因为类型的定义已经完成了（CLR中已经完成定义）

namespace 初级教程练习01
{
    //定义一个委托跟函数差不多，区别在于
    //1、定义委托需要加上delegate关键字
    //2、委托的定义不需要函数体
    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();
        }
    }
}

例题：

1、下列常量中，不是字符常量的是（B）。
A．’\n’ B．“y” C．‘x’
字符常量是括在单引号里，例如，‘x’，且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 ‘x’）、一个转义序列（例如 ‘\t’）或者一个通用字符（例如 ‘\u02C0’）。

函数的递归调用

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

namespace CSharp初级教程
{
    class Program
    {
        static int F(int n)
        {
            if (n == 0) return 2;//这两个是函数终止递归的条件
            if (n == 1) return 3;
            return F(n-1)+F(n-2);//函数调用自身，叫做递归调用 F(40)=F(39)+F(38)分解到F(0)
        }
        static void Main(string[] args)
        {
            int res = F(40);
            Console.WriteLine(res);
            int res2 = F(2);
            Console.WriteLine(res2);
            Console.ReadKey();
        }
    }
}

循环结构练习和函数练习

5.一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

namespace CSharp初级教程
{
    class Program
    {
       
        static void Main(string[] args)
        {
            float height = 100;
            float distance = 0;
            for (int i = 1; i <=10; i++)//每次落地的时候经过多少米
            {
                distance += height;
                height /= 2;
            }
            Console.WriteLine("经过了"+distance+"米，第十次反弹"+height/2+"米");
            Console.ReadKey();
        }
    }
}

6.求1+2!+3!+…+20!的和?（！数学中的阶乘 5！=54321）

namespace CSharp初级教程
{
    class Program
    {
        static int Factorial(int n)
        {
            int res = 1;
            for (int i = 1; i <= n; i++)
            {
                res *= i;
            }
            return res;
        }
        static void Main(string[] args)
        {
            int sum = 0;
            for (int i = 1; i <= 20; i++)
            {
                sum += Factorial(i);
            }
            Console.WriteLine(sum);
            Console.ReadKey();
        }
    }
}

7，利用递归方法求5!。 f(n)=n*f(n-1)

namespace 初级教程练习01
{
    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));
            Console.ReadKey();
        }
    }
}

8，编一个程序，定义结构类型（有学号、姓名、性别和程序设计成绩四个字段），声明该结构类型变量，用赋值语句对该变量赋值以后再输出。

namespace 初级教程练习01
{
    struct Student
    {
        public string number;
        public string name;
        public bool isGirl;
        public int score;
        public void Show()
        {
            Console.WriteLine("姓名："+name+"学号："+number+"性别："+(isGirl?"女":"男")+"程序设计成绩:"+score);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Student str1;
            str1.name = "siki";
            str1.number = "124365768";
            str1.isGirl = false;
            str1.score = 100;
            str1.Show();
            Console.ReadKey();
        }
    }
}

9，编一个程序，输入一个正数，对该数进行四舍五入到个位数的运算。例如，实数12.56经过四舍五入运算，得到结果13；而12.46经过四舍五入运算，得到结果12

namespace 初级教程练习01
{
    class Program
    {
        static void Main(string[] args)
        {
            double number = Convert.ToDouble(Console.ReadLine());
            int numberInteger = (int)number / 1;
            double numberDouble = number - numberInteger;
            if (numberDouble>=0.5f)
            {
                numberInteger++;
            }
            Console.WriteLine(numberInteger);
            Console.ReadKey();
        }
    }
}

下方的 代码与上方的代码结果一样

namespace 初级教程练习01
{
    class Program
    {
        static void Main(string[] args)
        {
            double number = Convert.ToDouble(Console.ReadLine());
            int res = (int)(number + 0.5f);
            Console.WriteLine(res);
            Console.ReadKey();
        }
    }
}

10，有关系式11+22+33+…+kk<2000,编一个程序，求出满足此关系式的k的最大值

namespace 初级教程练习01
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            int k = 0;
            while (sum<2000)
            {
                k++;
                sum += k * k;
            }
            Console.WriteLine(k-1);
            Console.ReadKey();
        }
    }
}

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

namespace 初级教程练习01
{
    class Program
    {
        static void Main(string[] args)
        {
            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);
                    }
                }
            }
            Console.ReadKey();
        }
    }
}