internal class Program
    {
        static int WhoIsBigger(int a, int b)
        {
            int bigger = 0;

            if(a > b)
            {
                bigger = a;
            }
            else
            {
                bigger = b;
            }
            return bigger;
        }

        static float WhoIsBigger(float a, float b)
        {
            float bigger = 0;

            if (a > b)
            {
                bigger = a;
            }
            else
            {
                bigger = b;
            }
            return bigger;
        }

        static double WhoIsBigger(double a, double b)
        {
            double bigger = 0;

            if (a > b)
            {
                bigger = a;
            }
            else
            {
                bigger = b;
            }
            return bigger;
        }

        static float WhoIsBigger(params float[] floats)
        {
            float bigger = floats[0];

            for (int i = 0; i < floats.Length; i++)
            {
                if (bigger < floats[i])
                {
                    bigger = floats[i];
                }
            }

            return bigger;
        }

        static double WhoIsBigger(params double[] doubles)
        {
            double bigger = doubles[0];

            for (int i = 0; i < doubles.Length; i++)
            {
                if (bigger < doubles[i])
                {
                    bigger = doubles[i];
                }
            }

            return bigger;
        }

        static void Main(string[] args)
        {
            int a = 1;
            int b = 2;
            double d = Math.PI;
            double e = Math.Sqrt(2);
            float f = 34.56f;
            float g = 454.54f;
            float[] A_float = { 1.2f, 0.5f, 7.7f, 9.37f };
            double[] A_double = { Math.PI, Math.Sqrt(2), Math.Sin(30), Math.Cos(50), Math.Tan(45) };
            Console.WriteLine("{0}和{1}中{2}更大", a, b, WhoIsBigger(a, b));
            Console.WriteLine("{0}和{1}中{2}更大", f, g, WhoIsBigger(f, g));
            Console.WriteLine("{0}和{1}中{2}更大", d, e, WhoIsBigger(d, e));
            Console.WriteLine("float数组中{0}更大", WhoIsBigger(A_float));
            Console.WriteLine("double数组中{0}更大", WhoIsBigger(A_double));
        }
    }

//重载概念
//在同一语句块(class或者struct)中

//函数(方法)名相同
//参数的数量不同

//或者
//参数的数量相同，但参数的类型或顺序不同

/**********************************************/

//作用:
//1.命名一组功能相似的函数，减少函数名的数量，避免命名空间的污染

//2.提升程序可读悝

// ref和out 可以理解成他们也是一种变量类型所以可以用在重载中。但是ref和out不能同时修饰
 

函数重载只和参数类型、个数、顺序有关，和返回类型无关，也就是不能重载参数一样但返回类型不同的函数

加了ref和out也相当于重载，但不能这样：

static float Calc(out float f, int a);

static float Calc(ref float f, int a);

一个用out一个用ref不算重载

变成可选参数不算重载

函数重载：

函数名相同，传入的参数类型、数量、顺序不同的函数。

理解：一个机器可以给椅子自动刷漆，那想用它给桌子刷漆他就不能工作了，所以在制作机器的时候要考虑到当放入的是桌子的是后，要怎样工作，所以，当我们设置好，放入机器中一样东西，他会根据你放入东西的种类来自动执行相应的操作。

函数重载的优点：再使用函数的时候，功能相同或类似的函数可以用一个函数实现，减少定义新的函数名，方便使用。

## 一、基本概念

重载概念：

在同一语句块（class 或者 struct）中函数名相同 参数数量不同 或者参数的数量相同，但是参数的类型或者顺序不同

作用：

1. 命名一组功能相似的函数，减少函数名的数量，避免命名空间的污染

2. 提升程序可读性

## 二、实例

注意⚠️

1. 重载和返回值类型无关，只和参数类型，个数，顺序有关

2. 调用时，程序会根据传入的参数类型判断使用哪个重载

总结：

概念  同一个语句块中，函数名相同，参数数量、类型、顺序不同的函数 就成为我们的重载函数

注意 和返回值无关

作用 一般用来处理不同参数的同一类型的

## 练习题

### 1

请重载一个函数
让其可以比较两个int或两个float或两个double的大小
并返回较大的那个值

static int Max(int a, int b){}

static float Max(float a, float b){}

### 2

请重载一个函数
让其可以比较n个int或n个float或n个double的大小
并返回最大的那个值。（用params可变参数来完成）

static int Max(params int arr){}

static float Max(params float arr){}

static double Max(params double arr){}

函数重载

知识点一：基本概念

在同一语句块中（class或者struct）中

函数（方法）名相同

参数数量不同

或者

参数数量相同，但参数的类型类型顺序不同

作用

1、命名一组功能相似的函数，减少函数数名的数量，避免命名空间的污染

2、提升程序可读性

知识点二：实例

注意：

1、重载和返回值无关，纸盒参数类型，个数，顺序有关

2.调用时，程序会自己根据传入的函数类型判断使用哪一个重载

参数数量不同

static int CalcSum(int a,int b,int c)

{

return a + b + c;

}

重载概念

在同一语句块（class或者struct）中，函数名相同，参数的数量不同或者参数数量相同，但参数的类型或者顺序不同

作用：1.命名一组功能形似的函数，减少函数名的数量，避免命名空间的污染       2.提升程序可读性

注意：1.重载和返回值类型无关，只和参数类型，个数，顺序有关      2.调用时，程序会自己根据传入的参数类型判断使用哪一个重载

ref和out也可以构成重载，可选参数不能重载