【Java】Java学习（五）—— 方法和数组

最新推荐文章于 2024-08-26 16:40:46 发布

伍陆壹柒

最新推荐文章于 2024-08-26 16:40:46 发布

阅读量194

点赞数 1

分类专栏： Java从零开始文章标签： java

本文链接：https://blog.csdn.net/liuliuliu561/article/details/107291675

版权

Java从零开始专栏收录该内容

15 篇文章 1 订阅

订阅专栏

上一篇： Java学习（四）—— IntelliJ IDEA的安装及简单使用

第十三部分方法

13.1 定义方法的格式详解

修饰符 返回值类型 方法名(参数列表){
  //代码省略...
  return 结果; 
}

修饰符： public static（现阶段固定写法）
返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者。
参数列表： 方法在运算过程中的未知数据，调用者调用方法时传递。
return： 将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束。

参数如果有多个，使用逗号进行分隔。
return后面的“返回值”，必须和方法名称前面的“返回值类型”保持对应。
对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。return；表示结束方法，也可以省略不写。
一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。

13.2 方法调用

三种方法
- 单独调用：方法名称(参数)；
- 打印调用：System.out.println(方法名称(参数))；
- 赋值调用：数据类型变量名称 = 方法名称(参数)；

public class Method {
  
    public static void main(String[] args) {
        // 单独调用
        sum(10, 20);
        System.out.println("===========");

        // 打印调用
        System.out.println(sum(10, 20)); // 30
        System.out.println("===========");

        // 赋值调用
        int number = sum(15, 25);
        number += 100;
        System.out.println("变量的值：" + number); // 140
    }

    public static int sum(int a, int b) {
        System.out.println("方法执行啦！");
        int result = a + b;
        return result;
    }
  
}

注意
- 对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
- 对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

public class MethodReturn {
  
    public static void main(String[] args) {
        int num = getSum(10, 20);
        System.out.println("返回值是：" + num);
        System.out.println("==============");

        printSum(100, 200);
        System.out.println("==============");

        System.out.println(getSum(2, 3)); // 正确写法
        getSum(3, 5); // 正确写法，但是返回值没有用到
        System.out.println("==============");

        // 对于void没有返回值的方法，只能单独，不能打印或者赋值
				// System.out.println(printSum(2, 3)); // 错误写法！
				// System.out.println(void);

				// int num2 = printSum(10, 20); // 错误写法！
				// int num3 = void;
				// void num4 = void;
    }

    // 有返回值
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }

    // 没有返回值
    public static void printSum(int a, int b) {
        int result = a + b;
        System.out.println("结果是：" + result);
    }

}

13.3 方法重载

方法重载（Overload）： 指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符、参数名称和返回值类型无关。
参数列表： 个数不同，数据类型不同，顺序不同。
重载方法调用： JVM通过方法的参数列表，调用不同的方法。

public class Demo01MethodOverload {
  
    public static void main(String[] args) {
      
        System.out.println(sum(10, 20)); // 两个参数的方法
        System.out.println(sum(10, 20, 30)); // 三个参数的方法
        System.out.println(sum(10.0, 20.0, 30.0, 40.0));	// 四个参数的方法
      
    }

    public static int sum(int a, double b) {
        return (int) (a + b);
    }

    public static int sum(double a, int b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数的方法执行！");
        return a + b;
    }

    // 错误写法！与方法的返回值类型无关
//    public static double sum(int a, int b) {
//        return a + b + 0.0;
//    }

    // 错误写法！与参数的名称无关
//    public static int sum(int x, int y) {
//        return x + y;
//    }

    public static int sum(double a, double b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个参数的方法执行！");
        return a + b + c;
    }

    public static double sum(double a, double b, double c, double d) {
        System.out.println("有4个参数的方法执行！");
        return a + b + c + d;
    }

}

比较两个数据是否相等

