02-数组，方法

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量69 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59939643/article/details/128010647
版权

数组

  • 引入

    变量定义 ： 数据类型 变量名 = new 数据类型();

    Integer zhangsanAge = new Integer();

    数组

  • 数组： 存储相同的数据类型的值的容器

  • 数据格式

    /**
 * Author itcast
 * Date 2021/5/3 9:49
 * Desc TODO
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组的格式
        //1. 动态定义数组
        数据类型[] 数组名称 = new 数据类型[长度];  // 推荐使用
        数据类型 数据名称[] = new 数据类型[长度];
        //2. 静态定义数组
        数据类型[] 数组名称 = new 数据类型[]{值1,值2...};
        数据类型[] 数组名称 = {值1,值2...};   // 推荐使用
        
        // 数据类型 代表是 当前数组的元素的类型
        // [] 代表是 当前这个类型是数组
        // [长度] 代表是 当前数组的长度（容量的大小）
        // {} 代表是 静态分配的元素集合
    }
}

  • 案例1 - 定义数组

    /**
 * Author itcast
 * Date 2021/5/3 9:55
 *         //1. 动态定义数组
 *         数据类型[] 数组名称 = new 数据类型[长度];  // 推荐使用
 *         数据类型 数据名称[] = new 数据类型[长度];
 *         //2. 静态定义数组
 *         数据类型[] 数组名称 = new 数据类型[]{值1,值2...};
 *         数据类型[] 数组名称 = {值1,值2...};   // 推荐使用
 */
public class ArrDemo01 {
    public static void main(String[] args) {
        //1.创建int类型的数组, 用来存储3个元素.
        int[] arr = new int[3];
        //2.创建int类型的数组, 存储数据11, 22, 33.
        int[] arr1 = {11,22,33};
        //3.创建boolean类型的数组，用来存储3个元素 false,false,false
        boolean[] bs = new boolean[3];
    }
}

  • 数组的特点

    1. 数组的存储是顺序的，获取数据的下标（索引），默认索引位置是 0

    2. 数组类型默认值

      int 类型默认值是 0

      String 类型默认值是 null

      boolean 类型默认值是 false

      double 类型默认值是 0.0d

  • 数组的基本用法

    1. 如何获取数组的值 格式： 数组名称[索引]

      如果数组名是 arr 获取第12个位置的数据 arr[11]

    2. 如何对数组的进行赋值 数组名称[索引]=值

      int[] arr = new int[3]; // 0,0,0

      第二个值赋值为15

      arr[1]=15;

    3. 如何获取数组的长度呢 数组名称.length

      int[] arr = new int[3]; // 0,0,0

      arr.length // 3

  • 案例1 - 基础需求

    /**
 * Author itcast
 * Date 2021/5/3 10:08
 * 数据类型[] 数组名称= new 数据类型[长度];
 * 数据类型[] 数组名称 = {值1,值2...};
 */
public class ArrayDemo03 {
    public static void main(String[] args) {
        //1.定义一个长度为5的int类型的数组.
        int[] arr1= new int[5];
        //2.打印数组中的第3个元素.
        System.out.println(arr1[2]);
        //3.设置数组中的第一个元素值为11.
        arr1[0]=11;
        //4.获取数组中的第一个元素值, 并将其赋值给变量a, 然后打印.
        int a = arr1[0];
        //5.打印数组的长度.
        System.out.println(arr1.length);
    }
}

  • 内存划分图

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iZ3rx3Bs-1669232742912)(F:/BigData/java/java笔记/assets/image-20210503105930618.png)]

  • 案例2 - 两个数组的操作案例

    /**
 * Author itcast
 * Date 2021/5/3 14:43
 * Desc TODO
 */
