方法、面向对象

一、方法

定义：是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个C#程序至少有一个带有Main方法的类，一个程序从Main开始，从Main结束。

1.每一个C#程序中至少含有一个Main。

声明

<Access Specifier> <Return Type> <Method Name>(Parameter list){
    Method Body;
}
<访问修饰符> <返回类型> <方法名称>(参数列表){
	方法体;
}

2.方法中默认访问修饰符：private

3.方法中的形参:在定义方法的时候，小括号中的声明的参数，不参与任何工作；

​ 实参：在调用方法的时候小括号中的参数，才是方法真正执行的参数。

4.try…catch

尝试执行try里面的代码，如果里面的某句代码报错，立刻进入catch中执行，如果无报错，则执行完try中的代码。

5.递归算法：在一个方法中调用自己。

6.方法的返回值类型：

void：没有返回值类型

7.return break continue区别

return：跳出当前循环，直到代码块结束；

break：跳出当前循环，进行之后的代码；

continue：跳出当前循环，执行下一次循环。

8.方法的重载

是方法多态的一种表现，是指在一个类中方法名相同，方法的参数列表不同（参数的个数，类型，不同类型的排列顺序不同）。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 方法的重载
{
    class Program
    {
        static void Main(string[] args)
        {
            Max(); 
            Max(20,23);
            Max("wuke", 100);
            Max(100, "wuke");
            Console.ReadLine();
        }
        static void Max()
        {
            Console.WriteLine("最大的Int正整数是:2147483647");

        }
        static void Max(int num1,int num2)
        {
            Console.WriteLine((num1>num2?num1:num2)+"最大");
        }
        static void Max(string name,int num)
        {
            Console.WriteLine(name + "写了个数字：" + num);
        }
        static void Max( int num ,string name)
        {
            Console.WriteLine(num + "这个数字是：" + name+"写的");
        }
    }
}

9.out ref parems

out:至少返回两种类型，一种是判断这个字符串是否能够转换成int型的结果为true、false；另一个数值是转换成int之后的整数；

方法中的out参数在方法体结束之前必须对out参数进行赋值；

遇到方法中的形参是out或ref类型，则在调用方法的时候同样实参也必须带有out或热点关键字；

在调用具有out类型参数的方法时，需要准备一个相同类型的变量接受out的结果，并且必须带有关键字。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace out参数
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入第一个数");
            string str = Console.ReadLine();
            int num = -1;
            if (IsNum(str,out num))
            {
                Console.WriteLine("可以转成数字:"+num);
            }
            Console.ReadLine();
        }
        /// <summary>
        /// 判断输入的这个字符串是否是整数
        /// </summary>
        /// <param name="str">输入的字符串</param>
        /// <param name="res">如果那个字符串能够转成整数，则使用res装起来</param>
        /// <returns></returns>
        static bool IsNum(string str,out int res)
        {
            try
            {
                //如果传进去的字符串能转成数字，则转换成数字后装进res里面
                res = int.Parse(str);
                return true;
            }
            catch
            {
                //如果传进来的字符串不能转成数字，则给res赋予0
                res = 0;
                return false;
            }
        }

    }
}

ref:引用传参

普通方法传参对基本参数没有影响，只有在方法中的某些地方参数值会发生改变；

引用传参传送方法中的参数，如果在方法内发生改变，那么这个参数变量将永久性发生改变。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ref参数
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入一个数字");
            int i= int.Parse(Console.ReadLine());
            Console.WriteLine("输入的数是：" + i);
            Add(ref i);
            Console.WriteLine("输入的数值是：" + i);
            Console.ReadLine();
        }
        static void Add(ref int num1)
        {
            Console.WriteLine("经过计算之后的结果是："+(++num1));
        }
    }
}

parems:可变参数

