Java 基础语法方法的使用

Posted 吞吞吐吐大魔王

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 基础语法方法的使用相关的知识,希望对你有一定的参考价值。

一、方法的基本用法

1. 什么是方法

方法就是一个代码片段,类似于 C 语言中的函数。它是一个语句的集合,它们在一起执行一个功能

那么方法存在的意义是什么呢?

  1. 能够模块化的组织代码
  2. 做到让代码被重复使用,一份代码可以用在多个位置
  3. 让代码更好理解、更简单
  4. 直接调用现有方法,不必重复造轮子

2. 语法格式

  1. 方法的定义

    public static 方法的返回值 方法名称 ([参数类型 形参]){
        // 方法体代码
        [return 返回值;]
    }
    
  2. 方法的调用

    • 定义方法时,不会执行代码,调用时才执行
    • 当方法被调用时,会将实参赋值给形参
    • 参数传递完毕后,就会执行到方法体代码
    • 当方法执行完毕后护(遇到 return 语句),就会回到方法调用位置继续往下执行

    接下来我们写一个求两个整数相加的方法,体验一下

    public class Test{
        public static void main(String[] args){
            int a = 10;
            int b = 20;
            int ret = add(a, b);
            System.out.println("ret = " + ret);
        }
        public static int add(int a, int b){
        	return a + b;
    	}
    }
    // 结果为 ret = 30
    
  3. 注意事项

    • public 和 static 两个关键字在此处具有特定含义,后面再介绍
    • 方法定义时,参数可以没有,但如果有一定要指定类型
    • 方法定义时,返回值可以没有,但如果没有,返回类型应该写出 void
    • 方法定义时的参数为“形参”,方法调用时的参数为“实参”
    • 方法定义必须在类中
    • 和 C 语言不同的是 Java 中没有“函数声明”的概念,所以方法的定义可以写在 main 方法的上方或者下方
    • 一个方法可以被多次调用
    • 方法的调用需要开辟栈帧,方法结束栈帧就随即结束

其实 Java 中的方法和 C 语言太类似了,不过还是会有不同的,所以接下来继续了解方法吧!

3. 实参和形参的关系

我们先来看一个代码

public class Test{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println("a = "  + a " b = " + b);
    }
    public static void swap(int a, int b){
        int tmp = a;
        int a = b;
        int b = tmp;
    }
}
// 运行结果为 a = 10 b = 20

为啥呢?不过在 C 语言里这样写也是错的,因为形参只是实参的一份临时拷贝,swap 方法里只将形参的值互换了,但是实参的值没有互换。

那么就使用指针传值吧!可惜 Java 中没有指针,那怎么办呢?我们可以使用引用类型,如数组实行两个数的交换,如

public class Test{
    public static void main(String[] args){
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("a = "  + arr[0] " b = " + arr[1]);
    }
    public static void swap(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}
// 运行结果为 a = 20 b = 10

二、方法的重载

1. 重载要解决的问题

什么是重载呢?大家可能都会有这个疑问,接下来我们直接用一个代码,揭开重载的面纱

public class Test{
    public static void main(String[] args){
        //当我们求两个整数和时
        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1, b1);
        System.out.println("ret1 = " + ret1);
        //当我们求两个浮点数和时
        double a2 = 1.5;
        double b2 = 2.4;
        double ret2 = a2 + b2;
        System.ouy.println("ret2 =" + ret2);
    }
    public static int addInt(int a, int b){
    	return a + b;
	}
    public static double addDouble(double a, double b){
    	return a + b;
	}
}

上面我们分别对整数和浮点数求和都写了一个方法,这个做法也是对的。但是 Java 认为 addInt 这样的名字不友好,不如直接就叫 add。啥意思呢,在 Java 中上述代码可以写出这样

public class Test{
    public static void main(String[] args){
        //当我们求两个整数和时
        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1, b1);
        System.out.println("ret1 = " + ret1);
        //当我们求两个浮点数和时
        double a2 = 1.5;
        double b2 = 2.4;
        double ret2 = a2 + b2;
        System.ouy.println("ret2 =" + ret2);
    }
    public static int add(int a, int b){
    	return a + b;
	}
    public static double add(double a, double b){
    	return a + b;
	}
}

细心的可以发现我们把方法名都叫作了 add,这个就叫做重载

