2023.3.27学习Java打卡

Java方法

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

例：

public class demo1 {
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }
    
    public static int add(int a, int b){
        return a+b;
    }
}

方法的定义：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法调用

调用方法：对象名.方法名(实参列表)
1. 若方法返回一个值：
```
int num = max(30, 40);
```
2. 若方法返回值是void：
```
System.out.println("xxxxxxxx");
```
  调用一定是一条语句。
  
  Java都是值传递！！
方法的重载：在一个类中，方法名相同，形参不同的函数。

规则：
- 方法名必须相同
- 参数列表必须不同（个数，类型，参数排列顺序不同等）
- 方法返回类型可相同可不同
- 仅返回类型不同，不可成为方法重载
命令行传参

可变参数

规则：

在指定参数类型后加一个省略号(...)
一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在他前面声明。

例：

public class Demo1 {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.test(1,2,56,51,3,8);
    }
    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }

递归

小练习：写一个计算器，要求实现加减乘除功能，并且能循环接受新的数据。

以下是我的代码：

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        for (int i = 0; i < 1000; i++) {
            System.out.println("您需要做什么计算？加法、减法、乘法、除法。");
            System.out.println("完成请输入退出");
            Scanner scanner = new Scanner(System.in);
            String need = scanner.nextLine();
            if(need.equals("加法")){
                double x = scanner.nextDouble();
                double y = scanner.nextDouble();
                demo1.add(x, y);
            }else if (need.equals("减法")) {
                double x = scanner.nextDouble();
                double y = scanner.nextDouble();
                demo1.sub(x, y);
            }else if (need.equals("乘法")) {
                double x = scanner.nextDouble();
                double y = scanner.nextDouble();
                demo1.multi(x, y);
            }else if (need.equals("减法")) {
                double x = scanner.nextDouble();
                double y = scanner.nextDouble();
                demo1.div(x, y);
            } else if (need.equals("退出")) {
                break;
            }
        }
    }
    public void add(double a, double b){
        double sum = 0;
        sum = a + b;
        System.out.println(a + "+" + b + "=" + sum);
    }
    public void sub(double a, double b){
        double sum = 0;
        sum = a - b;
        System.out.println(a + "-" + b + "=" + sum);
    }
    public void multi(double a, double b){
        double sum = 0;
        sum = a * b;
        System.out.println(a + "*" + b + "=" + sum);
    }
    public void div(double a, double b){
        double sum = 0;
        sum = a / b;
        System.out.println(a + "/" + b + "=" + sum);
    }
}

还请各位大神亮出你们的代码，我的代码好像太啰嗦了。

数组

定义：数组是相同类型数据的集合，是按照一定次序排列相同类型的若干数据的组合。其中每一个数据被称为一个数组元素，每个数组元素可以通过一个下标来访问他们。

数组声明创建
```
//声明数组
dataType[] arrayRefVar;                        //首选方法
dataType arrayRefVar[];                        //效果相同，但并非首选
//使用new操作符创建数组
dataType[] arrayRefVar = new dataType[arraySize];
//获取数组长度
arrays.length
```
数组特点：
- 其长度确定，一旦被创建，大小不可改变。
- 其元素必须是相同类型，不可混合其他类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于引用类型，数组也可看作为对象，数组中的每个元素相当于该对象的成员变量。数组对象本身是在堆中。

内存分析

堆
- 存放new的对象和数组；可被所有线程共享
栈
- 存放基本变量类型（包括这个基本变量的具体数值）；
- 引用对象的变量（会存放这个引用在堆里面的集体地址）
方法区
- 可以被所有的线程共享
- 包含所有的class和static变量

三种初始化

静态初始化

int[] a = {1, 2, 3};
Man[] mans = {new Man(1, 1), new Man(2, 2)};

动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

数组的默认初始化

数组是引用类型，其元素相当于类的实例变量，因此，数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组边界

下标的合法区间：[0, length-1]
越界则报ArrayIndexOutOfBoundsException。

数组使用

for-each循环
数组作方法入参
数组作返回值

多维数组

二维数组
```
int a[][] = new int[2][5]
```

Arrays类

可以用提供的工具类Arrays，对数据对象进行一些基本操作。
Arrays类中的方法都是static修饰的静态方法，可以直接使用类名调用。

冒泡排序

import java.util.Arrays;

public class MaoPaoPaiXu {
    public static void main(String[] args) {
        int[] a = {1,2,3,5,7,9,22,44,63,75};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        int temp = 0;
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;//通过flag标识符减少没有意义的比较
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1] > array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

当数组中大部分元素为0，或为同一值时，可用稀疏数组来保存。

处理方式：

记录数组一共有几行几列，有多少不同值。

把具有不同值的元素和行列和值记录在小规模数组中，从而缩小程序的规模。

例：

public class XiShuMetrix {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        System.out.println("输出原始数组：");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值个数为："+sum);

        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值放入稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("稀疏数组：");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                             + array2[i][1] + "\t"
                             + array2[i][2] + "\t");
        }
        //还原稀疏数组
        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //给其中元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        System.out.println("输出还原数组：");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}