2024暑假第四周总结

数组

容器，可以用来存储同种数据类型的多个值
需要结合隐式转换考虑
容器的类型和存储数据的类型保持一致

数组的定义：

格式一：
数据类型 [] 数组名
int [] array
格式二：
数据类型 数组名 []
int array []

数组初始化：在内存中，为数组容器开辟空间，并将数据存入容器中的过程

数组静态初始化和动态初始化的区别：
动态初始化：手动指定数组长度，由系统给出默认初始化
静态初始化：手动指定数组元素，系统根据元素个数，计算长度

静态初始化：

完整格式：
数据类型 []数组名 = new 数据类型 [ ] {元素1,元素2,元素三,…};
简化格式：
数据类型 []数组名 = {元素1,元素2,元素三,…};
数组长度定义后不变

动态初始化

初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 =new 数据类型[数组长度];

数组的地址值：

public class ArrayDemo1 {
    public static void main(String[] args) {
        int[] arr1 = new int[]{11,12,13,14};
        int[] arr2 = {11,12,13,14};
        String[] arr3 = new String []{"zhangsan","lisi","wangwu","zhaoliu"};
        String[] arr4 = {"zhangsan","lisi","wangwu","zhaoliu"};
        double[] arr5 = new double[]{161.5,189.6,179.9,193.8};
        double[] arr6 = {161.5,189.6,179.9,193.8};
        System.out.println(arr1);//[I@b4c966a
    }
}

地址值：[I@b4c966a
地址值的格式含义：[ ：表示是一个数组
I ：表示当前数组里面的元素都是int类型的
@ : 表示一个间隔符号（固定格式）
b4c966a：才是数组真正地址（十六进制）

数组元素访问格式：

数组名[索引];
索引：下标，角标
特点：从0开始，逐个+1，连续不间断

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        //获取数组中的元素
        int number = arr[0];
        System.out.println(number);
        System.out.println(arr[1]);
    }
}

数组的内存图：

两个数组指向同一空间的内存图
当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果。

数组遍历：

java中，关于数组的一个长度属性，length
调用方式：数组名.length
拓展：
自动生成数组的遍历方式
idea提供的：数组名.fori

常见问题

索引越界

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        //长度5
        //最小索引：0
        //最大索引：4
        System.out.println(arr[10]);
    }
}

数组常见操作：

求最值
求和:

import java.util.Random;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int number = r.nextInt(100) + 1;
            arr[i] = number;
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("所有数据的总和：" + sum);
        int temp = sum /arr.length;
        System.out.println("平均数"+ temp);
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (temp < arr[i]) {
                count++;
            }
        }
        System.out.println("一共有" + count + "个数据比平均数大");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

交换数据：
定义中间变量
打乱数据：
获取随机索引Random

import java.util.Random;

public class ArrayDemo4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        Random r = new Random();
        int number = r.nextInt(arr.length);
        System.out.println(number);
    }
}

实例：

import java.util.Random;

public class ArrayDemo4 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int number = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[number];
            arr[number] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

java内存分配

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆：存储对象或者数组，new来创建的，都存储在堆内存中
堆内开发的空间有地址值
方法区：存储可以运行的class文件
本地方法栈：JVM在使用操作系统功能的时候使用
寄存器：给CPU使用

方法

程序中最小的执行单元
main方法,主方法
作用：调用方法（解决代码重复问题） 提高代码复用性、可维护性
把一些代码打包，用的时候就调用
方法定义——一些代码打包
方法调用——手动调用

定义格式

最简单：
public static void 方法名 () {
方法体 (就是打包起来的代码);
}
调用：方法名 () ;
方法必须先定义后调用，否则报错
实例：

public class MethodDemo1 {
    public static void main(String[] args) {
        //调用方法
        playGame();
        playGame();
    }
    //定义一个方法
    //放在类内,main方法之外
    public static void playGame (){
        System.out.println("1");
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
    }
}