2. 什么是重载

  1. 含义

    同一个方法名字相同,提供不同版本的实现,称为重载

  2. 满足要求

    • 方法名相同
    • 参数列表不同(参数的个数或者参数的类型不同)
    • 返回值不作要求

    以上条件都满足时,才是重载。后面我们还会讲到重写,这是面试时时常会被问到的问题

  3. 注意事项

    重载不是必须在一个类当中(继承)

三、方法递归

1. 什么是递归

  1. 概念

    一个方法在执行过程中调用自身,就称为“递归”

  2. 实行条件

    • 存在限制条件,当满足这个限制条件的时候,递归便不再继续
    • 每次递归调用之后越来越接近这个限制条件

    递归其实就是调用自己嘛,如果不存在限制条件只是调用自己的话,就可能有错误,如

    public class Test{
        public static void main(String[] args){
            func();
        }
        public static void func(){
            func();
        }
    }
    

    上述代码就会栈溢出(StackOverflowError),因为方法调用时都会在栈上开辟内存,无休止的调用就会导致无休止的开辟,使栈溢出

2. 递归执行过程分析

既然知道什么是递归后,我们先来看一个求 n 的阶乘的例子

public class Test{
    public static void main(String[] args){
        int num = 4;
        int ret = factor(num);
        System.out.println(ret);
    }
    public static int factor(int n){
        if(n == 1 || n == 0) 
            return 1;
        else
            return n * factor(n-1);
    }
}
// 结果为24

而接下来我用两种方法为大家分析一下递归的执行过程

  1. 分析方法一


    递归其实可以分为递和归两部分,如上图,红色路线就是递(将新的数值传递给方法调用),橙色路线就是归(从最后的限制条件得到的值,依次往回传回去)

  2. 分析方法二
    我们可以直接把这个方法放到栈上面去看,我们知道栈的特点是后进后出。最左边的图表示是四次调用方法,往右,由于 n == 1 时遇到限制条件,fac(1) 方法返回1并且结束(该方法在栈上随即销毁)。再往右,fac(2) 方法返回2并且结束(该方法在栈上随即销毁)。再往右,fac(3) 方法返回6并且结束(该方法在栈上随即销毁)。最后,fac(4) 方法返回24并且结束(该方法在栈上随即销毁)。

3. 递归练习

接下来我们做几个练习,让方法递归的理解更加深刻一些吧!

  1. 按顺序打印一个数字的每一位

    public static void print(int num){
        if(num < 10)
            System.out.print(num);
        else{
            print(num / 10);
            System.out.print(num % 10);
        }
    }
    
  2. 求 1 + 2 + … + n 的和

    public static int sum(int num){
    	if(num == 1)
    		return 1;
    	else
    		return num + sum(num - 1);
    }
    
  3. 写一个递归方法,输入一个非负整数,返回组成它的数字之和

     public static int sum(int num){
        if(num < 10)
            return num;
        else
            return num % 10 + sum(num / 10);
    }
    
  4. 求斐波那契数列数列的第 N 项

    public static int fic(int num){
        if(num == 1 || num == 2) 
            return 1;
        else 
            return fic(num - 1) + fic(num -2);
    }
    

4. 递归小结

递归是一种重要的编程解决问题的方式,我们已经知道了递归的用法,但是我们还应该知道什么时候使用递归更好。就比如上述求斐波那契数列的第 N 项,其实并不推荐使用递归去求,因为 N 越大,重复计算的次数就越多,这时就更推荐迭代法,如

public static int fic(int num){
    int f1 = 1;
    int f2 = 1;
    int f3 = 1;
    int i = 0;
    for(i = 3; i <= num; i++){
        f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
    }
    return f3;
}

四、总结

这次学习了 Java 中方法的使用,其实学习的过程很轻松,因为和 C 语言的函数太像了。如果大家上述有什么没有理解的话,可以给我私信或者浏览我之前写过的 C 语言函数的文章 第五章 C世界函数的故事(1)第六章 C世界函数的故事(2) 以加深理解。
希望大家喜欢哦!

以上是关于Java 基础语法方法的使用的主要内容,如果未能解决你的问题,请参考以下文章

JSP开发中的基础语法

java基础3-重载+命令行传参+递归+数组+排序

Java 基础语法Java 对象的比较

Java语言基础之方法的设计

Java Lambda

Java Web学习总结JSP