public class OverloadSame {

    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));
        System.out.println(isSame((short) 20, (short) 20));
        System.out.println(isSame(11, 12));
        System.out.println(isSame(10L, 10L));
    }

    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数的方法执行！");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }

    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数的方法执行！");
        boolean same = a == b ? true : false;
        return same;
    }

    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数的方法执行！");
        return a == b;
    }

    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数的方法执行！");
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }

}

第十四部分数组

14.1 数组概念

概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

14.2 数组定义

14.2.1 动态初始化（指定长度）

格式： 数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[长度];

// 创建一个数组，里面可以存放300个int数据
int[] arrayA = new int[300];

// 创建一个数组，能存放10个double类型的数据
double[] arrayB = new double[10];

// 创建一个数组，能存放5个字符串
 String[] arrayC = new String[5];

14.2.2 静态初始化（指定内容）

标准格式： 数据类型[ ] 数组名 = new 数据类型[ ]{元素1,元素2,元素3…};
省略格式： 数据类型[ ] 数组名 = {元素1,元素2,元素3…};

// 直接创建一个数组，里面装的全都是int数字，具体为：5、15、25
int[] arrayA = new int[] { 5, 15, 25, 40 };
int[] arrayC = {5, 15, 20};

// 创建一个数组，用来装字符串："Hello"、"World"、"Java"
String[] arrayB = new String[] { "Hello", "World", "Java" };
String[] arrayD = {"Hello", "World", "Java"};

静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
静态初始化标准格式可以拆分成为两个步骤。
动态初始化也可以拆分成为两个步骤。
静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。
不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

// 静态初始化的标准格式，可以拆分成为两个步骤
int[] arrayB;
arrayB = new int[] { 11, 21, 31 };

// 动态初始化也可以拆分成为两个步骤
int[] arrayC;
arrayC = new int[5];

// 静态初始化的省略格式，不能拆分成为两个步骤。
// int[] arrayD;
// arrayD = { 10, 20, 30 };

14.3 数组的访问

索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。
格式： 数组名[索引]

public class ArrayUse {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30 };
        System.out.println(array); // 内存地址哈希值

        // 直接打印数组当中的元素
        System.out.println(array[0]); // 10
        System.out.println(array[1]); // 20
        System.out.println(array[2]); // 30

        // 也可以将数组当中的某一个单个元素，赋值交给变量
        int num = array[1];
        System.out.println(num); // 20
    }

}

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
- 如果是整数类型，那么默认为0
- 如果是浮点类型，那么默认为0.0
- 如果是字符类型，那么默认为'\u0000'
- 如果是布尔类型，那么默认为false
- 如果是引用类型，那么默认为null

public class ArrayUse {

    public static void main(String[] args) {
        // 动态初始化一个数组
        int[] array = new int[3];

        System.out.println(array); // 内存地址哈希值
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 0
        System.out.println(array[2]); // 0
        System.out.println("=================");

        // 将数据123赋值交给数组array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]); // 0
        System.out.println(array[1]); // 123
        System.out.println(array[2]); // 0
    }

}

14.4 Java中的内存划分

14.4.1 内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

14.4.2 Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

JVM的内存划分

区域名称	作用
方法栈（Stack）	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。同时也存放着方法中的局部变量（方法的参数或者时方法{ }内部的变量），一旦超出作用域，立刻从栈内存中消失。方法的运行一定要在栈中运行。
堆内存（Heap）	存储对象或者数组，new来创建的，都存储在堆内存。
方法区（Method Area）	存储可以运行的.class文件。
本地方法栈（Native Method Stack）	JVM在使用操作系统功能的时候使用，和我们开发无关。
寄存器（pc Register）	给CPU使用，和我们开发无关。

堆内存
- 堆内存里面的东西都有一个地址值（16进制）
- 堆内存里面的数据，都有默认值，规则：
  - 如果是整数类型，那么默认为0
  - 如果是浮点类型，那么默认为0.0
  - 如果是字符类型，那么默认为'\u0000'
  - 如果是布尔类型，那么默认为false
  - 如果是引用类型，那么默认为null

14.5 数组在内存中的存储