public class ArrayDemo05 {
    public static void main(String[] args) {
        //1.定义一个长度为3的int类型的数组.
        int[] arr = new int[3];
        //2.修改数组中的第一个元素为: 11
        arr[0]=11;
        //3.打印数组中的第一, 第二个元素.
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        //4.打印数组对象.
        System.out.println(arr);
        //5.定义一个int类型的数组, 存储元素1, 2.
        int[] arr1 = {1,2};
        //6.修改数组的第二个元素值为: 22.
        arr1[1]=22;
        //7.打印数组的第二个元素.
        System.out.println(arr1[1]);
        //8.打印arr1数组对象.
        System.out.println(arr1);
        int sum = sum(1, 2);
        System.out.println(sum);
    }
    public static int sum(int a,int b){
        return a+b;
    }
}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NS0gaUSN-1669232742913)(F:/BigData/java/java笔记/assets/image-20210503150707373.png)]

  • 案例3 - 第二个数组指向第一个数组首地址，修改数组的内容

    public class ArrayDemo06 {
    public static void main(String[] args) {
        //1.定义一个int类型的数组, 存储元素11, 22, 33.
        int[] arr1 = {11, 22, 33};
        //2.打印数组对象.
        System.out.println(arr1);
        //3.打印数组中的各个元素值.
        //Arrays.asList(arr1).stream().forEach(t->System.out::println);
        for (int i = 0; i < arr1.length; i++) {
            int i1 = arr1[i];
            System.out.println(i1);
        }
        //4.定义第二个数组, 把第一个数组的地址值赋值给第二个数组.
        int[] arr2 = arr1;
        //5.通过第二个数组, 修改第二个元素值为200.
        arr2[1] = 200;
        //6.打印数组对象.
        System.out.println(arr2);
        //7.打印数组中的各个元素值.
        for (int i = 0; i < arr2.length; i++) {
            int i1 = arr2[i];
            System.out.println(i1);
        }
    }
}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UDg9QRep-1669232742913)(F:/BigData/java/java笔记/assets/image-20210503151654404.png)]

数组使用中常见的两个小问题

  • 数组索引越界异常(ArrayIndexOutOfBoundsException)

    当前获取的数组的索引不在数组的长度范围之内

    /**
 * Author itcast
 * Date 2021/5/3 11:09
 * Desc TODO
 */
public class ArrayExceptDemo {
    public static void main(String[] args) {
        //1.定义int类型的数组, 存储元素11, 22.
        int[] arr = {11, 22};
        //2.打印数组中的第2个元素.
        System.out.println(arr[1]);
        //3.尝试打印数组中的第3个元素.
        System.out.println(arr[2]);
    }
}

  • 空指针异常(NullPointerException)

    当前数组并没有赋值，开辟堆的存储空间，调用数组的值，报空指针异常

    /**
 * Author itcast
 * Date 2021/5/3 11:11
 * Desc TODO
 */
public class ArrayExceptDemo02 {
    public static void main(String[] args) {
        //1.定义int类型的数组, 存储元素11, 22.
        int[] arr = {11, 22};
        //2.将null(空常量)赋值给数组.
        arr = null;
        //3.尝试打印数组的第一个元素.
        System.out.println(arr[0]);
    }
}

数组的常见操作

  • 遍历数组
  • 获取数组中最大/最小值
  • 翻转数组
  • 对数组排序
  • 填充数组的内容
  • 将数组转换成其他的类型，比如List，字符串等

遍历数组

  • 定义int类型的数组arr, 存储元素11, 22, 33, 44, 55.

    通过for循环, 遍历数组.

    public class ArrayDemo07 {
    public static void main(String[] args) {
        //1.定义int类型的数组arr, 存储元素11, 22, 33, 44, 55.
        int[] arr = {11, 22, 33, 44, 55};
        //2.通过for循环, 遍历数组.
        //2.1 增强 for 循环  //快捷键： foreach || iter || fori
        for (int i : arr) {
            System.out.println(i);
        }
        //2.2 使用 for 固定大小遍历 //快捷键 itar
        for (int i = 0; i < arr.length; i++) {
            int i1 = arr[i];
            System.out.println(i1);
        }
    }
}

  • 已知各位美女的颜值如下图, 请求出下图中, 颜值最高的数字, 并打印到控制台上.

    /**
 * Author itcast
 * Date 2021/5/3 15:29
 * Desc TODO
 */
public class ArrayDemo08 {
    public static void main(String[] args) {
        //求出当前颜值最高的数字
        int[] arr = {5, 15, 2000, 10000, 100, 4000};
        //设置变量用于接收当前最大值的变量
        int tmp = arr[0];
        //遍历数组，比较最大值
        /*for (int i = 0; i < arr.length; i++) {
            int i1 = arr[i];
            if (i1 > tmp) {
                tmp = i1;
            }
        }*/
        //先排序，取第一个或者最后一个
        //冒泡排序，快速排序，堆排序，归并排序
        Arrays.sort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("当前颜值最高的值： " + arr[arr.length - 1]);
    }
}
    • 通过将每个值都和数组中的第一个值进行比较，最大的放到第一个位置 （大堆排序）
    • 先排序，取第一个或者最后一个

  • 案例3 - 翻转数组元素

    /**
 * Author itcast
 * Date 2021/5/3 16:13
 *  11, 33, 22, 55, 44.
 */
