.Net学习笔记3-.Net基础1.3 方法与递归

1.方法简介
方法(Methon).或函数(Function)
方法主要格式:
返回值类型 方法名(参数类型 参数1,参数类型 参数2……)

{

}
目前来讲所有方法都先加上static,以后讲why
封装一下GetMax方法:
static int GetMax(int[] nums)//参数的名字只在方法内部使用,和调用方法中的参数名字无关
{
int max=num[0];
for(int i=1;i
{
int num=nums[i];
if(num>max)
{
max=num;
}
}
return max;//把执行结果返回
}
调用方法: GetMax(x);
方法就是一堆可以重复使用(复用)的代码段。
执行过程中无法确定的数据以参数形式传递;方法的执行结果以返回值进行返回。不能在方法中定义方法。
方法可以没有参数;方法可以没有返回值(void)。
return:方法中用return返回处理结果,执行return之后方法内部的代码就执行结束了
如果没有返回值,则在需要执行结束的地方return;如果没写return,则在最后一句return;
方法中的局部变量不能被调用的方法访问,如果真要访问只能通过参数传值,
并且只是相当于变量赋值,方法内部对参数的赋值不会影响调用者。方法也不能调用调用者的局部变量。
一个问题:不是所有路径都有返回值。
必须方法的所有执行路径都要有返回值
2.方法重载(OverLoad)
两个方法名字相同,参数不同才能构成重载,和返回值无关;
编写一个获得String[]最长元素的方法GetMax
static string GetMax(string[] nums)
{
string max=num[0];
for(int i=1;i
{
string num=nums[i];
if(num.length>max.length)
{
max=num;
}
}
return max;//把执行结果返回
}
重载(OverLoad):在同一个类中,允许存在一个以上的同名方法,只要其参数个数或者参数类型不同即可。
返回值是否一样无关。如果只是参数名字不一样,也不能构成合法的重载。
即:只有参数类型或者个数不一样,方法才能重名,和参数的名字、返回值类型都没有关系。
编译器怎么样知道应该调用哪个?
只调用参数类型相同的方法;GetMax(string[])调用第二个,GetMax(int[])调用第一个
之前我们用过的方法重载。Console.WriteLine()
3.可变长度数组(params):
int sum(params int[] nums);
就可以这样自由调用sum(3,5);sum(3,9,11,22,5);
这些参数其实还是以数组形式传递过去,在sum看来也是数组,
只不过编译器会自动把参数封装为数组,简化了调用。通过神器ILSpy可看出
可变参数可以声明为各种类型:test1(String... values)
可变参数前面还可以有其他参数,
可变长度参数params,params必须是最后一个参数,而且是数组类型;
sum(int name,params string[] data)。
4.i++  ++i  i=i+1的区别:
i++:先取值再自增
++i:先自增再取值
i=i+1:赋值表达式也是一个值,这个值就是赋值之后=号左边的值

高效率的学习:
同一时间只做一件事情

一件事情一次性完成


5.递归:(面试重点:阶乘和斐波数列的递归算法和非递归算法)
递归:方法自己调用自己
两个条件:递推方法;递归的终止条件:什么情况下不再递归。
static void JGS(int i)
 {
            Console.WriteLine("从前有座山...讲的什么故事呢?" + i);
            if (i <= 5)
             {
            i++;
           JGS(i);//c#代码中执行完第一行代码才会继续往下执行第二行代码,被调用的方法执行完返回后才会往下继续执行
           Console.WriteLine("讲完了"+i);
             }
             
             }
如果没有终止条件,会一直执行下去,直到抛出异常(StackOverflowException):栈内存溢出,
每执行一次JSG(i),都会在栈里面创建一块内存储存int i
每次调用方法,都会为方法创建一块内存空间,一个方法的两次调用就会有两块内存空间
他们的局部变量是不互相影响的、是独立的
c#代码中执行完第一行代码才会继续往下执行第二行代码,被调用的方法执行完返回后才会往下继续执行
阶乘:
//递推方法:f(n)=n*f(n-1)    5!=5*4*3*2*1
//终止条件: n=0 return 1
static int JC(int n)
        {
            if (n < 0)
            {
                throw new Exception("n不能是负数");
            }
            if (n == 0)
            {
                return 1;
            }
            return n * (JC(n - 1));
        }
斐波那契数列:
//1,1,2,3,5,8,13,21.....第n位(从0开始)值是多少?
        //递推方法:f(n)=f(n-1)+f(n-2)。终止条件:n=0,1 return 1。
        static int fib(int n)
        {
            if (n < 0)
            {
                throw new Exception("n不能是负数");
            }
            if (n == 0 || n == 1)
            {
                return 1;
            }
            return fib(n - 1) + fib(n - 2);
        }
//n从1开始计算
private static int Fib4(int n)
        {

            if (n < 1)
            {
                throw new Exception("n需大于0");
            }
            if (n == 1 || n == 2)
            {
                return 1;
            }
            return Fib(n - 2) + Fib(n - 3);
        }
递归的缺点:效率低,占内存  有的递归算法可以转为非递归算法
当你无法预测到底要递归多少次的时候用非递归算法更加恰当
非递归算法:
阶乘:
static int jiecheng2(int n)
        {
            if (n < 0)//参数合法性校验是面试时候的加分项!
            {
                throw new Exception("n不能是负数");
            }
            //n=3 n*(n-1)*(n-2)*1=3*2*1*1
            int result = 1;
            for (int i = 1; i <= n; i++)
            {
                result = result * i;
            }
            return result;
        }
菲波数列:
private static int Fib2(int n)
        {
            if (n < 0)
            {
                throw new Exception("n不能为负数");
            }
            if (n == 0 || n == 1)
            {
                return 1;
            }
            int[] nums = new int[n+1];
            nums[0] = 1;
            nums[1] = 1;
            for (int i = 2; i < n+1; i++)
            {
                nums[i] = nums[i-1] + nums[i-2];
Console.WriteLine(string.Join(",",nums));//string.Join把一个集合用某个分隔符拼接起来,成为字符串
            }
            return nums[n];
        }
private static int Fib3(int n)
        {
            if (n < 0)
            {
                throw new Exception("n不能为负数");
            }
            int i1 = 1;
            int i2 = 1;
            int i3 = 0;
            for (int i = 1; i < n; i++)
            {
                i3 = i1;
                i1 = i2;
                i2 = i1 + i3;
            }
            return i2;
        }

你可能感兴趣的:(学习笔记,.net,c#)