java13编程基础之方法深入

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 关键字

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

注意:在一个作用域内 return 之后不能再存在代码

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

return语句:

  1. return语句可以出现在任何(有返回值和没有返回值)方法中
  2. return语句 在没有返回值的方法中,用来提前结束方法

    //打印出1~5之间前两个数
    public static void test(){
        for(int i=1;i<=5;i++){
            if(i==3){
                return; //结束方法
            }
            System.out.println(i);
        }
    } 
  3. 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) 带出返回值
            }
        }
    } 
  4. 一个方法只能执行一条return语句
  5. 在一定会被执行的return语句后,写的语句为不可达语句,程序自动检测这种语句,永远不会被执行到,报错。
  6. 在循环中无条件的break后写语句,会出现不可达语句
  7. 在死循环(没有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方法执行完毕,弹栈释放内存空间

重载(Method OverLoad)

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

①必须是同一个类

②方法名必须相同

③参数列表不同

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

} 

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

参数列表不同:

​ 参数的个数不同。

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

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

递归结构

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

递归结构包括两个部分:

  1. 定义递归头。解答:什么时候不调用自身方法。如果没有头,将陷入死循环。
  2. 递归体。解答:什么时候需要调用自身方法。
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);
}

 **递归的缺陷:**

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

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

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

你可能感兴趣的