public class MethodDemo2 {
    public static void main(String[] args) {
        student();

    }
    public static void student(){
        System.out.println("张三");
        System.out.println("性别男");
        System.out.println("20岁");
        System.out.println("身高187");
    }
}

public class MethodDemo3 {
    public static void main(String[] args) {
        getSum();
    }
    public static void getSum(){
        int number1 = 10;
        int number2 = 20;
        int sum = number1 + number2;
        System.out.println(sum);
    }
}

带参数：
定义：
public static void 方法名(参数) {… …}

调用：

method(变量);
形参：方法定义中参数
实参：方法调用中参数
调用时，形参和实参必须一一对应
带返回值：
格式：
public static 返回值类型方法名(参数) {
方法体;
return 返回值;
}
调用：
直接调用：方法名(实参);
赋值调用：整数类型 变量名 = 方法名 (实参);
输出调用：System.out.println(方法名(实参));

public class MethodDemo4 {
    public static void main(String[] args) {
        //直接调用
        method1(10,30,50);
        //赋值调用
        int sum = method1(10,30,50);
        System.out.println(sum);
        //输出调用
        System.out.println(method1(10,30,50));;
    }
    public static int method1(int a, int b,int c) {
        return a + b + c;//返回给方法的调用处
    }
}

方法注意事项：
方法不调用就不执行
方法与方法是平级关系，不能互相嵌套定义（嵌套调用可以，不能嵌套定义）
方法的编写顺序和执行顺序无关

方法的重载：

在同一类中，定义了多个同名的方法，这些同名的方法具有同种功能
每个方法具有不同参数类型或参数个数
同一个类中，方法名相同，参数不同的方法，与返回值无关
参数不同：个数不同、类型不同、顺序不同

public class MethodDemo5 {
    public static void main(String[] args) {
        method1((byte)5, (byte)6);
    }
    public static void method1(byte b1,byte b2) {
        System.out.println(b1 == b2);

    }
    public static void method1(short s1,short s2) {
        System.out.println(s1 == s2);
    }
    public static void method1(int i1,int i2) {
        System.out.println(i1 == i2);
    }
    public static void method1(long o1,long o2) {
        System.out.println(o1 == o2);
    }
}

练习：

复制数组：

public class MethodDemo6 {
    public static void main(String[] args) {
        //定义原始数组
        int[] arr = {1,2,3,4,5,6,7,8,9};
        //调用方法拷贝数据
        int [] copyArr = method1(arr,3,7);
        //遍历copyArr
        for (int i = 0; i < copyArr.length; i++) {
            System.out.print(copyArr[i] + " ");
        }

    }
    public static int[] method1(int [] arr,int from,int to) {
        //定义数组，动态初始化
        int [] newArr = new int[to-from];
        //复制数据
        //伪造索引的思想
        int index = 0;
        for (int i = from; i < to; i++) {
            newArr[index] = arr[i];
            index++;
        }
        return newArr;

    }
}

平方根应用
获取随机数
导包 – Random这个类在哪
import java.util.Random
创建对象
Random r = new Random () ;
上式中只有r是变量名，可以变，其他的都不允许变
接收数据
int number = r.nextInt(随机数范围);
上式中只有number是变量名，可以变，其他都不能变

import java.util.Random;
public class Demo2 {
    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(9) + 7;// 7~15
        System.out.println(number);
    }
}

猜数字

import java.util.Random;
import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(100) + 1;// 1~100
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("Enter a number: ");
            int guessnumber = sc.nextInt();
            if(guessnumber > number) {
                System.out.println("大了");
               }else if(guessnumber > number) {
                System.out.println("小了");
            }else {
                System.out.println("Guess number is: " + guessnumber);
                System.out.println("You guessed correctly!");

                break;
        }

        }
    }
}

总结：

本周继续学习java数组和方法相关的基础语法，并进行了相关练习。
下周进行面向对象和管理系统的相关内容的学习。
本周主要问题是学习态度不够积极，学习效率较低，要合理规划时间进行有效学习。