当方法中的形参为parems类型时，必须保证形参是一维数组类型。当调用时，遇到parems参数，我们可以传递一个相同类型的数组，也可以直接在调用方法时填入任意数量的这种类型的参数，方法执行时会自动将填入的所有的这种类型的参数转换为数组。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace parems参数
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.WriteLine(Max(12, 32, 55, 77, 21, 3));
            //Console.ReadLine();
            //随机输出不重复的数


            Console.WriteLine("请输入第一条边:");
            int i = int.Parse(Console.ReadLine());
            Console.WriteLine("请输入第二条边:");
            int j = int.Parse(Console.ReadLine());
            Console.WriteLine("请输入第三条边:");
            int k = int.Parse(Console.ReadLine());
            tri(i, j, k);
            Console.ReadLine();
            
        }
        static void tri(int i,int j,int k)
        {
            if (i==j&&j==k)
            {
                Console.WriteLine("是等边三角形");
            }
            if (i==j || j==k || k==i)
            {
                Console.WriteLine("是等腰三角形");
            }
            if (i==j && i*i+j*j==k*k)
            {
                Console.WriteLine("是等腰直角三角形");
            }
            else if (i*i+j*j==k*k)
            {
                Console.WriteLine("是直角三角形");
            }
            else if (i+j>k && i+k>j && j+k>i)
            {
                Console.WriteLine("是普通三角形");
            }
            else
            {
                Console.WriteLine("不能构成三角形");
            }
        }
    //static int Max(params int[] array)
    //{
    //    for (int i=0;i<array.Length-1;i++)
    //    {
    //        for (int j=0;j<array.Length-i-1;j++)
    //        {
    //            if (array[j]>array[j+1])
    //            {
    //                int temp = array[j];
    //                array[j] = array[j + 1];
    //                array[j + 1] = temp;
    //            }
    //        }
    //    }
    //    return array[array.Length - 1];
    //}
}
}

二、面向对象

1.定义：通过封装对象的属性实现对象的方法、事件以此得到最终的对象。

2.三大特征：

封装：减少代码的冗余性，优化代码，安全性

继承：实现多重使用

多态：实现代码的各种使用状态

3.在静态(static)的函数中只能调用外部的静态和函数变量。

案例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _01方法
{
    class Program
    {
        static void Main(string[] args)
        {
            //先输入第一个数
            Console.WriteLine("请输入第一个数:");
            string num1 = Console.ReadLine();
            //判断输入的这个数是否是整数，如果不是整数，提示重新输入第一个数
            //实参：真正的进行方法中使用的参数
            int number1 = CheckNum(num1);
            //输入第二个数
            Console.WriteLine("请输入第二个数:");
            string num2 = Console.ReadLine();
            int number2 = CheckNum(num2); 
            //判断输入的这个数是否是整数，如果不是整数，提示重新输入第二个数
            Console.WriteLine("请选择运算类型：1.+    2.-    3.*    4./    5.%");
            //局部变量
            string fun = Console.ReadLine();
            GetResult(fun,number1, number2);
            Console.ReadLine();
        }
        /// <summary>
        /// 检测这个字符串是否能够转换为32位有符号整数
        /// </summary>
        /// <param name="num"></param>
        static int CheckNum(string num)
        {
            //尝试执行里面的代码，如果里面的某句代码报错，立刻进入catch中的执行，如果无报错，则执行完try中的代码
            try
            {
                //方法的形参：不参与任何工作
                int i = int.Parse(num);
                //方法中采用return关键字进行返回结果
                return i;
            } 
            catch
            {
                Console.WriteLine("输入的数字有误，请重新输入！");
                string str = Console.ReadLine();
                //递归算法
                return CheckNum(str);

            }
        }

        static void GetResult(string fun,int num1,int num2)
        {
            int res = 0;
            string yun = "";
            switch (fun)
            {
                case "1":
                    res = num1 + num2;
                    yun = "+";
                    break;
                case "2":
                    res = num1 - num2;
                    yun = "-";
                    break;
                case "3":
                    res = num1 * num2;
                    yun = "*";
                    break;
                case "4":
                    res = num1 / num2;
                    yun = "/";
                    break;
                case "5":
                    res = num1 % num2;
                    yun = "%";
                    break;
                default:
                    Console.WriteLine("请重新输入运算符:");
                    string str = Console.ReadLine();
                    GetResult(str, num1, num2);
                    return;
            }
            Console.WriteLine("{0}{1}{2}={3}", num1, yun,num2, res);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lx
{
    class Program
    {
        static void Main(string[] args)
        {
            //1,使用方法返回出一个数组中的最大值
            int[] array = { 23, 12, 3, 56, 39,  5 };
            //Console.WriteLine("最大值:" + Max(array));
            Console.WriteLine("最小值"+Min(array));

            Console.WriteLine("请输入年份");
            int year = int.Parse(Console.ReadLine());
            Console.WriteLine(Year(year));

            Console.ReadLine();

        }
        static int Min(int[] array)
        {
            for (int i = 0; i < array.Length-1; i++)
            {
                for (int j = 0; j < array.Length-i-1; j++)
                {
                    if (array[j]<array[j+1])
                    {
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
            return array[array.Length - 1];
        }
        //输入一个年份，返回这一年是闰年还是平年
       static string Year(int year)
        {
            if (year%4==0 || year%400==0)
            {
                return year + ":是闰年";
            }
            return year + ":是平年";
        }
    }
}