五、Java基础之方法

一、方法重载

/*
*1. 关于方法重载：
* 1.不使用方法重载，分析缺点：
* 记忆的方法较多，代码不美观
* 2.使用方法重载，分析优点：
* 3.什么情况下发生方法的重载：
* a、发生在同一个类中
* b、方法名相同
* c、参数列表不同（类型，个数，顺序）
* d、和返回的类型无关
* e、和方法的修饰符无关
*/

public class Day001 {
    
    public static void main(String[] args){
        //方法不重载
        System.out.println(Compute.sumInt(10, 12));
        
        System.out.println(Compute.sumDouble(10.0, 12.0));

        System.out.println(Compute.sumLong(10L, 12L));
        
        //方法重载
        System.out.println(Computer.sum(10, 12));
        
        System.out.println(Computer.sum(10.0, 12.0));

        System.out.println(Computer.sum(10L, 12L));
        
        
        

    }
    //其他方法重载的情况：

    public static void m1(int a){}
    public static void m1(double a){}
    
    public static void m2(int a,int b){}
    public static void m2(int a){}
    
    public static void m3(int a,double b){}
    public static void m3(double a,int b){}
    
    //一下两个方法没有构成重载
    //方法重复，编译不能通过
    //public static void m4(int a){}
    //public static void m4(int b){}
    
    

}

//方法 不重载
class Compute{
    public static int sumInt(int a,int b){
        return a+b;
    }
    public static double sumDouble(double a,double b){
        return a+b;
    }
    public static long sumLong(long a,long b){
        return a+b;
    }
}

//方法重载
class Computer{
    
    public static int sum(int a,int b){
        return a+b;
    }
    public static double sum(double a,double b){
        return a+b;
    }
    public static long sum(long a,long b){
        return a+b;
    }
}

2.栈

* 栈stack
* 存储数据特点：后进先出
* 入栈，压栈，push
* 栈底元素，栈顶元素
* 出栈，弹栈，pop
* 1.方法在调用的时候，才回会给该方法在内存中分配空间
* 2.如果这个方法只是定义没有调用，则不需要再内存中分配空间
* 3.方法在调用时候在栈中分配空间（jvm内存中有一块内存是栈内存）
* 4.方法调用其实就是“压栈”，方法结束其实就是“弹栈”
*/
/*
* 使用图形画出以下 程序的执行流程
*
*/

public class Day02 {
    public static void main(String[] args){
        int i=100;
        m1(i);
        System.out.println("Hello World!");
    }
    
    
    public static void m1(int i){
        m2(i);
    }
    public static void m2(int i){
        m3(i);
    }
    public static void m3(int i){
        System.out.println("m3方法中的i="+i);
    }
    //方法只要被调用 ，才分配空间
    public static void m4(int i){}

}

3.递归

/*
* 关于方法的递归调用：
* 1.方法的递归调用就是方法自身调用自身
* 2.已下程序因为没有结束条件，所有一直压栈，没有弹栈，导致栈内存溢出出现错误（StackOverflowError）
* 所以递归必须要有结束条件
* 题： 不是用递归，计算1-n的求和
* n的阶乘
*/

public class Day03 {
    public static void main(String[] args){
        //m1();
        int n=5;
        int result1=Method1(n);
        System.out.println(result1);
        int result2=Method2(n);
        System.out.println(result2);
        int result3=Method3(n);
        System.out.println(result3);
    }
    
//    public static void m1(){
//        m1();
//    }
    
    //使用for循环，求和
    public static int Method1(int n){
        int sum=0;
        for(int i=0;i<=n;i++){
            sum+=i;
        }
        return sum;
        
    }
    public static int Method2(int n){
        if(n==1){
            return 1;
        }else{
            return n+Method2(n-1);
        }
    }
        
    public static int Method3(int n){
        if(n==1){
            return 1;
        }else{
            return n*(Method3(n-1));
        }
    }
            


}