Java方法详解

方法

1.方法的概念

(1).什么是方法

方法类似于C语言中的函数，我们重在体会与理解，不必去强硬地去背
1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子.

(2).方法的定义

我们最早见过的是main方法，我们可以把它作为C语言中的函数去理解
例如： 定义个main方法：

    public static void main(Sting[] args){

    }
    //public static（这两个东西不能省略掉） 
    //void是指的是无类型的返回值， main是方法名，其后的括号中是形式参数列表
    所以我们应定义一个：
    public static 返回值 方法名(参数类型 形参){
        方法体代码
        return(返回值)
     }

在这里：我要先就关于大驼峰与小驼峰的命名方式先说一下
大驼峰：每个单词的首字母大写： 例如 DemoTest,MyClass
小驼峰：只有第一个单词的首字母大写，后续每个单词的首字母都大写，其余小写 例如：myFunction,userProfile等

示例：判断某年是不是闰年

public static boolean isLeapYear1(int year){
        if(0 == year % 4 && 0 != year % 100 || 0 == year %400){
            System.out.println(year + "是闰年");
            return true;//由于boolean类型，所以需要返回两个值
        }else{
            System.out.println(year + "不是闰年");
            return false;
        }
}

    public static void main(String[] args) {
        Scanner sc = new Scanner (System.in);
        int year = sc.nextInt();
        isLeapYear1(year);
        sc.close();
    }

注意事项：
1. 修饰符：现阶段直接使用public static 固定搭配
2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
void
3. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
4. 方法体：方法内部要执行的语句
5. 在java当中，方法必须写在类当中，不能嵌套定义
6. 在java当中，没有方法声明一说，声明必须要在主函数之前，所以我们可以不用在意
7. 一个方法可以多次去调用
示例：

public static void main9(String[] args) {
         boolean flg1 = isLeapYear3(2025);//2025是实际参数
        System.out.println(flg1);
         boolean flg2 = isLeapYear3(2024);//2025是实际参数
        System.out.println(flg2);
}

    public static boolean isLeapYear3(int year) {//int year是形式参数
        if (0 == year % 4 && 0 != year % 100 || 0 == year % 400) {
            return true;//由于boolean类型，所以需要返回两个值
        } else {
            return false;
        }
    }  

(3).实参与形参的关系

import  java.util.Scanner;
public static int func1(int x) {
        int ret = 1;
        for (int j = 1; j <= x; j++) {
            ret *= j;
        }
        return ret;
}

public static void main1(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int ret = func1(a);
        System.out.ptrintln(ret);
}        

在Java中，实参的值永远都是拷贝到形参之中，形参和实参本质是两个实体。
但是两者的栈帧并不一样，都是在一个栈空间（虚拟机栈）中，但是所处的区域不同

//老生常谈的例子
//交换变量
//正常版：
    public static void main2(String[] args){
        int a = 10;
        int b = 20;
        int temp = 0;
        temp = a;
        a = b;
        b =temp;
        System.out.println(a + " " + b);
    }
    //方法版
    public static void swap4(int x ,int y) {
        int temp = 0;
        temp = x;
        x = y;
        y =temp;
    }
    //当这个方法走完，那么也就是把x和y的变量的值进行交换完成。
    //但是也只是把它们被赋予的值进行交换完成
    //对于a和b的本身没有任何影响
    public static void main3(String[] args){
        int a = 10;
        int b = 20;
        //a和b的局部变量
        //作用域：在方法中
        //生命周期：调用方法的创建，方法调用结束的时候来销毁
        //内存：储存在栈上
        //Java中由于其安全性，不会让你拿到局部变量的地址
        System.out.println("交换前"+ a + " " + b);
        //swap(a,b);
        System.out.println("交换后"+ a + " " + b);
    }

就目前来看，学完类和对象才能知道怎么交换,Java中没有指针这一个概念；
但是有引用这一个概念，“引用”叫做引用变量；引用变量中存入的是地址。
数组就是一个引用变量
当一个方法没有返回值，所以我们就要用void类型来接收

2.方法重载

(1).方法重载的概念

在Java中如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

//    public static int addInt(int x,int y){
//        return x + y;
//    }
//
//    public static double addDouble (double x,double y){
//        return x + y;
//    }

    //这时候方法里的名字不一样，所以我们可以创建新的方法名从而计算。
    //当然这不是方法重载
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
//        System.out.println(addInt(a, b));
        //System.out.println(add(a, b));
        double c1 = sc.nextDouble();
        double c2 = sc.nextDouble();
//        System.out.println(addDouble(c1,c2));
        //System.out.println(add(c1,c2));
        sc.close();
    }
    public static int add(int x,int y){
        return x + y;
    }
    public static double add(double x,double y){
        return (int)(x + y);
        //这么做强制转化，如果仅仅是返回值不同，这种仅有返回值改变，那么这就不叫做方法重载
    }
    //这部分方法的操作叫做重载，只有一个名字都是add

方法重载：
1.方法名相同
2.参数列表不同【数据类型，变量个数，顺序】
3.返回值不影响重载

3.递归（C语言详细讲过）

必要条件：
1.将原问题转为多个子问题，（子问题必须要与原问题解法相同）
2.递归出口

public static int func(int n){
        if(n == 1 || n == 0){
            return 1;
        }
        int ret = n * func(n-1);
        return ret;
    }
    public static void main5(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(func(5));
    }    

调用栈：
方法调用的时候，会有一个“栈”这样的内存空间描述当前的调用关系，称为调用栈.
每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息.

按顺序打印1 2 3 4

public static void print (int n){
       if(n > 9){
           print(n / 10);
       }
       //当n为一个数时，那么可以直接打印
       System.out.print(n % 10 + " ");
   }

   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int n = sc.nextInt();
       print(n);
   }

求斐波那契数列第N项数

public static int funca(int n) {
        /*if(n <= 2)*/if(n == 1 || n == 2){
            return 1;
            //这两种写法均可以
        }else {
            return  funca(n - 1) + funca(n - 2);
        }
}

    public static void main8(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(funca(n));
    }

这个代码不适合用递归去写，程序执行速度极慢. 原因是进行了大量的重复运算.

//迭代写法
public static long funcaA(long n){
        long a = 1;
        long b = 1;
        long c = 1;
        while(n > 2){
            c = a + b;
            a = b;
            b = c;
            n--;
        }
        return c;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        System.out.println(funcaA(n));
    }
    //后续：在二叉树我们经常需要使用递归去解决问题
    ```
好了，今天我们就分享到这里了，如果有什么不足，劳烦大家帮忙在评论区指出，谢谢大家了！让我们下一次见！