public class ArrayDemo09 {
    public static void main(String[] args) {
        //1.定义int类型的数组, 存储数据: 11, 33, 22, 55, 44.
        int[] arr = {11, 33, 22, 55, 44, 66};
        //2.反转数组, 并打印反转后的结果.
        for (int i = 0; i <= (arr.length - 1)/2; i++) {
            int temp = 0;
            temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
        //2.1 将 i -> length - 1 - i
        //2.2 交换了 length - 1 / 2
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

  • 对数组排序

    Arrays.sort(arr);

  • 填充数组的内容

    Arrays.fill(arr,2,3,200);
        for (int i = 0; i < arr.length; i++) {
            int i1 = arr[i];
            System.out.println(i1);
        }

  • 将数组转换成其他的类型，比如List，字符串等

    # 转换成 字符串 
    Arrays.toString(arr);
# 转换成 列表
    Arrays.asList(arr);

方法

概述

方法值的就是把一些具有独立功能的代码块整合成一个整体，使其成为一个具有特殊功能的代码集。
把Scanner，if，for，输出语句，数组 -> 求数组元素最大值。
  • 格式
修饰符 返回值的数据类型 方法名(数据类型 形参1, 数据类型 形参2) {
        //具体的业务代码,  就是以前你写的: 变量, 常量, if, for, switch, 输出语句, 运算符...
        return 具体的返回值;
}

  • 格式解释:

    • **修饰符：**固定格式, 目前先写 public static
      **返回值的数据类型：**表示方法执行完毕后, 需要返回一个什么类型的结果, 如果方法无任何返回值, 则返回值的数据类型要写成: void
      **方法名：**遵循 小驼峰 命名法, 最好做到 见名知意.
      **参数列表：**表示调用方法的时候, 需要给方法传入什么类型的值, 例如: int a, int b
      **具体的业务代码：**就是以前你写的: 变量, 常量, if, for, switch, 输出语句, 运算符…
      **return 具体的返回值：**就是方法执行结束后, 返回的 具体的 结果.

  • 注意事项:

1. 方法与方法之间是平级关系, 不能嵌套定义.
2. 方法只有被调用才会执行.
3. 方法在调用之前, 必须先定义, 这个动作称为: 定义方法.
4. 定义方法的时候, 写到参数列表中的内容叫: 形式参数(简称: 形参), 形容调用方法,需要传入什么类型的值.
5. 调用方法的时候, 传入的值叫: 实际参数(简称: 实参), 即: 实际参与运算的数据.
6. 方法的功能越单一越好.
7. 方法如果没有具体的返回值, 则返回值的数据类型必须写成 void

使用方法的核心6步:

定义方法时的三个明确:
1. 明确方法名, 做到见名知意.
2. 明确参数列表, 即: 调用方法, 需要传入什么类型的值.
3. 明确返回值的数据类型, 即: 方法执行结束后, 返回一个具体的什么类型的结果.
调用方法的三个步骤:
1. 写 方法名();
2. 传参, 方法要什么类型的参数, 我们就传入什么类型的值.
3. 接收返回值. 方法返回什么类型的结果, 我们就用对应类型的变量来接收.

案例：

public class Demo01 {
    public static void main(String[] args) {
        //调用方法
        int sum = getSum(10, 20);   //实参
        System.out.println(sum);
        return;     //return的主职: 就是用来结束方法的.
    }

    //定义方法
    public static int getSum(int a, int b) {    //形参
        int sum = a + b;
        return sum; //return的兼职: 可以返回方法的执行结果(如果有), 在哪里调用, 就返回到哪里.
    }
}

无参无返回值

public class Demo02 {
    public static void main(String[] args) {
        printHello();
    }
    public static void printHello(){
        System.out.println("hello world");
    }
}

有参无返回值

 //案例: 演示有参无返回值的方法.
/*
    方法的定义格式:
        修饰符 返回值的数据类型 方法名(数据类型 参数名1, 数据类型 参数名2...) {
            方法体;        //就是以前我们一直写的 逻辑代码
            return 具体的返回值;
        }
    示例:
        public static void main(String[] args) {
        }
    注意事项:
        1. 方法与方法之间是平级关系, 不能嵌套定义.
        2. 方法的功能越单一越好.
        3. 方法只有被调用才会执行.
        4. 定义方法的时候写在参数列表中的参数叫: 形参.
           调用方法的时候传入的具体值, 叫: 实参.
 */
public class MethodDemo02 {
    public static void main(String[] args) {
        //1.定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
        //2.判断num是奇数还是偶数, 并打印结果.
        /*
            调用方法的三个步骤:
                1. 写方法名. 用谁就写谁, 注意大小写, 不要写错了.
                2. 传参, 方法要什么, 我们就给什么.
                3. 接收返回值, 即: 方法给什么, 我们就用什么类型的变量来接收.
         */
        isEvenNumber(13);
    }

    //1.定义方法isEvenNumber(), 该方法接收一个int类型的整数num.,    方法与方法之间是平级关系, 不能嵌套定义.
    /*
        分析: 定义方法的三个明确
            1. 明确方法名.
            2. 明确参数列表.
            3. 明确返回值的数据类型.
     */
    public static void isEvenNumber(int num) {      //参数列表, 形容调用方法的时候需要传入什么类型的数据.
        //即: 判断传过来的num是奇数还是偶数, 并将结果打印到控制台上.
        if (num % 2 == 0)
            System.out.println(num + " 是偶数");
        else
            System.out.println(num + " 是奇数");
    }
}

无参有返回值

  • 案例1:
//案例: 演示无参有返回值的方法, 案例一: 求和.
public class MethodDemo03 {
    public static void main(String[] args) {
        //3.在main方法中调用getSum()方法, 并打印结果.
        /*
            调用方法的3个步骤:
                1. 写方法名. 用谁就写谁, 注意大小写, 不要写错了.
                2. 传参, 方法要什么, 我们就给什么.
                3. 接收返回值, 即: 方法给什么, 我们就用什么类型的变量来接收.
         */

        //调用方法的方式1: 直接调用, 无意义, 一般不用.
        //getSum();

        //调用方法的方式2: 输出调用, 比较简单, 一般上课都用这种.
        //System.out.println(getSum());;               //getSum()  -> 30

        //调用方法的方式3:  赋值调用.
        int sum = getSum();
        //打印求和结果
        System.out.println(sum);
    }

    //1.定义方法getSum(), 该方法内部有两个int类型的整数.
    /*
        定义方法的三个明确:
            1. 明确方法名.                           getSum()
            2. 明确参数列表.                         空
            3. 明确返回值的数据类型.                 int
     */
    public static int getSum() {
        //1.1 该方法内部有两个int类型的整数.
        int a = 10;
        int b = 20;

        //2.获取上述两个整数的和, 并返回.
        //分解版
        /*//1.2 求和
        int sum = a + b;
        //1.3 返回结果.
        return sum;*/

        //合并版.
        return a + b;
    }
}
  • 案例2：
package com.itheima.demo03_method;

//案例: 演示无参有返回值的方法, 案例二: 判断奇偶数.
public class MethodDemo04 {
    public static void main(String[] args) {
        //3.在main方法中调用isEvenNumber()方法, 并打印结果.
        //调用方式1: 直接调用, 了解.
        //isEvenNumber();

        //调用方式2: 输出调用, 课堂用.
        //System.out.println(isEvenNumber());;

        //调用方式3: 赋值调用, 实际开发用.
        boolean flag = isEvenNumber();
        System.out.println(flag);
    }


    //1.定义方法isEvenNumber(), 该方法内部有一个整数num.
    /*
          定义方法的三个明确:
            1. 明确方法名.                           isEvenNumber()
            2. 明确参数列表.                         空
            3. 明确返回值的数据类型.                 boolean
     */
    public static boolean isEvenNumber() {
        //1. 该方法内部有一个整数num.
        int num = 26;
        //2.判断num是奇数还是偶数, 并返回结果.
        if (num % 2 == 0)
            return true;            //true: 偶数,   false: 奇数
        else
            return false;
    }
}

有参有返回值

  • 求和案例
package com.itheima.demo03_method;

//案例: 演示有参有返回值的方法, 求和案例.
/*
    方法的完整的定义格式:
        public static 返回值的数据类型 方法名(数据类型 参数名1, 数据类型 参数名2) {
            方法体;
            return 具体的返回值;
        }
 */
public class MethodDemo05 {
    public static void main(String[] args) {
        System.out.println("start");
        //3.在main方法中调用getSum()方法, 并打印结果.
        /*
            调用方法的三个步骤:
                1. 写方法名. 用谁就写谁, 注意大小写, 不要写错了.
                2. 传参, 方法要什么, 我们就给什么.
                3. 接收返回值, 即: 方法给什么, 我们就用什么类型的变量来接收.
         */
        int sum = getSum(10, 21);
        System.out.println("sum: " + sum);
        System.out.println("end");
    }

    //1.定义方法getSum(), 接收两个int类型的整数.
    /*
         定义方法的三个明确:
            1. 明确方法名.                           getSum()
            2. 明确参数列表.                         int a, int b         形式参数
            3. 明确返回值的数据类型.                 int
     */
    public static int getSum(int a, int b) {        //int a = 10, int b = 21
        //2.获取上述两个整数的和, 并返回.
        /*int sum = a + b;
        return sum;*/
        return a + b;
    }
}
  • 判断奇偶数案例
package com.itheima.demo03_method;

//案例: 演示有参有返回值的案例, 判断奇偶数.
public class MethodDemo06 {
    public static void main(String[] args) {
        //3.在main方法中调用isEvenNumber()方法, 并打印结果.
        /*
            调用方法的三个步骤:
                1. 写方法名. 用谁就写谁, 注意大小写, 不要写错了.
                2. 传参, 方法要什么, 我们就给什么.
                3. 接收返回值, 即: 方法给什么, 我们就用什么类型的变量来接收.
         */
        boolean flag = isEvenNumber(22);
        System.out.println(flag);

    }//main方法的大括号


    //1.定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
     /*
         定义方法的三个明确:
            1. 明确方法名.                           isEvenNumber()
            2. 明确参数列表.                         int num            形式参数
            3. 明确返回值的数据类型.                 boolean
     */
    public static boolean isEvenNumber(int num) {
        //2.判断num是奇数还是偶数, 并返回结果.
        //分解版
        //boolean flag = num % 2 == 0 ? true : false;
        /*boolean flag = num % 2 == 0;
        return flag;*/

        //合并版
        return num % 2 == 0;
    }


}//类的大括号
  • 求最大值
package com.itheima.demo03_method;

//案例: 演示有参有返回值的方法, 求最大值.

public class MethodDemo07 {
    public static void main(String[] args) {
        //3.在main方法中调用getMax()方法, 获取最大值并打印.
        int max = getMax(11, 22);
        System.out.println("最大值是: " + max);
        //return;       如果方法没有明确的返回值, 则return可以省略, 对结果没有影响.
    }

    //1.定义方法getMax(), 该方法接收两个整数.
    //参数列表: int a, int b,    返回值类型: int
    public static int getMax(int a, int b) {
        //2.通过该方法, 获取两个整数的最大值, 并返回.
        return a > b ? a : b;
    }
}
关于方法的思考题:
1.方法与方法之间可以嵌套定义吗?
不可以, 因为方法与方法之间是平级关系, 不能嵌套定义.

2.方法没有具体的返回值时, 返回值的数据类型可以不写吗?
不可以, 如果方法没有明确的返回值, 则返回值的数据类型必须写成: void

3.方法体中的`return关键字可以省略吗?
看需求,
如果方法没有明确的返回值, 则return可以省略, 对结果没有影响.
如果方法有明确的返回值, 则return不能省略.

小细节:
					  主职                  兼职
//return的主要作用是用来 结束方法的, 捎带着可以 返回值.

方法重载

  • 方法重载概述
1. 同一个类中出现,
2. 方法名相同,
3. 但是参数列表不同的    //参数列表不同分为两种情况: 1. 参数个数不同. 2. 对应的数据类型不同.
4. 两个或者以上的方法时, 称为方法重载.也叫: Overload.
5. 方法重载和方法的返回值的数据类型无关.
    
作用（目的）：
    方法重载就是用来解决: 功能相似, 但是方法名不能重名的问题的.
  • 应用场景:
实际开发中, 我们发现某些方法的功能是类似的, 每个方法都单独设置一个名字是非常麻烦的, 也不方便记忆.
针对于这种情况,我们可以采用 方法重载来解决, 只要保证: 方法名相同, 参数列表不同即可.
这样当我们调用该方法时, 会根据传入的参数, 来调用对应的方法.
  • 案例：演示方法重载入门, 不使用方法重载版本
package com.itheima.demo05_overload;


//案例: 演示方法重载入门,   不使用方法重载版本, 了解即可.
public class MethodDemo01 {
    public static void main(String[] args) {
        System.out.println(compareInt(10, 20));
    }

    //1.定义方法compare(), 用来比较两个整型数据是否相等.
    //2.要求兼容所有的整数类型, 即(byte, short, int, long)

    //1.1 定义方法, 用来比较两个byte数据是否相等.
    public static boolean compareByte(byte b1, byte b2) {
        return b1 == b2;
    }

    public static boolean compareByteAndInt(byte b1, int b2) {
        return b1 == b2;
    }

    //1.2 定义方法, 用来比较两个short数据是否相等.
    public static boolean compareShort(short s1, short s2) {
        return s1 == s2;
    }
    //1.3 定义方法, 用来比较两个int数据是否相等.
    public static boolean compareInt(int s1, int s2) {
        return s1 == s2;
    }
    //1.4 定义方法, 用来比较两个long数据是否相等.
    public static boolean compareLong(long s1, long s2) {
        return s1 == s2;
    }
}
  • 案例: 演示方法重载入门, 使用方法重载版本
package com.itheima.demo05_overload;

//案例: 演示方法重载入门, 使用方法重载版本
/*
    方法重载概述:
        1. 同一个类中出现,
        2. 方法名相同,
        3. 但是参数列表不同的            //参数列表不同分为两种情况: 1. 参数个数不同. 2. 对应的数据类型不同.
        4. 两个或者以上的方法时, 称为方法重载.
        5. 方法重载和方法的返回值的数据类型无关.

    应用场景:
        实际开发中, 我们发现某些方法的功能是类似的, 每个方法都单独设置一个名字是非常麻烦的, 也不方便记忆.
        针对于这种情况,我们可以采用 方法重载来解决, 只要保证: 方法名相同, 参数列表不同即可.
        这样当我们调用该方法时, 会根据传入的参数, 来调用对应的方法.
 */
public class MethodDemo02 {
    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
        System.out.println(compare(b1, b2));

    }

    //1.定义方法compare(), 用来比较两个整型数据是否相等.
    //2.要求兼容所有的整数类型, 即(byte, short, int, long)

    //1.1 定义方法, 用来比较两个byte数据是否相等.
    public static boolean compare(byte b1, byte b2) {
        System.out.println("byte");
        return b1 == b2;
    }
    //1.2 定义方法, 用来比较两个short数据是否相等.
    public static boolean compare(short s1, short s2) {
        System.out.println("short");
        return s1 == s2;
    }
    //1.3 定义方法, 用来比较两个int数据是否相等.
    public static boolean compare(int s1, int s2) {
        System.out.println("int");
        return s1 == s2;
    }
    //1.4 定义方法, 用来比较两个long数据是否相等.
    public static boolean compare(long s1, long s2) {
        System.out.println("long");
        return s1 == s2;
    }


    //方法重载的思考题
    public static void open(){}
    public static void open(int a){}
    public static void open(double a,int b){}
    //public static void open(int a,double b){}   //冲突1
    public void open(int i,double d){}			//冲突1


    static void open(int a,int b){}			//冲突2
    //public static void open(int i,int j){}	//冲突2

    public static void OPEN(){}
}

方法的参数传递

形参是基本类型：
  • 基本类型作为参数时, 形参的改变对实参没有任何影响
package com.itheima.demo05_overload;

//演示: 方法的参数传递问题之:  形参是基本类型.
//记忆: 基本类型作为参数时, 形参的改变对实参没有任何影响.
public class MethodDemo03 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);        //100
        change(number);	 //实参.
        System.out.println("调用change方法后：" + number);        //100
    }

    public static void change(int number) {	//形参.           //number = 100;
        number = 200;
    }
}
形参是引用类型
  • 引用类型作为参数时, 形参的改变直接影响实参
  • (String类型除外, String类型当做形参使用时, 用法和基本类型一致, 后续API部分详解)
package com.itheima.demo05_overload;

//演示: 方法的参数传递问题之:  形参是引用类型.
//记忆: 引用类型作为参数时, 形参的改变直接影响实参(String类型除外, String类型当做形参使用时, 用法和基本类型一致, 后续API部分详解)
public class MethodDemo04 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};       //0x001
        System.out.println("调用change方法前：" + arr[1]);        //20
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);        //200
    }

    public static void change(int[] arr) {  //0x001,  10, 20, 30
        arr[1] = 200;            //10, 200, 30
    }
}
  • 打印数组
package com.itheima.demo05_overload;

//案例: 打印数组, (伪)标准版.
public class MethodDemo05 {
    public static void main(String[] args) {
        //调用方法.
        int[] arr = {11, 22, 33, 44, 55};
        //printArray(arr);
        printArray2(arr);
        //System.out.println("我在哪? ");
    }

    //1.定义方法printArray(), 该方法用来打印数组.
    //2.打印格式为: [11, 22, 33, 44, 55]
   public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            //arr[i]: 就是数组中的每一个元素, 例如: 11, 22, 33, 44, 55

            //判断当前是否是数组的最后一个元素, 如果是, 就拼接: ]  + 换行
            if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                //说明不是最后一个元素, 拼接:  ,
                System.out.print(arr[i] + ", ");
            }
        }
    }



    public static void printArray2(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++)
            //arr[i]: 就是数组中的每一个元素, 例如: 11, 22, 33, 44, 55
            //判断当前是否是数组的最后一个元素, 如果是, 就拼接: ]  + 换行
            System.out.print(arr[i] + (i == arr.length - 1 ? "]\r\n" : ", "));
    }
}

Debug断点调试

  • 名词解释：Bug
    • 指的是项目中出现的所有非正常的情况（软件，硬件都包含），统称为：Bug
  • 概述：
    • 可以帮助我们对程序进行调错，也可以帮助我们快速梳理项目的业务模板。
package com.itheima.demo06_debug;

//案例: 演示Debug断点调试
/*
    步骤:
        1. 加断点, 哪里不会点哪里.
        2. 运行加了断点的程序, 注意: 不要选择run, 要选择debug(就是小蜘蛛)
        3. 开始调试后, 看哪里呢?
            Debugger:   看代码执行到哪里了.
            Console:    控制台, 就是查看程序运行结果的.
            Variable:   就是查看 变量的变化过程的.
        4. 如何进行下一步?
            F7: 逐过程调试
            F8: 逐行调试
            F9: 逐断点调试
        5. 如何删除断点?
            方式1: 一个一个删除.
            方式2: 批量删除.      //选择breakpoints(双红点), 移除断点即可.
 */
public class Dem14 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int sum = getSum(a,b);
        System.out.println(sum);
    }

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

        System.out.print(arr[i] + (i == arr.length - 1 ? "]\r\n" : ", "));
}

}


### Debug断点调试

* 名词解释：Bug
  * 指的是项目中出现的所有非正常的情况（软件，硬件都包含），统称为：Bug
* 概述：
  * 可以帮助我们对程序进行调错，也可以帮助我们快速梳理项目的业务模板。

~~~java
package com.itheima.demo06_debug;

//案例: 演示Debug断点调试
/*
    步骤:
        1. 加断点, 哪里不会点哪里.
        2. 运行加了断点的程序, 注意: 不要选择run, 要选择debug(就是小蜘蛛)
        3. 开始调试后, 看哪里呢?
            Debugger:   看代码执行到哪里了.
            Console:    控制台, 就是查看程序运行结果的.
            Variable:   就是查看 变量的变化过程的.
        4. 如何进行下一步?
            F7: 逐过程调试
            F8: 逐行调试
            F9: 逐断点调试
        5. 如何删除断点?
            方式1: 一个一个删除.
            方式2: 批量删除.      //选择breakpoints(双红点), 移除断点即可.
 */
public class Dem14 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int sum = getSum(a,b);
        System.out.println(sum);
    }

    public static int getSum(int a, int b) {
        int sum = a + b;
        return sum;
    }
}
Sql_Boy_A_Liang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Excel-VBA-数组-02-数组遍历
Z的博客
05-30 7466
微信公众号原文 系统：Windows 7 软件：Excel 2016 本系列讲讲数组功能 今天说说如何获取数组的每一个元素 Part 1：实现内容 依然针对1维和2维数组进行讲解 示例结构如下 数组1：1维数组，包含3个元素 数组2：2维数组，包含6个元素 目标在于打印输出数组中的每一个元素，下文提供了两种方法 For Each... For i = 0 to ... 数组1 数组2 Part 2： 方法1-For Each Sub test1() arr1 = Arra
力扣初级算法-02-数组-旋转数组
nvluco的博客
11-02 155
学习目标： 本次学习目标为 力扣初级算法-数组，其中主要的LC如下： 旋转数组 存在重复元素 学习内容： 旋转数组 （链接） 给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。 进阶： 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。 你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？ 示例1： 输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4] 解释: 向右旋转 1 步: [7,1,2,
数据结构Java实现02--数组、链表和动态数组
一个软件开发者的成长记录
07-01 887
数组 链表 动态数组
java-数组和方法
weixin_50206068的博客
06-01 687
Java中的数组和方法是编程中的基本概念。数组用于存储相同数据类型的多个元素，可以静态或动态初始化和调整大小。方法是可重复使用的代码块，接受输入参数并返回值，可用于在数组上执行特定任务，如排序、搜索、插入和删除元素。了解数组和方法对于在Java编程中进行有效的数据管理和操作至关重要。
02-数组(Array)应用分析
雨田说码
10-28 1172
数组是一个有限的、类型相同的数据的集合，在内存中是一段连续的内存区域，这段内存区域一旦定义，其大小不改变。数组的长度在定义时确定，数组中的元素的默认值由其数组类型决定。可通过数组下标访问数组中元素，下标的起始位置永远从0开始。
js--数组方法
weixin_33875564的博客
11-13 41
01、concat（）---合并数组的方法02、join（separator）--把数组的所有元素放入一个字符串。元素通过指定的分隔符separator进行分隔。03、shift（）---删除数组第一个元素04、pop（）---删除数组最后一个元素05、unshift（）---在数组开头追加元素06、push（）---在数组末尾追加元素07、reverse（）---翻转数组元素08、sort（）-...
C++学习笔记02--数组\字符串
weixin_51114234的博客
05-05 1100
数组与字符串详解
Java基础--数组练习2
人生得意须尽欢
07-25 619
Java基础之数组练习第二弹！！！
算法7--数组--02
weixin_69239230的博客
01-08 403
方法一：排序，对数组排序，如果存在重复元素，则数组相邻元素一定相等。217--存在重复元素。
C语言---数组
qq_62743629的博客
04-23 1174
基本概念 一组具有相同数据类型的元素的集合 元素:组成数组的基本单位 注意:同一个数组中只能存储同一种数据类型的元素 定义 int a; // 变量本身的类型 变量名; // 数组本身的类型 数组名; // 数组本身的类型 ==> 数组元素的类型 [数组的长度] // 数组元素的类型 数组名 [数组的长度]; int Card[10]; // 定义了一个数组,取名叫做Card // 数组元素的类型:int 数组长度:10 // 数组本身的类型:int [10] // 数组
JavaSE进阶-02-数组.pdf
09-10
- Java提供了一个`Arrays`类，其中包含多种操作数组的方法，如`sort()`、`equals()`、`fill()`和`deepEquals()`等，方便对数组进行操作。 通过深入理解和熟练运用这些概念，开发者能够有效地管理和操作数据，实现...
goit-js-hw-02:数组，数组方法，函数
03-16
在“goit-js-hw-02”作业中，我们将深入探讨数组以及与之相关的数组方法和函数。 首先，让我们了解数组的基本概念。在JavaScript中，数组可以由不同类型的值（如数字、字符串甚至其他对象）组成，并通过索引来访问...
02-Java基础(数组-常见操作-遍历
04-28
本教程“02-Java基础(数组-常见操作-遍历)”将深入讲解Java数组的概念、创建、初始化以及如何进行遍历等核心知识点。 首先，数组是存储同一类型元素的固定大小的集合。在Java中，数组的声明语法如下： ```java 数据...
2020老杜最新Java零基础进阶视频教程-数组课件
12-10
- **示例**: 在`ArrayTest02`中，声明了一个`Student`类型的数组，但尝试访问未初始化的数组元素会引发`NullPointerException`。 ### 3. 数组的操作 - **排序**: 数组可以进行排序操作，Java提供了多种排序算法，如...
《物联网C#程序开发案例式教程》教学课件-第五章-数组与集合02 c#经典案例.pptx
05-07
`foreach`循环则提供了一种更简洁的遍历数组的方法，它自动处理索引，程序员无需关心下标的细节。例如： ```csharp foreach (数据类型 变量名 in 数组名) { 语句 } ``` 使用`foreach`时，可以直接访问数组中...
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 319
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 476
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 262
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 225
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
jmu-java-02基本语法-04-动态数组
06-28
动态数组是一种可以根据需要动态增加或减少大小的数组。...ArrayList类提供了一些方法来添加、删除、获取和修改元素。与普通数组不同的是，ArrayList可以自动调整大小，因此不需要手动管理数组大小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值