Java学习记录 Day4（方法、数组）_从主方法中接收值传入数组中-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41151659/article/details/88981398

本文介绍了Java中的方法、方法重载、数组及引用数据类型的使用，包括格式、注意事项、实例演示等，适合初学者掌握基本概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

Day 4

Day 4

2019年3月31日。
这是我学习Java的第四天。
这一天，我学到了以下的知识。

方法

一段功能逻辑的封装，以实现重复调用。
格式如下：

 修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
    		方法体;
    		return 返回值;
    	}
    /*方法的格式详细说明
	(1): 修饰符 			比较多,后面会详细介绍。目前使用  public static
	(2): 返回值类型 		用于限定返回值的数据类型
	(3): 方法名			就是一个名称，它的存在是为了方便我们调用方法
	(4): 参数类型 			限定调用方法时传入参数的数据类型
	(5): 参数名 			是一个变量，接收调用方法时传入的参数
							        这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
	(6): 方法体 			完成功能的代码
	(7): return 			结束方法以及返回方法指定类型的值 
	(8): 返回值 			就是功能的结果，由return带回，带回给调用者	*/

方法重载

允许一个类中，可以出现多个同名方法，只要他们的参数个数不同，或者参数类型不同，就能构成重载。调用的时候，会根据参数个数和参数类型去匹配。
例题：选择正确的选项
下列哪个答案与show不是方法重载( B )。

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

数组

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

格式：

  	格式1： 数据类型[] 数组名；
    格式2： 数据类型   数组名[];
    /*举例：
    int[] a； 	定义了一个int类型的数组a；
	int a[];	定义了一个int类型的a数组；
	推荐使用第一种定义方式。*/

相关性质：

数组的定义语法：分为两种，动态定义（由我们规定数组的长度，由系统赋默认值：short、byte、long、int-0；boolean-false；float、double-0.0）和静态定义（由我们赋默认值，由系统规定数组的长度）。
注意事项：这两种方式，只能使用一种，不能进行动静结合。
Java中的数组必须先初始化才能使用。初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数据的使用，涉及栈内存、堆内存、方法区之间的互相调用（多个引用可以指向同一个空间）。
例题：

public class ArrayDemo2 {
        public static void main(String[] args) {
            int[] arr1 = new int[3];
            arr1[0]=10;
            arr1[2]=200;
            int[] arr2 = new int[3];
            arr2[0]=11;
            arr2[1]=19;
            int[] arr3=arr1;
            arr3[0]=108;
            arr3[1]=106;
            arr1[1]=177;
            System.out.println(arr1[0]); // 108
            System.out.println(arr1[1]); // 177
            System.out.println(arr1[2]); // 200
            System.out.println(arr2[0]); // 11
            System.out.println(arr2[1]); // 19
            System.out.println(arr2[2]); // 0
            System.out.println(arr3[0]); // 108
            System.out.println(arr3[1]); // 177
            System.out.println(arr3[2]); // 200
        }
        }

定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，再输出数组名称和元素。
定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重新赋值。
最后，再次输出第一个数组数组名称和元素。

数组的长度属性：length，数组中最后一个元素的索引：length（数组长度）-1。
数组的异常：数组角标越界异常（数组一旦定义好，长度就固定了），空指针异常（数组名 = null，人为置空）。
数组的遍历：利用for循环。
代码：

   public class ArrayDemo {
            public static void main(String[] args) {
                int[] arr={10,20,50,40,102};
                //数组的遍历
                //for(int i=0;i<arr.length;i++){
                //    System.out.println(arr[i]);
                //}
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }
                System.out.println("---------------------------");
                //反向遍历
                for(int i=arr.length-1;i>=0;i--){
                    System.out.println(arr[i]);
                }
            }
        }

获取数组中的最大值或最小值
代码：

>    public class ArrayDemo2 {
>         public static void main(String[] args) {
>             //获取数组中的最大值或最小值
>             int[] arr = {10, 20, 50, 40, 102};
>             int max = getMax(arr);
>             System.out.println("最大值是" + max);
>             int[] arr2 = {10, 20, 50, 40, 102,1000,1};
>             int max1 = getMax(arr2);
>             System.out.println("最大值是" + max1);
>         }
>         public static int getMax(int[] arr){
>             //定义一个参照值
>             int max = arr[0];
>             for (int i = 1; i < arr.length; i++) {
>                 if (arr[i] > max) {
>                     max = arr[i];
>                 }
>             }
>             return max;
>         }
>     }

调转数组中的元素（首尾元素交换，遍历一半）
代码：

 public class ArrayDemo3 {
     public static void main(String[] args) {
         //A:
         //案例演示:
         //数组元素反转(就是把元素对调)
         int[] arr = {10, 20, 30, 40, 50}; //50 40 30 20 10
         for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
             int t = arr[i];
             arr[i] = arr[j];
             arr[j] = t;
         }
         //reverseArray(arr);
         showArray(arr);
     }
     //数组元素反转
     private static void reverseArray(int[] arr) {
         //分析：首尾元素值交换，遍历一半
         for (int i = 0; i < arr.length / 2; i++) {
             //采用中间变量进行值交换
             int t = arr[i];
             arr[i] = arr[arr.length - 1 - i];
             arr[arr.length - 1 - i] = t;
         }
     }
     private static void showArray(int[] arr) {
         for (int i = 0; i < arr.length; i++) {
             System.out.print(arr[i] + ",");
         }
     }
 }

数组元素、索引的分别查找
代码：（1）输入索引，寻找数组元素：

    public class ArrayDemo8 {
         public static void main(String[] args) {
             //A:
             //案例演示:
             //数组查表法(根据键盘录入索引, 查找对应星期)
             //根据索引查元素
             //获取跟打印输出是两个概念
             String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
             Scanner scanner = new Scanner(System.in);
             System.out.println("请输入一个整数 1----7");
             int index = scanner.nextInt();
             String str = getElementByArray(index, arr);
             System.out.println(str);
         }
         private static String getElementByArray(int index, String[] arr) {
             if (index >= 1 && index <= 7) {
                 return arr[index - 1];
             } else {
                 return "查无此元素";
             }
         }
     }

（2）输入数组元素，寻找索引：

public class ArrayDemo9 {
    public static void main(String[] args) {
        //ctrl+alt+O 优化导包，没有的包导进来，没有用到的包删掉
        //根据元素查索引
        String[] arr = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个星期");
        String str = scanner.nextLine();//获取用户输入的字符串
        int index = getIndex(str, arr);
        System.out.println("该元素的索引是" + index)
    }
    private static int getIndex(String str, String[] arr) {
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            if (str.equals(arr[i])) {
                return i;
            }
        }
        return -1; // 一般喜欢用 -1 代表没找到
    }
}