第二周笔记

public class Calc {
    //加法, 把和作为一个结果返回出去, 返回给调用者
    public int add3(int num1, int num2){
        if(num1 == 0 && num2 == 0){
            return 0;  //隐式包含一个if-else结构
        }
        //使用return 关键字
        return num1 + num2;
    }

    public void fun1(){
        System.out.println("开始执行fun1方法...");
        if(true){
            System.out.println("fun1方法中途退出");
            return;  //退出方法
        }
        System.out.println("fun1方法执行完成");
    }

    public void fun2(){
        for (int i = 0; i <10 ; i++) {
            System.out.println(i);
            if(i == 5){
               // break; //退出循环 0~5  fun2执行完成
                return; //退出方法 0~5
            }
        }
        System.out.println("fun2执行完成....");
    }

    public static void main(String[] args) {
        Calc calc = new Calc();
        /*
        //调用有返回值的方法
        calc.add3(10,8);//程序能正常运行, 但是返回值结果数据丢失
        int rs = calc.add3(11,8);
        System.out.println(rs);
        long rs1 = calc.add3(11,8); // int 自动转换为long
        System.out.println(rs1);
         */
        //调用fun1
        calc.fun1();

        calc.fun2();

        int[] arr = {1,2,55,22,33,111,222,56};
        int[] rsArr = calc.findMaxAndMin(arr);
        System.out.println("最大值:"+rsArr[0]);
        System.out.println("最小值:"+rsArr[1]);
    }

    //如果一个方法返回多个数据   找数组的最大值,最小值并返回
    //返回数组
    // 返回值类型可以是数组类型
    public  int[] findMaxAndMin(int[] arr){
        int[] nums = new int[2]; //存放最大值,最小值
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            //找最大值
            if(max < arr[i]){
               max = arr[i];
            }
            //最小值
            if(min > arr[i]){
                min = arr[i];
            }
        }

        //把最大值,最小值保存数组
        nums[0] = max;
        nums[1] = min;
        return nums;
    }

    public int fun3(int a){
        if(true){
            return 1;
        }
        return -1;
    }
}
 

 

 

带参方法

方法定义的参数称为形参, jdk判断方法参数列表: 根据参数数据类型, 参数个数, 参数的位置

调用方法的时候, 传递变量, 称为实参

方法的参数传递: 值传递

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值 值数据

对于引用数据类型(类类型)的参数, 形式参数的改变，影响实际参数的值 地址码

有返回值的方法

定义有返回值方法, 在方法体使用return 结果返回数据.

有返回值方法的调用: 需要定义变量接收方法返回值, 保存数据

接收返回值的变量的数据类型与返回值类型匹配

return 使用方式:

• return 退出方法 只能在无返回值的方法内部使用

• return 结果 只能在有返回值的方法内部使用, 1) 返回结果 2) 退出方法

return关键字作用: 退出方法

方法重载

如果一组方法, 功能类似的, 但是参数不一样,

第一种方式: 给每个方法取不同的名字, 通过名字来区分

缺点:

1. 开发者想一堆的名字

2. 使用者记一堆的名字

第二种方式: JAVA提供了 方法重载的机制

在同一个类中, 方法名一样, 参数列表不一样的一组方法,称为方法的重载, 与返回值无关

参数列表不一样:

1. 参数个数不一样

2. 参数对应位置的数据类型不一样

3. 与参数名无关

功能相似的推荐使用方法重载的方式, 如果不同功能的方法, 取不同的方法名

方法注意事项

• 方法内部不能再定义方法

• 

   

 

 

 

 

 

 

//1,声明一个二维数组
        int[][] arr;
        //2. 开辟空间
        arr = new int[3][4];  // 包含3个一维数组,而且每一个一维数组长度都是4
        //第一个长度: 3: 一维数组的个数
        //第二个长度: 4: 一维数组的长度
        //arr[下标]: 获取下标为几的一维数组
        arr[0] = new int[]{1,2,3,4,5};
        arr[1] = new int[]{1,3,5,7};
        arr[2] = new int[]{2,4,6,8};
        //arr[3] = new int[]{2,4,6,8};

        int[][] arr2 = new int[5][];
        // arr2二维数组包含5个一维数组, 但是每一个一维数组的长度不确定

        //循环变量
        // 得到一维数组的个数: 数组名.length
        for (int i = 0; i             // 每一个一维数组的长度 arr[i].length
            for (int j = 0; j < arr[i].length; j++) { //遍历每一个一维数组
                //arr[0][0]: 二维数组中第一个一维数组的第一个元素
                System.out.print(arr[i][j]+", ");
            }
            System.out.println();
        }

//冒泡排序
        int arr[] = {26,34,1,29,39,28,2,44,48,27,12};

        //升序排序
        for (int i = 1; i <= arr.length -1 ; i++) {  //控制的轮  = 数组的长度-1
            for (int j = 0; j < arr.length -i; j++) { //每一轮的次数  j作为数组下标  = 数组长度 - 轮
                //两两比较,如果违反规则,进行交换
                //if(arr[j] > arr[j+1]){ //如果前一个元素比后一个元素大,违反规则 升序
                if(arr[j] < arr[j+1]){   //降序 大在前,小在后  违反规则(大的在后)
                    //交换
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        System.out.println("排序之后的结果:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+", ");
        }

 

## 二维数组

一维数组:   `数组名[]`

二维数组: `数组名[][]`   由多个一维数组组成

三维数组: `数组名[][][]`  由多个二维数组组成

 

二维数组的第一个长度,设不设意义不大

二维数组名.length: 表示二维数组包含多少个一维数组

二维数组名[i].length: 表示获取二维数组中下标为i的一维数组的长度

获取每一个元素: 数组名[i][j]

实际开发中: 常用的一维数组, 多维数组: 使用一维对象数组来表示

java: 面向对象编程

数组的排序, 面试

升序,降序

十大排序方式: 冒泡, 选择, 插入, 堆排序….

冒泡排序

数据结构和算法动态可视化 (Chinese) - VisuAlgo

思路:

1. 从数组的第一个元素开始,依次与后面的元素进行两两比较, 如果违反排序规则,进行交换, 经过第一轮, 把最大/最小的元素排在最后一个位置

1. 从数组的第一个元素开始,依次与后面的元素进行两两比较, 如果违反排序规则,进行交换, 经过第二轮, 把第二大/第二小的元素排在倒数第二个位置

2. 依次内推, 把第二小/第二大的元素排在第二个位置, 该数组排序完成

数组有10个元素: 确定9个

排序轮数 = 数组长度-1 : 外循环

每一轮比较的次数: = 数组长度 - 轮数 : 内循环

排序性能: 时间复杂度 O(n^2) 循环的次数

最小的时间复杂度: O(n)

扩展: 选择排序, 插入排序, 每一种排序时间复杂度

 

int left = 0;

int right = arr.length - 1;

while(left < right){

        int min = left;

        int max = left;

        for(int i = left;i <= right;i++){

                if(arr[i] < arr[min]){

                        min = i;

                }

                if(arr[i] > arr[max]){

                        max= i;

                }

        }

        swap(arr[left],arr[min]);

        if(left == max){

                max = min;

        }

        swap(right,max);

        left++;

        right--;

}

选择排序：O(n^2) 因为每一次遍历数组数组时，都要遍历数组选出最大和最小的数组，每一次遍历都是O(n),就算是自身有序的也要遍历筛选