Java方法入门级详细讲解（包含重载，递归，常见问题，常用方法）

Java方法

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

1. 修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
2. 返回值类型: 方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没返回值。在这种情况下，returnValueType 是关键字void.
3. 方法名:是方法的实际名称。方法名和参数表共同构成方法签名参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。形式参数:在方法被调用时用于接收外界输入的数据实参:调用方法时实际传给方法的数据。
4. 方法体:方法体包含具体的语句，定义该方法的功能。

形式参数不可以赋值

案例

修饰符 返回值类型 方法名（参数类型 参数名）{
	...
	方法体
	...
	return 返回值；
}
//案例
package com.cai;
public class Demo01 {
    public static void main(String[] args) {

        //调用方法
        int rs = sum(4,6);
        System.out.println(rs);
    }

    //建立方法
    public static int sum(int a ,int b){
        int c =a+b;
        return c;
    }
}

打印单行或多行数据

注意无返回值类型则申明为：void

有返回值类型的方法必须要有返回值：return

package fangfa;

public class Demo02 {
    public static void main(String[] args) {

        printHelloWorld(5);
    }
    //void无返回值类型的意思
    public static int printHelloWorld(int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("hello,world");
        }
        return n; //返回值，不可以放在循环中
    }
}

方法使用的常见问题

• 方法在类中的位置放前放后无所谓，但一个方法不能定义在另一个方法里面

• 方法的返回值类型写void(无返回申明)时，方法内不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据

• return语句的下面，不能编写代码，属于无效的代码，执行不到这儿

• 方法不调用就不会执行，调用方法时，传给方法的数据，必须严格匹配方法的参数情况

• 调用有返回值的方法，有3种方式:1，可以定义变量接收结果 2、或者直接输出调用，3、甚至直接调用。

• 调用无返回值的方法，只有1种方式:只能直接调用。

设计方法技巧

1. 方法是否需要接收数据进行处理
2. 方法是否需要返回数据
3. 方法要处理的业务（编程能力）

案例实操

计算1-n的和

package fangfa;
public class Demo03 {

    public static void main(String[] args) {

        System.out.println(add(5));
        System.out.println(add(100));

    }

    public static int add(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;

    }
    
}

判断奇偶数

package fangfa;

public class Demo04 {
    public static void main(String[] args) {
        add2(10);
        add2(103);
    }
    public static void add2(int dog){

        if (dog % 2==0){
            System.out.println(dog+"是偶数");
        }else {
            System.out.println(dog+"是奇数");
        }
    }
}

方法运行区域：栈

栈的特点：后进先出

优点：保证一个方法调用完另一个方法后，可以回来

Java参数传递机制

都是值传递

实参：在方法内部定义的变量

形参：定义方法时“（…）”中所声明的参数

案例

package fangfa;

public class MethodDemo01 {
    public static void main(String[] args) {
        //方法的传递机制，值传递
        int a = 10;
        change(a);
        System.out.println("main="+a);
    }

    public static void change(int a){
        System.out.println("change1="+a);

        a = 20;
        System.out.println("change2="+a);

    }
}

引用类型的参数传递

案例打印[11,22,33,44,55]

package fangfa;

public class Demo05 {
    public static void main(String[] args) {
        int[]arr = new  int[]{11,22,33,44,55};
        arr(arr);
        //为空
        int[]arr2 = null;
        arr(arr2);
        //空数组
        int[]arr3 = {};
        arr(arr3);
    }
    public static void arr(int[] arr){
        //判断是否为空
        if (arr == null){
            System.out.println(arr);
            return;
        }
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
/*
            if (i== arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
*/
        //优化代码===============================================三元运算符
            System.out.print(i==arr.length-1 ? arr[i] : arr[i]+",");
        }
        System.out.println("]");
    }
}

数组对比案例

package fangfa;

public class Demo06 {
    public static void main(String[] args) {
        int[]arr1 = new int[]{1,2,3,4};
        int[]arr2 = new int[]{1,2,3,4,5};
        System.out.println(to(arr1,arr2));
        
    }
    public static boolean to(int[] arr1,int[] arr2) {

        if (arr1 == null && arr2 == null) {

            return true;
        } else if (arr1 == null || arr2 == null) {
            
            return false;
        } else if (arr1.length != arr2.length) {

            return false;
        } else for (int i = 0; i < arr1.length; i++) {

            if (arr1[i] != arr2[i]) {
                return false;
            }
            }
            return true;
    }

}

方法的重载

可变参数

在方法声明中，指定参数类型后加一个省略号

发射导弹案例

package fangfa;

public class Demo09 {
    //目标：
    public static void main(String[] args) {
        fire();
        fire("米国");
        fire("岛国",80);

    }

    public static void fire(){
        fire("岛国");
    }
    public static void fire(String country){
        fire(country,1);
    }

    public static void fire(String country,int number){
        System.out.println("发射了"+number+"枚导弹给"+country);
    }
}

递归

//阶乘案例
package scanner;

public class Demo13 {
    public static void main(String[] args) {
        System.out.println(f(3));
    }

    public static int f(int n){

        if (n==1){
            return 1;

        }else {
            return n*f(n-1);
        }
    }
}

边界条件：边界

前阶段：

返回阶段n*（n-1）

深度越大占用空间内存越大

能不用尽量不用（思路的解决）

必须在最后面

return关键字

作用：跳过该段

案例演示：分母为0跳过案例

package fangfa;

public class Demo08 {
    public static void main(String[] args) {
        //用于立即跳出return;
        System.out.println("程序开始");
        chu(2,0);
        System.out.println("程序结束");
    }
    public static void chu(int a,int b){
        if (b==0){
            System.out.println("分母有0");
            return;
        }
        int c = a/b;
        System.out.println(c);
    }
}
tring[] args) {
        //用于立即跳出return;
        System.out.println("程序开始");
        chu(2,0);
        System.out.println("程序结束");
    }
    public static void chu(int a,int b){
        if (b==0){
            System.out.println("分母有0");
            return;
        }
        int c = a/b;
        System.out.println(c);
    }
}