.NET 基础一步步一幕幕[面向对象之方法、方法的重载、方法的重写、方法的递归]

方法、方法的重载、方法的重写、方法的递归

方法:

将一堆代码进行重用的一种机制。

语法：

[访问修饰符] 返回类型 <方法名>（参数列表）{

方法主体；

}

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

[访问修饰符] void <方法名>（）{

方法主体；

}

如果需要写返回值，返回类型写需要返回的类型：

例如返回string类型：

[访问修饰符] string <方法名>（）{

方法主体；

}

方法名：Pascal 每个单词的首字母都大些。其余字母小写

参数列表：完成这个方法所必须要提供给这个方法的条件。如果没有参数，小括号也不省略。

方法写好后，如果想要被执行，必须要调用。

方法的调用语法：类名.方法名(参数);

代码展示：

       static void Main(string[] args)

        {

            //计算两个整数之间的最大值

		   //调用有返回值的方法

            int max = Program.GetMax(66, 88);

		   //调用没有有返回值的方法

		   Write();

            Console.WriteLine(max);

            Console.ReadKey();

        }

        /// <summary>

        /// 计算两个整数之间的最大值并且将最大值返回

        /// </summary>

        /// <param name="n1">第一个整数</param>

        /// <param name="n2">第二个整数</param>

        /// <returns>将最大值返回</returns>

        public static int GetMax(int n1, int n2)

        {

            return n1 > n2 ? n1 : n2;

        }

        /// <summary>

        /// 没有返回值的方法

        /// </summary>

        public static void Write()

        {

            Console.WriteLine("计算结束。。。");

        }

运行结果：

方法的练习：

static void Main(string[] args)

        {

            //读取输入的整数

            //多次调用(如果用户输入的是数字,则返回,否则提示用户重新输入)

            Console.WriteLine("请输入一个数字");

            string input = Console.ReadLine();

            int number = GetNumber(input);

            Console.WriteLine(number);

            Console.ReadKey();

        }

        /// <summary>

        /// 这个方法需要判断用户的输入是否是数字

        /// 如果是数字，则返回

        /// 如果不是数字，提示用户重新输入

        /// </summary>

        public static int GetNumber(string s)

        {

            while (true)

            {

                try

                {

                    int number = Convert.ToInt32(s);

                    return number;

                }

                catch

                {

                    Console.WriteLine("请重新输入");

                    s = Console.ReadLine();

                }

            }

        }

运行结果：

方法的重载

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

参数不同，分为两种情况

1)、如果参数的个数相同，那么参数的类型就不能相同。

2)、如果参数的类型相同，那么参数的个数就不能相同。

***方法的重载跟返回值没有关系

代码展示：

       static void Main(string[] args)

        {

            M();

            M(1, 2);

            double b = M(0.1, 0.3);

            Console.WriteLine(b);

            M(1,2,3);

            string s = M("1", "2");

            Console.WriteLine(s);

            //Console.WriteLine 也是方法的重载（可以F12进方法看看）

            Console.WriteLine(1);

            Console.WriteLine(1.4);

            Console.WriteLine(true);

            Console.WriteLine('c');

            Console.WriteLine("123");

            Console.WriteLine(5000m);

            Console.ReadKey();

        }

        public static void M()

        {

            Console.WriteLine("无参数的方法！！！");

        }

        public static void M(int n1, int n2)

        {

            int result = n1 + n2;

            Console.WriteLine(result);

        }

        public static double M(double d1, double d2)

        {

            return d1 + d2;

        }

        public static void M(int n1, int n2, int n3)

        {

            int result = n1 + n2 + n3;

            Console.WriteLine(result);

        }

        public static string M(string s1, string s2)

        {

            return s1 + s2;

        }

运行结果：

Console.WriteLine 源代码一部分(详情F12进方法自行查看)：

方法的重写

“重写”父类方法就是修改它的实现方式或者说在子类中对它进行重新编写。

重写必须发生在继承基础之上

1、重写父类的方法要用到override关键字(具有override关键字修饰的方法是对父类中同名方法的新实现)

2、要重写父类的方法，前提是父类中该要被重写的方法必须声明为virtual或者是abstract类型。给父类中要被重写的方法添加virtual关键字表示可以在子类中重写它的实现。(注意：C#中的方法默认并不是virtual类型的，因此要添加virtual关键字才能够被重写)

3、virtual关键字用于将方法定义为支持多态，有virtual关键字修饰的方法称为“虚拟方法”

[访问修饰符] virtual [返回类型] 方法名（参数列表）

{

//虚拟方法的实现，该方法可以被子类重写

}

代码展示：

namespace inheritDemo2

    {

        class Employee

        {

            public virtual void EmpInfo()

            {

                Console.WriteLine("用virtual关键字修饰的方法是虚拟方法");

            }

        }

         class DervEmployee : Employee

        {

            public override void EmpInfo()

            {

                base.EmpInfo();//base关键字将在下面拓展中提到

                Console.WriteLine("该方法重写base方法");

            }

        }

         class Test

        {

            static void Main(string[] args)

            {

               DervEmployee objDervEmployee = new DervEmployee();

               objDervEmployee.EmpInfo();

                //注意：objDervEmployee派生类的实例是赋给Employee类的objEmployee的引用，

                 // 所以objEmployee引用调用EmpInfo()方法时 还是调用DervEmployee类的方法

                 Employee objEmployee = objDervEmployee;

               objEmployee.EmpInfo();

             }

        }

}

拓展：base关键字用于从子类中访问父类成员。即使父类的方法在子类中重写，仍可以使用base关键字调用。而且，在创建子类实例时，可以使用base关键字调用父类的构造函数。使用base关键字只能访问父类的构造.

方法的递归

方法自己调用自己。（注意：可是这个方法体里面必须有一个条件,可以使这个递归停下来的条件,要不然就成了死循环,出不了这个方法.）

代码展示：

      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();

        }

运行结果：

总结：

方法：将一堆代码进行重用的一种机制。

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

方法的重写： “重写”父类方法就是修改它的实现方式或者说在子类中对它进行重新编写。

方法的递归：方法自己调用自己。

本篇就到这里了，最后打个小广告：QQ群： .NET 一步步一幕幕 群号：590170361 （加群备注：博客园看到的）

巴特西

.NET 基础一步步一幕幕[面向对象之方法、方法的重载、方法的重写、方法的递归]

最新文章

热门文章

巴特西

.NET 基础 一步步 一幕幕[面向对象之方法、方法的重载、方法的重写、方法的递归]

最新文章

热门文章

.NET 基础一步步一幕幕[面向对象之方法、方法的重载、方法的重写、方法的递归]