14.5.1 一个数组内存图

在这里插入图片描述

14.5.2 两个数组内存图

在这里插入图片描述

14.5.3 两个变量指向一个数组

在这里插入图片描述

14.6 数组常见操作

14.6.1 数组越界

如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常（ArrayIndexOutOfBoundsException）。

public class ArrayIndex {

    public static void main(String[] args) {
        int[] array = {15, 25, 35};

        System.out.println(array[0]); //15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 35

        // 错误写法
        // 并不存在3号元素，所以发生异常
        // System.out.println(array[3]);
    }

}

在这里插入图片描述

14.6.2 空指针异常

数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常 （NullPointerException）。

public class ArrayNull {

    public static void main(String[] args) {
        int[] array = null;		// 空指针
				// array = new int[3];
        System.out.println(array[0]);		// 访问不到
    }

}

在这里插入图片描述

14.6.3 获取数组长度

格式： 数组名称.length
数组一旦创建，程序运行期间，长度不可改变。

public class ArrayLength {

    public static void main(String[] args) {
        int[] arrayA = new int[3];

        int[] arrayB = {10, 20, 30, 3, 5, 4, 6, 7, 8, 8, 65, 4, 44, 6, 10, 3, 5, 4, 6};
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是：" + len);
        System.out.println("=============");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length); // 3
        arrayC = new int[5];
        System.out.println(arrayC.length); // 5
    }

}

在这里插入图片描述

14.6.4 数组遍历

数组遍历： 将数组中的每个元素分别获取出来，就是遍历。

public class Array {

    public static void main(String[] args) {
        int[] array = { 15, 25, 30, 40, 50, 60, 75 };

        // 首先使用原始方式
        System.out.println(array[0]); // 15
        System.out.println(array[1]); // 25
        System.out.println(array[2]); // 30
        System.out.println(array[3]); // 40
        System.out.println(array[4]); // 50
        System.out.println(array[5]); // 50
        System.out.println("=================");

        // 使用循环，次数其实就是数组的长度。
      	// 可使用快捷键：6.fori + enter 
        for (int i = 0; i < 6; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=================");

				// int len = array.length; // 长度
      	// 可使用快捷键：array.fori + enter 
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}

14.6.5 数组反转

数组反转： 数组元素顺序颠倒

public class ArrayReverse {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };

        // 遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");

        /*
        初始化语句：int min = 0, max = array.length - 1
        条件判断：min < max
        步进表达式：min++, max--
        循环体：用第三个变量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        // 再次打印遍历输出数组后来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}

在这里插入图片描述

14.7 数组作为方法参数和返回值

14.7.1 数组作为方法参数

数组作为方法参数传递，传递的参数是数组内存的地址。

public class ArrayParam {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };

        System.out.println(array); // 地址值

        printArray(array); // 传递进去的就是array当中保存的地址值
        System.out.println("==========AAA==========");
        printArray(array);
        System.out.println("==========BBB==========");
        printArray(array);
    }

    public static void printArray(int[] array) {
        System.out.println("printArray方法收到的参数是：");
        System.out.println(array); // 地址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}

14.7.2 数组作为方法返回值

一个方法可以有0、1、多个参数，但是只能有0或者1个返回值，不能有多个返回值。
数组作为方法的返回值，返回的是数组的内存地址。

public class ArrayReturn {

    public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);

        System.out.println("main方法接收到的返回值数组是：");
        System.out.println(result); // 地址值

        System.out.println("总和：" + result[0]);
        System.out.println("平均数：" + result[1]);
    }

    public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c; // 总和
        int avg = sum / 3; // 平均数
        // 两个结果都希望进行返回

        // 需要一个数组，数组可以保存多个结果
        /*
        int[] array = new int[2];
        array[0] = sum; // 总和
        array[1] = avg; // 平均数
        */

        int[] array = { sum, avg };
        System.out.println("calculate方法内部数组是：");
        System.out.println(array); // 地址值
        return array;
    }

}