Java语言基础（方法、数组、递归）

最新推荐文章于 2021-11-01 15:50:52 发布

Tigirs

最新推荐文章于 2021-11-01 15:50:52 发布

阅读量339

点赞数 2

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_45677119/article/details/102366383

版权

JavaSE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

Java语言基础

方法

为什么要有方法？
假设植物大战僵尸这个游戏程序，程序在运行过程中，要豌豆射手要不断地发射炮弹，发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很繁琐，可读性也非常差；
为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。
什么是方法？
方法就是完成特定功能的代码块；
在很多语言中都有函数的定义，在Java语言中，我们将其称之为方法。
方法的格式：
修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2 …){
方法体;
return 返回值;
}
方法的格式详细说明：
(1): 修饰符：例如，public static
(2): 返回值类型：用于限定返回值的数据类型
(3): 方法名：就是一个名称，它的存在是为了方便我们调用方法
(4): 参数类型：限定调用方法时传入参数的数据类型
(5): 参数名：是一个变量，接收调用方法时传入的参数，这个参数被称之为形式参数,它的作用是用来接收实际参数的
(6): 方法体：完成功能的代码
(7): return：结束方法以及返回方法指定类型的值
(8): 返回值：就是功能的结果，由return带回，带回给调用者
如何写一个方法?
(1):返回值类型: 明确功能结果的数据类型
(2):参数列表: 你要传递几个参数，以及每一个参数的数据类型
方法的调用(有明确返回值的调用)
(1):单独调用,一般来说没有意义;
(2):赋值调用,比较常用的；
(3):输出调用,我们可能需要针对结果进行进一步的操作。
方法的注意：
(1):方法不调用不执行
(2):方法与方法是平级关系，不能嵌套定义
(3):方法定义的时候参数之间用逗号隔开
(4):方法调用的时候不用在传递数据类型
(5):如果方法有明确的返回值，一定要由return带回一个值
方法的重载：
概述：在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
参数列表不同即，参数个数不同；参数类型不同。

例1：
//定义一个show方法，下面与的B选项与show不是方法重载；
class Demo {
void show(int a,int b,float c){}
}
A.void show(int a,float c,int b){}
B.void show(int x,int y,float z){}
C.int show(int a,float c,int b){return a;}
D.int show(int a,float c){return a;}

例2：

//键盘录入并且调用方法求两数之和：
package org.westos.demo1;
import java.util.Scanner;
public class Demo4 {
    public static void main(String[] args) {
        Scanner i = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num1 = i.nextInt();
        Scanner y = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num2 = y.nextInt();
        int sum=add(num1,num2);//调用add这个方法
        System.out.println("两数之和为："+sum);
}
//构建方法add；
/*	修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
		方法体;
		return 返回值;
	}
*/
    private static int  add(int a,int b) {
        int sum=a+b;
        return sum;//将求和结果sum返回到main中
    }
}

数组

数组概念：
数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义格式：
格式1：数据类型[] 数组名；
格式2：数据类型数组名[];
例如：
int[] a：定义了一个int类型的数组a；
int a[]：定义了一个int类型的a数组；
数组的初始化：
Java中的数组必须先初始化,然后才能使用；所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

初始化的分类：
1.动态初始化: 只指定长度，由系统给出初始化值；
2.静态初始化: 给出初始化值，由系统决定长度
注意：这两种方式，只能使用一种，不能进行动静结合
动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
例如： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
静态初始化的格式：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
例如： int[] arr = new int[]{1,2,3};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
例如： int[] arr = {1,2,3};

在数组这里我们还需要引入一个概念：Java中的内存分配以及栈和堆的区别；

1.栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
2.堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地址值；
b: 每一个变量都有一个默认的值

类型	默认值
byte，short，int，long	0
float，double	0.0
char	‘\u0000’
boolean	false
引用数据类型	null

c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收；
3.方法区；
4.本地方法区:(和系统相关)
5.寄存器:(cpu使用)

//定义一个一维数组，动态初始化；
 int[] arr1 = new int[3];
 System.out.println(arr1);//打印数组arr[]的地址：[I@3f99bd52
 System.out.println(arr1[0]+","+arr1[1]+","+arr1[2]);//分别打印arr[]中的元素，由于系统默认故它们的值都为0；
 //定义一个一维数组，静态初始化；
 int[] arr2={1,2,3};
 System.out.println(arr2[0]+","+arr2[1]+","+arr2[2]);//打印结果为1，2，3

注意：数组操作的两个常见小问题越界和空指针；
1.ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
2.NullPointerException:空指针异常
原因：数组已经不在指向堆内存了，而你还用数组名去访问元素。

有关数组的操作：

数组的遍历：

就是依次输出数组中的每一个元素

例1：

 int[] arr={1,2,3,4,5,6,7,8,9};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");//遍历结果为：1，2，3，4，5，6，7，8，9，
       }

数组的反转

