Java基础回顾_Java方法详解

deanyuancn

发布于 2021-5-13 10:44

浏览

0收藏

Java基础回顾_Java方法详解

何谓方法？

Java方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其它地方被引用

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，这样利于我们后期的发展。

个人随笔：

方法命名遵循小驼峰原则
main方法尽量保持简洁、干净
方法其实就是C语言里的函数，方法遵循原子性，即一个方法只完成一件事
有些方法没有return返回值，于是方法体就不需要写返回值类型，这个时候就要用 void 替代返回值类型
有参数的方法一定要有return返回值，没有参数的方法即void方法就不需要return返回值
参数类型这里得注意：参数类型分为形式参数和实参（或称为变量）。

形式参数：形参就是创建方法的时候我个人定义的像 int a, int b 这样的，没有实际值，等着调用的时候再往里传具体值的参数，相当于占位符，先把位置占着，用的时候再给它其他的值；

实参（或称为变量）：方法在被调用的时候直接给参数赋值，像add( 1, 2);这种里面的 1和2 就是实参。

代码格式：

 修饰符 + 返回值类型 + 自定义方法名 + （ 参数类型 + 参数名--->”参数可以定义一个或者多个“ ）{

//执行的代码语句，即方法体

 return + 返回值；

}

例如：下面的add方法（加法）：

 public int add( int a, int b ){

 return a+b;

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

个人随笔：

1、有时候用return 0；去终止方法。
2、方法的带你用：用对象名去点方法名，例如：对象名.方法名（实参列表）
拓展了解：值传递和引用传递

Java都是值传递！只有值传递！

方法的重载

个人练习：

结合Scanner对象，完成手动输入两个整数打印最小值；以及直接注入三个整数然后得到三个整数中最小的那个。

这两个方法的方法名都是min，但是它们的参数列表不一样，一个是两个变量（实参），一个是3个变量（实参）！！！！妙啊！！！

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请依次输入要比较的两个整数：");
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int min = min(a, b);
        System.out.println("输入的两个整数中较小的那个整数是："+min);
        int min1 = min(6, 8, 3);
        System.out.println("三个整数中最小的整数是："+min1);
    }
    public static int min(int a,int b){
        int minNumber;
        if (a<b){
            minNumber = a;
        }else {
            minNumber = b;
        }
        return minNumber;
    }
    //重载的取最小值的方法，但是参数列表不一样，多了一个参数
    public static int min(int a,int b,int c){
        int minNumber;
        if (a<b){
            minNumber = a;
        }else {
            minNumber = b;
        }
        if(minNumber<c){
            return minNumber;
        }else {
            minNumber=c;
        }
        return minNumber;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.

Java基础回顾_Java方法详解-鸿蒙开发者社区

方法重载的规则：

1、方法名称必须一模一样
2、参数列表必须不同，即参数的个数不同、或参数的类型不同、或参数的排列顺序不同等
3、方法的返回值类型可以相同，也可以不相同，但是仅仅只有返回值类型不同也不行

个人随笔：

当编写了重载的方法的时候，再去调用这些方法名相同的方法的时候，编译器它自己会根据参数列表的差异去一个方法一个方法的找，知道找到对应的方法，如果找不到，它就会报错！

命令行传参（不经常使用）

有时候你希望运行一个程序的时候，再传递给它消息。这个时候就要靠传递命令行参数给main()函数去实现。

可变参数

什么是可变参数？

有时候根据实际需求，可能需要用方法重载去编写几十个甚至上百个方法名相同，参数链表不同的方法，这样也太离谱了，这时候就诞生了可变参数这种东西，它解决了上述问题！妙啊！！！！！！

用法：在参数列表中的参数声明的参数类型后面加上一个省略号，例如：

利用可变参数，自定义任意的数据传入方法，取得最大值！

public class Demo01 {
    public static void main(String[] args) {
        printMax(1,5,3,4,6,8,2,3,9,6,4);
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double... numbers){
        if (numbers.length == 0){
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];

        //排序！
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max Value is " + result);
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

Java基础回顾_Java方法详解-鸿蒙开发者社区

递归（重点）

递归就是：A方法调用A方法，即自己调用自己！递归是一种思想！

递归结构包括两个部分：

递归头：就是有一串可以停止调用方法（函数）的代码，让程序不会无限循环运行！
递归体：
友情提示：能不用递归就不用递归，因为如果调用方法次数过多，会非常占用资源，影响性能！

个人练习：

写一个计算器，要求实现加减乘除功能，并且能循环接收新的数据，通过用户交互实现（即Scanner对象）

用到了 while循环 switch语句，实现了数据的循环输入并计算！！！！妙啊！！！！

import java.util.Scanner;

public class Calculator{
    public static void main(String[] args) {
        //创建对象用来调用对象里的方法
        Calculator calculator = new Calculator();
        //调用computer方法
        calculator.computer();
    }
    //第一步：加减乘除四个方法（因为要循环计算，每次传入一个数字，所以参数列表应该只有一个参数）
    //加法
    public static double add(double a){
        System.out.println("请输入一个数：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a+b;
    }
    //减法
    public static double subtract(double a){
        System.out.println("请输入一个数：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a-b;
    }
    //乘法
    public static double multiply(double a){
        System.out.println("请输入一个数：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a*b;
    }
    //除法
    public static double divide(double a){
        System.out.println("请输入一个数：");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a/b;
    }

    //第二步：完成循环输入数据的功能（while（true）+switch）,必须创建一个方法完成这一步
    public void computer(){
        System.out.println("请输入一个数：");
        Scanner scanner1 = new Scanner(System.in);
        double a = scanner1.nextDouble();

        while(true){
            Scanner scanner2 = new Scanner(System.in);
            System.out.println("你可以输入的操作有：加(+)减(-)乘(*)除(/)清零(小写的c)结束(小写的end)--->");
            String str = scanner2.nextLine();
            switch (str){
                case "+":
                    a = add(a);
                    System.out.println("="+a);
                    break;
                case "-":
                    a = subtract(a);
                    System.out.println("="+a);
                    break;
                case "*":
                    a = multiply(a);
                    System.out.println("="+a);
                    break;
                case "/":
                    if (a == 0){
                        System.out.println("除法分子不能为零，请重新输入：");
                        break;
                    }
                    a = divide(a);
                    System.out.println("="+a);
                    break;
                case "c":
                    computer();
                    break;
                case "end":
                    System.exit(-1);
                    break;
                default:
                    System.out.println("输入的字符有误！");
            }
        }
    }

}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.

Java基础回顾_Java方法详解-鸿蒙开发者社区

数组

什么是数组 ?

数组是相同类型数据的有序组合。

数组的声明创建
首先必须声明数组变量，才能在程序中使用数组。

int[] nums;//建议选择这种声明数组变量的格式；
int nums2[];//不建议使用这种格式；这是c和c++里的格式，早些年为了程序员能快速掌握Java所以也有这种声明数组变量的格式1.
2.

创建一个数组

int[] nums;//建议选择这种声明数组变量的格式；
int nums2[];//不建议使用这种格式；
nums = new int[10];//这里可以存放10个int类型的元素

//创建数组，一步到位
double[] nums3 = new double[10];
System.out.println(nums3.length);//输出nums3的数组长度1.
2.
3.
4.
5.
6.
7.

数组的内存分析
略...

数组的三种初始化：

静态初始化----------------------------->在声明数组的时候就直接给数组赋值------>int[] a = {1,2,3,4,5};
动态初始化----------------------------->在声明数组之后，再给数组赋值------>int[] a = new int[5]; a[0]=1; a[1]=2; a[2]=3; a[3]=4; a[4]=5;
数组的默认初始化-------------------->在声明数组之后，数组里的元素默认为0------>int[] a = new int[5]；//a= {0,0,0,0,0}

数组的四个基本特点

数组被创建之后，长度就不能改变了；
数组中所有的元素必须是同一数据类型；可以是任意数据类型，包括基本类型和引用类型；
数组中的变量属于引用类型，我们用的时候就去点它，数组也可以看成是对象，其中的没个元素都相当于是该对象的成员变量；
数组本身就是对象，Java中的对象都在堆中，所以数组对象本身是在堆中的。

数组边界

数组下标从0开始到数组长度减一，如果下标超了，就会报错：ArrayIndexOutofBounds--------->数组下标越界异常

数组使用

For-Each 循环
数组当作参数传入方法中
数组当作返回值返回

多维数组

int[][] a = {{1,2},{3,4},{8,9}};//这是一个二维数组1.

个人理解：多维数组就是不停的套娃！妙啊！！！！！！！！！！！

Arrays类

Arrays.toString(数组名称)；//可以打印出数组所有数组元素；
Arrays.sort(数组名称)；//可以对数组排序：升序（从小到大）
Arrays.fill(数组名称,想要填充的值)；//可以对数组进行填充：所有元素都会被想要填充的值给替换
Arrays.fill(数组名称,3,8,想要填充的值)；//只有数组下标为3到8的元素被替换

八大排序

个人理解：

冒泡排序：比较数组中两个相邻的元素，如果右边的元素比左边的小，则它们交换位置，达到左边的元素永远比右边的元素小的效果；从右往左比较，这样每个数都能被比较到，由于每次都将较小的移到了左边，所以每比较完一轮，下一轮又从最右边往最左边比较的时候，就可以少比较一次（比如有5个元素，每次比较两个元素的话，一轮就需要比较4次，第二轮就只需要比较3次，第三轮就只需要比较2次，第四轮就需要比较1次，然后就排好顺序了）；--------------->时间复杂度为O(n的2次方)。

public class Demo01 {
    public static void main(String[] args) {
        int[] array2 ={1,4,8,3,5,9,2};
        System.out.println(Arrays.toString(fun1(array2  )));
    }
    //编写一个给数组冒牌排序的方法，参数为数组
    public static int[] fun1(int[] array1){
        //声明一个用来给两个相邻元素交换位置的变量
        int t = 0;

        for (int i = 0; i < array1.length-1; i++) {
            for (int j = 0; j < array1.length-1-i; j++) {
                if (array1[j+1]<array1[j]){
                    t = array1[j];
                    array1[j] = array1[j+1];
                    array1[j+1] = t;
                }
            }
        }
        return array1;1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

稀疏数组

创建一个数组，打印出它的稀疏数组，并通过稀疏数组打印出原数组！！！！！！

public class Demo01 {
    public static void main(String[] args) {
        //二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
        //将上面的二维数组转换为稀疏数组保存起来
        //获取有效值的个数
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i][j] != 0){
                    count ++;
                }
            }
        }
        System.out.println("该二维数组中有效值的个数为："+ count);

        //稀疏数组
        //第一步：创建一个二维数组，称之为稀疏数组
        int[][] array1 = new int[count+1][3];//有效值+1就是稀疏数组的行数，列固定为3列
        //第二步，给这个稀疏数组加入第一行应该展示的数据；
        array1[0][0] = array.length;//原数组的行数
        array1[0][1] = array.length;//原数组的列数
        array1[0][2] = count;//原数组中有效值 的个数

        //第三步：给稀疏数组赋值
        int count1 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];

                }
            }
        }
        //第四步：打印输出数组
        System.out.println("原数组array的稀疏数组array1如下所示：");
        //遍历输出稀疏数组array1
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
//        for (int i = 0; i < array1.length; i++) {
//            System.out.println(array1[i][0]+"\t"+array1[i][1]+"\t"+array1[i][2]);
//        }

        System.out.println("将稀疏数组还原成原数组:");
        //将稀疏数组还原成原数组
        //第一步：用稀疏数组中第一行的值去创建一个二维数组，用来显示原数组
        int array2[][] = new int[array1[0][0]][array1[0][1]];//确定数组为几行几列
        //确认数组的大小后，就要通过稀疏数组中描述的原数组的有效值传入array2中
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        //第二步：打印array2数组
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.print("\n");
        }
    }

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.

