关于java:java13编程基础之方法深入

前解说的循环操作，能够解决的是代码反复的问题，然而此时的反复的代码必须是有法则的。那循环操作，能解决所有的代码反复吗? 答案必定是不行的，比方针对于某一种性能的反复操作，循环就无奈实现, 咱们能够应用办法.

编写一个飞机大战游戏，程序在运行过程中，须要一直地发射子弹。假如发射子弹性能须要编写 200 行代码，那么，每次发射子弹都须要反复地编写这 200 行代码，这样的程序太 low 了。在开发中咱们要遵循 DRY 准则（Don’t Repeat Youself）——不要反复你本人的代码，因为反复意味着保护老本很大，如果要批改性能代码，则每一个反复的中央都要批改一次，你敢确保每个反复的中央都能改到吗？你不感到腻烦吗？

为了解决性能代码反复编写的问题，能够把发射子弹的代码提取进去专门放在一个代码块（一对{}）中，并为这段代码起个惟一的名字，如此，每次发射子弹的时候间接通过这个名字就能够调用发射子弹的性能代码了。这个代码块咱们称之为办法。

办法就是封装在一起来执行操作语句的汇合，用来实现某个性能操作。

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-oZqjnfdO-1605668912733)(/1581308103720.png)]

使程序变得更简短而清晰。
有利于程序保护。
能够进步程序开发的效率。
进步了代码的重用性。

申明格局:

[修饰符] 办法返回值类型 办法名(形参列表) { 
    办法体;
    return 返回值; 
}

// 有返回值类型的办法
public static int add(int a, int b, int c){  // 求和
    int k = a + b + c; 
    return k; 
}

// 没有返回值的办法, 没有形参
public static void printStar(){ // 打印 5 行 5 列的星星
    for(int i=1;i<=5;i++){for(int j=1;j<=5;j++){System.out.print("*");
        }
        System.out.println();}
}

拜访修饰符:办法容许被拜访的权限范畴;
返回值类型:如果办法不返回任何值，则指定为 void; 如果办法具备返回值，则须要指定返回值的类型，并且在办法体中应用 return 语句返回值;
办法名:定义方法的名字，必须应用非法的标识符，见名知意。
形参列表:参数能够有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。

调用:

办法定义实现后，若要应用，必须调用它。在调用时，调用的控制权由办法调用处转移到办法中，办法遇到 return 或者 }完结时，将调用权交还给调用处。也就是”从哪里来到哪里去”的套路。

办法名([实参列表])

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-Y7oYxHYc-1605668912737)(/1581311754241.png)]

留神:

办法不调用不执行
存在返回值，接管变量或匿名接管(输入或者调用)
定义方法指定形参，调用办法指定实参
办法调用是要求形参实参要求个数雷同，类型匹配

一个 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 为跳出办法或返回值。

留神：在一个作用域内 return 之后不能再存在代码

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

签名(signature)

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

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

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;

[外链图片转存失败,
须要更多视频材料可加 vx：lezijie007（备注暗号 17）不备注会拒加噢

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 之间的数据
}

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-fXwfeFC7-1605668912754)(/5b6fac208b0ad.jpg)]

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

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);
}

递归的缺点：

简略的程序是递归的长处之一。然而递归调用会占用大量的零碎堆栈，内存耗用多，在递归调用档次多时速度要比循环慢的多。所以再应用时要谨慎。

留神：任何可用递归解决的问题也能应用迭代解决。但递归办法能够更加天然地反映问题，并且易于了解和调试，并且不强调效率问题时，能够采纳递归；

在要求高性能的状况下尽量避免应用递归，递归调用既花工夫又耗内存。

;
if (i==0) {// 临界条件
System.out.println(“我的小鲤鱼”);
} else {
recursion(–i); // 递归调用
}
System.out.println(“的我”);
}

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

 ** 递归的缺点：**

简略的程序是递归的长处之一。然而递归调用会占用大量的零碎堆栈，内存耗用多，在递归调用档次多时速度要比循环慢的多。所以再应用时要谨慎。** 留神：** 任何可用递归解决的问题也能应用迭代解决。但递归办法能够更加天然地反映问题，并且易于了解和调试，并且不强调效率问题时，能够采纳递归；在要求高性能的状况下尽量避免应用递归，递归调用既花工夫又耗内存。

关于java:java13编程基础之方法深入

java13 编程根底之办法深刻

纲要

办法入门

概述

长处

定义与应用

申明格局:

调用:

办法深刻

void 关键字

return 关键字

思考角度

签名(signature)

类型兼容

值传递和援用传递

内存划分:

重载（Method OverLoad）

递归结构