void-关键字

一个 void 方法，它不返回任何值。

public static void print() {for(int i=1;i<=9;i++) {for(int j=1;j<=i;j++) {System.out.print(j+"*"+i+"="+i*j+"\t");
        }
        System.out.println();// 换行}
}

一个带有返回值类型的方法, 必须带出返回值。

public static int getSum(int a,int b){return a+b;}

return 为跳出方法或返回值。

<font color=”red”>注意：在一个作用域内 return 之后不能再存在代码</font>

public static int getSum(int a,int b){
    return a+b;
    System.out.println("return 后不能存在代码!!!"); // 不可达语句
}

return 语句:

return 语句可以出现在任何 (有返回值和没有返回值) 方法中

return 语句在没有返回值的方法中，用来提前结束方法

// 打印出 1~5 之间前两个数
public static void test(){for(int i=1;i<=5;i++){if(i==3){return; // 结束方法}
        System.out.println(i);
    }
}

return 语句在有返回值的方法当中，有两个作用：提前结束方法，送出结果。

// 求出 1~100 之间前 5 个能被 2 整除数的和
public static int getSum(int a,int b){
    int sum=0; // 和
    for(int i=1;i<=100;i++){
        sum+=i;
        if(i==5){return sum; //1)提前结束方法 2) 带出返回值
        }
    }
}

一个方法只能执行一条 return 语句
在一定会被执行的 return 语句后，写的语句为不可达语句，程序自动检测这种语句，永远不会被执行到，报错。
在循环中无条件的 break 后写语句，会出现不可达语句
在死循环 (没有 break 来结束的死循环) 后写语句，会出现不可达语句

编写一个方法时，请思考这四个方面:

1)、确定方法的功能

2)、确定方法的名称

3)、此方法能否独立运行，不能独立，需要外界数据参与运算，确定形参。

4)、此方法完成后，其结果是否直接影响调用处的后续操作，如果影响，确定返回类型，不影响则为 void

方法的签名，确保在一个类中的唯一性。方法的签名只看方法名和形参

(类型个数和顺序)，与修饰符返回类型和形参名无关。

public static void getSum(int x,int y){} -->getSum(int x,int y)为方法签名

在调用方法时，形参与实参，接收类型与返回类型和返回值类型应该保持兼容。

①形参 >= 实参

public static void main(String[] args) {
   // int i=5;
    byte i=5;
    int x=test(i); // i 实参
}
public static int test(int d){ // d 形参
    return 'a';
}

②接收类型 >= 返回值类型 >=return 类型

public static void main(String[] args) {int x=test(5);  // x 为接收返回值的变量类型
}
//int 为方法的返回值类型(规定 return 后面数据的值只能 <=int)
public static int test(int d){ // d 形参
    return 'a'; //return 后面数据的类型
}

值传递和引用传递：
所谓值传递，就是说仅将对象的值传递给目标对象，就相当于 copy；系统将为目标对象重新开辟一个完全相同的内存空间。

public static void main(String[] args) {
    byte i=5;
    test(i); // 相当于 test(5) --> 值传递
    System.out.println(i);  //5
}
public static void test(int i){i++; // 局部变量 i ++;}

所谓引用，就是说将对象在内存中的地址传递给目标对象，就相当于使目标对象和原始对象对应同一个内存存储空间。此时，如果对目标对象进行修改，内存中的数据也会改变。

public static void main(String[] args) {Person p = new Person("张三",18);
    test(p); // i 实参
    System.out.println(p.age); // 引用传递 | p 指向对象的地址值
}
public static void test(Person p){p.age++;}

JVM 内存划分:

栈的特点:

站描述的时方法执行的内存模型, 每个方法被调用都会创建一个栈帧()

在程序运行期, 方法的内存分析:

public class MethodTest {public static void main(String[] args) {
        int w=5;
        int h=7;
        int area=getArea(w,h);
        System.out.println(area);
    }
    // 求面积
    public static int getArea(int w,int h) {return w*h;}
}

过程 1:

1)程序要运行, 当执行 java 命令时, 把类的信息 MethodTest.class 加载到内存

2)虚拟机 JVM 调用 main 方法, 主方法压栈运行, 在栈中为 main 方法开辟栈帧, 存储 main 中出现的局部变量

int w=5; int h=35;

3)main 方法中调用 getArea()方法, 栈中为 getArea 方法开辟栈帧

4)方法压栈执行并为形参赋值 int w=5;int h=7; 计算结果并 return 35; 将结果返回方法的给调用者

5)方法 getArea 执行完毕, 弹栈释放内存

6)继续执行 main 方法中内容, 栈空间中存储局部变量 int area = 35;getArea 方法返回值赋值给 area

7)main 方法执行完毕, 弹栈释放内存空间

一般来说，功能点相同的方法才适合使用重载，重载必须满足如下要求：

①必须是同一个类

②方法名必须相同

③参数列表不同

public class Demo {
 
    // 一个普通得方法，不带参数，无返回值
    public void add(){//method body}
    
    // 重载上面的方法，并且带了一个整形参数，无返回值
    public void add(int a){//method body}
    
        // 重载上面的方法，并且带了两个整型参数，返回值为 int 型
    public int add(int a,int b){
        //method body
        return 0;
    }

}

注意：方法重载与返回值无关。

参数列表不同：

参数的个数不同。

参数的对应的数据类型不同。

参数的顺序不同(不同类型的可以交换位置)

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。利用递归可以用简单的程序来解决一些复杂的问题。比如：大多数排序使用的就是递归算法。

递归结构包括两个部分：

定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体。解答：什么时候需要调用自身方法。

public static void print(int i) {System.out.println(i);
    if(i==10){ // 递归头
        return; // 提前结束方法
    }
    print(++i); // 递归
}

public static void main(String[] args) {print(1);  // 打印 1~10 之间的数据
}

这个图片很好的诠释了递归, 我们可以使用代码实现打印 吓得我抱起了抱着抱着抱着我的小鲤鱼的我的我的我

public static void recursion(int i) {System.out.println("抱着");
    if (i==0) { // 临界条件
        System.out.println("我的小鲤鱼");
    } else {recursion(--i);  // 递归调用
    }
    System.out.println("的我");
}

public static void main(String[] args) {System.out.println("吓得我抱起了");
    recursion(2);
}

递归的缺陷：

简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多。所以再使用时要慎重。

注意：任何可用递归解决的问题也能使用迭代解决。但递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归；

在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

方法深入

void 关键字

return 关键字

思考角度

签名(signature)

类型兼容

值传递和引用传递

内存划分:

重载（Method OverLoad）

递归结构