将上面的代码写为两个方法：数组转稀疏数组的方法，和，稀疏数组转原数组的方法：

public class Demo01 {
    public static void main(String[] args) {
        //二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        System.out.println("数组array的稀疏数组为：" );
        sparseArray(array);

        int[][] array1 = new int[3][3];
        array1[0][0] = 11;array1[0][1] = 11;array1[0][2] = 2;
        array1[1][0] = 1;array1[1][1] = 2;array1[1][2] = 1;
        array1[2][0] = 2;array1[2][1] = 3;array1[2][2] = 2;

        System.out.println("稀疏数组array1的原数组为：" );
        sparseArrayToArray(array1);

    }

    /**
     * 数组 转为 稀疏数组
     * @param array
     */
    public static void sparseArray(int[][] array){
        //将上面的二维数组转换为稀疏数组保存起来
        //获取有效值的个数
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i][j] != 0){
                    count ++;
                }
            }
        }
        //稀疏数组
        //第一步：创建一个二维数组，称之为稀疏数组
        int[][] array1 = new int[count+1][3];//有效值+1就是稀疏数组的行数，列固定为3列
        //第二步，给这个稀疏数组加入第一行应该展示的数据；
        array1[0][0] = array.length;//原数组的行数
        array1[0][1] = array.length;//原数组的列数
        array1[0][2] = count;//原数组中有效值 的个数

        //第三步：给稀疏数组赋值
        int count1 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];

                }
            }
        }
        //第四步：打印输出数组

        //遍历输出稀疏数组array1
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
    }

    /**
     * 稀疏数组 转为 数组
     * @param sparseArray
     */
    public static void sparseArrayToArray(int[][] sparseArray){

        //将稀疏数组还原成原数组
        //第一步：用稀疏数组中第一行的值去创建一个二维数组，用来显示原数组
        int array2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];//确定数组为几行几列
        //确认数组的大小后，就要通过稀疏数组中描述的原数组的有效值传入array2中
        for (int i = 1; i < sparseArray.length; i++) {
            array2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //第二步：打印array2数组
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.print("\n");
        }
    }

}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.

果断就会白给，犹豫就会败北，坚持才是胜利！！！

分类

Java

标签

方法解析

java基础

已于2021-5-13 10:44:09修改

51CTO

51CTO博客

51CTO学堂

Java基础回顾_Java方法详解

订阅鸿蒙技术特刊，精选内容抢先看