3-Java方法和数组模型

__Miracle__

已于 2022-02-07 18:01:10 修改

阅读量220

点赞数

分类专栏： Java基础精讲文章标签： java 开发语言后端

于 2021-07-20 00:43:01 首次发布

本文链接：https://blog.csdn.net/qq_39276337/article/details/118916444

版权

Java基础精讲专栏收录该内容

24 篇文章 2 订阅

订阅专栏

方法(函数)

格式

修饰符 [static] 返回值类型 方法名(参数列表){
		方法体..
		return  结果;
}

修饰符：public 目前固定写法
返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调者
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return：将方法执行后的结果带给调用者，方法执行到return整体方法运行结束
return结果;这里的"结果"在开发中，我们正确的叫法成为方法的返回值
方法名遵循小驼峰命名法(第一个单词首字母小写,其余首字母都大写)

类名使用大驼峰命名法(所有单词首字母都大写)

        int res = getMax(10,20);
        System.out.println(res);
        System.out.println(compare(11, 22));
        System.out.println(compare(11, 11));
    }
    public static int getMax(int x, int y){
//        if (x>y) {
//            return x;
//        }else{
//            return y;
//        }
        // 三目运算符
        // 条件 ? 满足条件返回的值:不满足条件返回的值
        return x >= y? x : y;
    }

    public static boolean compare(int a, int b){
        return a==b? true: false;
    }

实现m, n的星星打印

 public static void main(String[] args) {
        print(5, 6);
    }
    public static void print(int m, int n){
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

世界上本没有方法, 代码写多了,就有了方法

方法几种形式

无参无返回
无参有返回
有参无返回
有参有返回

public class Demo1 {
    public static void main(String[] args) {
        // 调用方法
        print();
        getSum(10, 20);
        System.out.println(getSum2(10, 30));;
    }

    //    - 无参无返回
    public static void print() {
        System.out.println("Hello");
    }

    //    - 无参有返回
    public static int print2() {
        return 100;
    }
    //- 有参无返回
    public static void getSum(int a, int b){
        System.out.println("a + b = " + (a + b));
    }
    //- 有参有返回
    public static int getSum2(int a, int b){
        return a + b;
    }
}

方法重载(overload)

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


package com.company.day03;

public class Demo2 {
    public static void main(String[] args) {
        // 方法重载
        int a = 10;
        int b = 10;
        int e = 10;
        System.out.println(compare(a, b));
        System.out.println(compare(a, b, e));
        byte c = 10;
        byte d = 20;
        System.out.println(compare(c, d));
        System.out.println(compare(a, d));


    }
    public static boolean compare(int a, int b){
        System.out.println("int");
        return a == b;
    }
    public static boolean compare(int a, byte b){
        System.out.println("int a, short b");
        return a == b;
    }
    public static boolean compare(byte a, byte b){
        System.out.println("byte");
        return a == b;
    }

    public static boolean compare(int a, int b, int c){
        System.out.println("三个");
        return (a == b)&&(b==c);
    }
}

数组

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

数组的定义

·方式一格式：

数组存储的数据类型[] 数组名字;

方式二格式：

数组存储的数据类型数组名字[];

数组的初始化:数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
第一种初始化数组的格式(动态初始化):
数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

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

数组定义格式详解：

数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
new：关键字，创建数组使用的关键字。
数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改

和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。

定义可以存储5个整数的数组容器，代码如下：

  int[]  arr1 = new int[5];
  int arr2[] = new int[10];

数组的长度属性：每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由此可以推断出，数组的最大索引值为数组名.length-1。

int[] arr1 = new int[5];
int arr2[] = new int[10];
int arr3[] = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4};
System.out.println(arr4[0]);
System.out.println(arr4.length); // 4
System.out.println(arr1.length); // 5

索引访问数组中的元素：

数组名[索引]=数值，为数组中的元素赋值
变量=数组名[索引]，获取出数组中的元素

int[] arr1 = new int[5];
System.out.println(arr1[0]);
arr1[0] =100;
System.out.println(arr1[0]);

``java
public static void main(String[] args) {
int[] arr1;
int[] arr2 = new int[10];
int arr3[] = new int[10];
int[] arr4 = new int[]{1, 2, 3, 4};
int[] arr5 = {1, 2, 3, 4};
System.out.println(arr2.length);
System.out.println(arr5.length);
System.out.println(arr5); // [I@1b6d3586

    //   数组需要单个访问
    System.out.println(arr5[0]);
    System.out.println(arr5[1]);
    System.out.println(arr5[2]);
    arr2[0] = 100;
    System.out.println(arr2[0]);
}


案例
```java
public static void main(String[] args) {
        int[]  arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
            arr[i] = i + 100;
        }
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

数组原理内存图

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

Java虚拟机(JVM)的内存划分

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

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

的变量arr保存的是数组的地址。
输出arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素

public static void main(String[] args) {
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2);
}

两个变量同时指向一个数组

public static void main(String[] args) {
        int[]  arr = new int[3];
        arr[0] = 5;
        arr[1] = 6;
        arr[2] = 7;
        // 输出
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        int[] arr2 = arr;
        arr2[1] = 100;

        System.out.println("arr[1]" + arr[1]);

        int a = 100;
        int b = a;
        b = 10;
        System.out.println(a);
    }

数组操作的常见问题

数组越界异常

 public static void main(String[] args) {
        int[] arr1 = {};
        // ArrayIndexOutOfBoundsException
//        System.out.println(arr1[0]);
        int[] arr2 = {133, 444, 555};
        System.out.println(arr2[3]);
    }

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

数组空指针异常

 public static void main(String[] args) {
        int[]  arr = {1, 2, 3};
        arr = null;
        // NullPointerException
        System.out.println(arr[0]);
    }

arr = null这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
解决方案 : 给数组一个真正的堆内存空间引用即可！

数组获取最大值元素

**最大值获取：**从数组的所有元素中找出最大值。
实现思路：
- 定义变量，保存数组0索引上的元素
- 遍历数组，获取出数组中的每个元素
- 将遍历到的元素和保存数组0索引上值的变量进行比较
- 如果数组元素的值大于了变量的值，变量记录住新的值
- 数组循环遍历结束，变量保存的就是数组中的最大值
  -


   public static void main(String[] args) {
        int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max)
                max = arr[i];
        }
        System.out.println("max = " +  max);
    }

封装

 public static void main(String[] args) {
        int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
        System.out.println(getMax(arr));
    }
    public static int getMax(int[] arr){
        if (arr.length <=0)
            return 0;
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >max)
                max = arr[i];
        }
        return max;
    }

求数组的和

 public static void main(String[] args) {
        int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
        System.out.println(getSum(arr));
    }

    public static int getSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return  sum;
    }

生成数组

package com.company;

import java.util.Random;

public class Demo11 {
    public static void main(String[] args) {
        int[] array = generateArray(10, 20, 100);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] +"\t");
        }
    }
    public static int[] generateArray(int n, int start, int end){
        Random random = new Random();
        int[] arr =  new int[n];
        for (int i = 0; i < n; i++) {
            // 左闭右开
            int num = random.nextInt(end-start+1) + start;
            arr[i] = num;
        }
        return arr;
    }
}