数组元素反转(就是把元素对调)

 int[] arr={4,5,6,7,8,9};
        for (int i = 0; i < arr.length/2; i++) {
            int t=arr[i];//引入中间变量t进行反转；
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i ]=t;
        }for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
        //结果：9，8，7，6，5，4，

数组查表法

根据键盘录入索引,查找数组中对应的元素

//输入索引1---7，查找该数组中对应的元素；
import java.util.Scanner;
public class Demo{
    public static void main(String[] args) {
        String[] arr={"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner sc = new Scanner(System.in);
        System.out.println("输入1---7");
        int i = sc.nextInt();
        String x=getindex(i,arr);
        System.out.println(x);
    }
   private static String getindex(int i, String[] arr) {
        if (i>=1 & i<=7){
            String c=arr[i-1];
            return c;
        } else {System.out.println("输入有误");}
        return "";
    }
}

数组元素查找

查找指定元素第一次在数组中出现的索引

import java.util.Scanner;
public class Demo2{
    public static void main(String[] args) {
        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个星期：");
        String s = scanner.nextLine();
        int index = getIndex(s, arr);
        System.out.println(index);
    }
  private static int getIndex(String s, String[] arr) {
        for (int i=0;i<arr.length;i++){
            boolean b = s.equals(arr[i]);//s.equals比较两个字符串是否相等；
            if (b) {
                return i + 1;
            }else {
                System.out.println("输入有误");
                break;
             }
        }
        return 1;
    }

二维数组

二维数组概述：
我们学校的每个班有很多个学生，所以，可以用数组来存储这些学生；但我们又同时有很多个班级，这个也应该用一个数组来存储，如何来表示这样的数据呢?Java就提供了二维数组供我们使用
由此可见：其实二维数组其实就是每一个元素为一维数组的数组。
二维数组格式1：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组必须写上
n表示每一个一维数组的元素个数可选
例如:
int[][] arr = new int[3][2];
定义了一个二维数组arr；
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]；
每个一维数组有2个元素，可以通过arr[m][n]来获取：
表示获取第m+1个一维数组的第n+1个元素。
二维数组格式2：
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组；
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];
二维数组格式3：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}…};
简化:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化，由我们指定具体的元素值,由系统给分配长度
举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};

有关二维数组的操作：

二维数组的遍历：

外循环控制的是二维数组的长度，其实就是一维数组的个数；内循环控制的是一维数组的长度。

 int[][] arr={{1,2},{3,4,5},{6,7,8,9}};
        for (int i = 0; i < arr.length; i++) {
            for (int y = 0; y <arr[i].length; y++) {
                System.out.print(arr[i][y]+",");//遍历结果为：1,2,3,4,5,6,7,8,9,
            }
}

打印杨辉三角：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
…

import java.util.Scanner;
public class Demo4 {
    public static void main(String[] args) {
       /*
        分析：
        1.每一行的第一个元素和最后一个元素都是1
        2.从第三行开始，从第二列开始，中间的数等于上一行的前一列和本列之和
        3.每一行的数据可以看作一个一维数组，然后把每一行的数据再用二维数组从起来。
        */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数：");
        int n = scanner.nextInt();
        int[][] arr = new int[n][n]; //构建一个二维数组，行数如果是n，我们把列数也先定义为n，这个n的数据来自于键盘录入。
        //1.把第一元素和最后一个元素置为1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
        }
        //2.算出中间元素
        //从第三行开始，从第二列开始，中间的数等于上一行的前一列和本列之和
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j <= i; j++) {
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }
        //3，打印出三角形
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <=i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

递归

1.递归概述: 方法定义中调用方法本身的现象
2.递归注意事项：
要有出口，否则就是死递归；
次数不能太多，否则就内存溢出
3.递归解决问题的思想及图解(5的阶乘)：

思想：
代码：

public static void main(String[] args) {
        //用递归的思想来处理5的阶乘
        int r = factorial(5);
        System.out.println("结果：" + r);
    }
    private static int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }//结果为：120

内存图解：

4.利用递归解决“不死神兔”问题：

/*需求：兔子问题(斐波那契数列)
	有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
	由此可见兔子对象的数据是：1 , 1 , 2 , 3 , 5 , 8 ...*/
public static void main(String[] args) {
      //  这组数据 斐波那契数列：1 1 2 3 5 8 13 21...从第三个数开始，后面的每个数 等于他前两个数之和
        int sum = rabbit(20);//调用rabbit方法本身
        System.out.println("第二十个月时兔子数量为："+sum);
    }
    private static int rabbit(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return rabbit(n - 1) + rabbit(n - 2);
        }
 }//输出结果为：第二十个月时兔子数量为：6765

//下篇再见…谢谢

Tigirs

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Java语言基础（方法、数组、递归）

Java语言基础方法为什么要有方法？假设植物大战僵尸这个游戏程序，程序在运行过程中，要豌豆射手要不断地发射炮弹，发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很繁琐，可读性也非常差；为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹...
复制链接

扫一扫