数组&方法

1. 数组简介

1.1 概述

我们之前学习的变量或者是常量, 只能用来存储一个数据, 例如: 存储一个整数, 小数或者字符串等. 如果需要同时存储多个同类型的数据, 用变量或者常量来实现的话, 非常的繁琐. 针对于这种情况, 我们就可以通过数组来实现了.

例如: 假设某公司有50名员工, 现在需要统计该公司员工的工资情况, 例如计算平均工资、获取最高工资等。针对于这个需求，如果用前面所学的知识实现，程序首先需要声明50个变量来分别记住每位员工的工资，然后在进行操作，这样做非常繁琐，而且错误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一操作。数组, 就是一种容器.

解释:

容器: 就是将多个数据存储到一起, 每个数据都是该容器的元素.

现实生活中的容器: 水杯, 衣柜, 教室等...

数组概述

数组就是用来存储多个同类型元素的容器, 例如: 存储5个整数, 或者存储10个小数, 亦或者存储3个字符串等...

1.2 格式

• 动态初始化: 我们给定长度, 由系统给出默认初始化值.

 //格式一
数据类型[] 数组名 = new 数据类型[长度];

//格式二
数据类型 数组名[] = new 数据类型[长度];

 解释: 上述两种定义方式只是写法不同, 并无其他区别.

• 静态初始化: 我们给定初始化值, 由系统指定长度.

 //格式一
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3}; //这里可以有多个元素.

//格式二 语法糖.
数据类型[] 数组名 = {元素1, 元素2, 元素3};

 解释: 上述两种定义方式只是写法不同, 并无其他区别.

 

1.3 示例: 定义数组

需求

创建int类型的数组, 用来存储3个元素.

创建int类型的数组, 存储数据11, 22, 33.

参考代码

public class ArrayDemo01 {
    public static void main(String[] args) {
        //1. 创建int类型的数组, 用来存储3个元素.
        //我们制定长度, 由系统给出默认值.
        //格式一:
        int[] arr1 = new int[3]; //推荐.
        //格式二:
        int arr2[] = new int[3];

        //2. 创建int类型的数组, 存储数据`11, 22, 33`.
        //我们直接传入元素, 由系统指定长度.
        //格式1
        int[] arr3 = new int[]{11, 22, 33};
        //格式2
        int[] arr4 = {11, 22, 33}; //推荐.
    }
}

 

1.4 数组各部分解释

此处以动态初始化举例:

数据类型[] 数组名 = new 数据类型[长度];

//例如:
int[] arr = new int[3];  

解释:

• 数据类型: 指的是数组中存储元素的数据类型

 例如: 如果是int, 说明数组中只能存储int类型的数据, 如果是String, 则说明数组中只能存储字符串.

• []: 表示是一个数组.
• 数组名: 类似于之前定义的变量名, 要符合命名规范, 我们可以通过数组名来操作数组.
• new: 它是一个关键字, 表示用来创建数组对象的.

 

1.5 数组的特点及基本用法

1.5.1 特点

数组中的每个元素都是有编号的, 且编号是从0开始的. 可以方便我们快速操作数组中的元素.

 解释: 编号也叫索引(这个是最常见的念法), 下标, 角标.   index

数组中每个元素都有默认值.

 例如:

int类型数组, 元素默认值是: 0

double类型的数组, 元素默认值是: 0.0

boolean类型的数组, 元素默认值是: false

String类型的数组, 元素默认值是: null

 

1.5.2 基本用法

通过数组名[索引]的形式, 可以快速获取数组中的指定元素.

 //格式
数组名[索引]

//例如:
int[] arr = {11, 22, 33};
System.out.println(arr[0]); //打印结果是: 11

通过数组名[索引] = 值;的方式, 可以修改数组中的指定元素值.

 //格式
数组名[索引] = 值;

//例如:
int[] arr = {11, 22, 33};
System.out.println(arr[1]); //打印结果是: 22
arr[1] = 222;
System.out.println(arr[1]); //打印结果是: 222

通过数组名.length的方式, 可以获取数组的长度.

 //格式
数组名.length

//例如:
int[] arr = {11, 22, 33};
System.out.println(arr.length); //打印结果是: 3

1.5.3 示例: 数组的基本用法

需求

定义一个长度为5的int类型的数组.

打印数组中的第3个元素.

设置数组中的第一个元素值为11.

获取数组中的第一个元素值, 并将其赋值给变量a, 然后打印.

打印数组的长度.

参考代码

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

 

2. 数组的内存图

2.1 内存解释

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

即: Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

JVM的内存划分

栈: 存储局部变量以及所有代码执行的.

 局部变量: 指的是定义在方法中, 或者方法声明上的变量.

 特点: 先进后出.

堆: 存储所有new出来的内容(即: 对象).

 特点: 堆中的内容会在不确定的时间, 被GC回收.

方法区: 存储字节码文件的.

 字节码文件: 指的是后缀名为.class的文件.

本地方法区:

 和系统相关, 了解即可.存储本地方法

寄存器

 和CPU相关, 了解即可.

 

2.2 案例一: 一个数组内存图

查看如下代码:

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[0]); //打印数组中的第一个元素, 值为: 0
        System.out.println(arr);    //[I@1540e19d
    }
}

其中[I@1540e19d是arr数组的地址值, 那这段代码在内存中的执行流程是怎样的呢? 我们一块儿来看下:

图解 

2.3 案例二: 两个数组内存图

需求

定义一个长度为3的int类型的数组.

修改数组中的第一个元素为: 11

打印数组中的第一, 第二个元素.

打印数组对象.

定义一个int类型的数组, 存储元素1, 2.

修改数组的第二个元素值为: 22.

打印数组的第二个元素.

打印数组对象.

参考代码

public class ArrayDemo04 {
    public static void main(String[] args) {
        //1. 定义一个长度为3的int类型的数组.
        int[] arr1 = new int[3];
        //2. 修改数组中的第一个元素为: 11
        arr1[0] = 11;
        //3. 打印数组中的第一, 第二个元素.
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        //4. 打印数组对象.
        System.out.println(arr1);
        //5. 定义一个int类型的数组, 存储元素1, 2.
        int[] arr2 = {1, 2};
        //6. 修改数组的第二个元素值为: 22.
        arr2[1] = 22;
        //7. 打印数组的第二个元素.
        System.out.println(arr2[1]);
        //8. 打印数组对象.
        System.out.println(arr2);
    }
}

上述代码的内存图解又是怎样的呢? 我们一块儿来看下:

图解 

2.4 案例三: 两个数组指向同一个对象

需求

定义一个int类型的数组, 存储元素11, 22, 33.

打印数组对象.

打印数组中的各个元素值.

定义第二个数组, 把第一个数组的地址值赋值给第二个数组.

通过第二个数组, 修改第二个元素值为200.

打印数组对象.

打印数组中的各个元素值.

参考代码.

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

上述代码的内存图解又是怎样的呢? 我们一块儿来看下:

图解 

3. 两个小问题

数组是我们在实际开发中用到的比较多的容器, 在使用它的时候, 很可能会遇到如下的两个问题:

数组索引越界异常(ArrayIndexOutOfBoundsException)

空指针异常(NullPointerException)

3.1 数组索引越界异常

产生原因 访问了数组中不存在的索引.

解决方案

访问数组中存在的索引即可.

示例

定义int类型的数组, 存储元素11, 22.

打印数组中的第2个元素.

尝试打印数组中的第3个元素.

参考代码

public class ArrayDemo06 {
    public static void main(String[] args) {
        //1. 定义int类型的数组, 存储元素11, 22.
        int[] arr = {11, 22};
        //2. 打印数组中的第2个元素.
        System.out.println("arr[1]: " + arr[1]);
        //3. 尝试打印数组中的第3个元素.
        System.out.println("arr[2]: " + arr[2]);
    }
}

 

3.2 空指针异常

产生原因

访问了空对象. 即: 对象为空, 你还去调用它的一些方法, 肯定不行.

解决方案

对对象赋具体的值即可.

示例

定义int类型的数组, 存储元素11, 22.

将null(空常量)赋值给数组.

尝试打印数组的第一个元素.

参考代码

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

 

4. 数组的常见操作

数组是我们在实际开发中用到的比较多的一种容器, 它的常见操作如下:

遍历数组.

获取数组的最值(最大值, 或者最小值).

反转数组.

 

4.1 案例一: 遍历数组

需求

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

通过for循环, 遍历数组.

参考代码

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1. 定义int类型的数组arr, 存储元素11, 22, 33, 44, 55.
        int[] arr = {11, 22, 33, 44, 55};
        //2. 通过for循环, 遍历数组.
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

 

4.2 案例二: 获取数组的最大值

需求

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

即:求数组int[] arr = {5, 15, 2000, 10000, 100, 4000};的最大值.

 

 

参考代码

public class ArrayDemo09 {
    public static void main(String[] args) {
        //需求: 求数组int[] arr = {5, 15, 2000, 10000, 100, 4000};的最大值.
        int[] arr = {5, 15, 2000, 10000, 100, 4000};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i])
                max = arr[i];
        }
        System.out.println("颜值最高的人的颜值为: " + max);
    }
}

 

4.3 案例三: 反转数组

需求

定义int类型的数组, 存储数据: 11, 33, 22, 55, 44.

反转数组, 并打印反转后的结果.

参考代码

public class ArrayDemo10 {
    public static void main(String[] args) {
        //1. 定义数组.
        int[] arr = {11, 33, 22, 55, 44};
        //2. 反转数组.
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        //3. 打印数组.
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);;
        }
    }
}

 

5. 方法简介

5.1 概述

方法(method)，也叫函数，是将具有独立功能的代码块组织成为一个整体，使其成为具有特殊功能的代码集.

例如: 现实生活中, 拿牙刷, 挤牙膏, 刷上排牙, 刷下排牙, 漱口, 这些单独的动作合起来, 就完成了刷牙的动作.

又例如: 让我们获取元素10和20的最大值, 我们可以通过if语句或者三元运算符实现, 如果再让我们获取22和11之间的最大值, 我们还需要把刚才的逻辑代码在写一次. 这样做很繁琐. 针对于这种情况, 我们就可以把获取两个整数最大值的逻辑代码封装到方法中, 当我们需要比较的时候, 直接调用方法就可以了. 这样做, 非常方便.

5.2 定义格式

修饰符 返回值的数据类型 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数
    //方法体;
    return 具体的返回值; //加工好的饲料
}

public static void main(String[] args) {
   
}

5.3 格式解释

• 修饰符: 目前记住这里是固定格式public static
• 返回值的数据类型: 用于限定返回值的数据类型的.

 注意:

返回值的数据类型是int类型, 则说明该方法只能返回int类型的整数.

如果方法没有具体的返回值, 则返回值的数据类型要用void来修饰.

• 方法名: 方便我们调用方法.
• 参数类型: 用于限定调用方法时传入的数据的数据类型.

 例如: 参数类型是String类型, 说明我们调用方法时, 只能传入字符串.

• 参数名: 用于接收调用方法时传入的数据的变量.
• 方法体: 完成特定功能的代码.
• return 返回值: 用来结束方法的, 并把返回值返回给调用者.

 解释: 如果方法没有明确的返回值, 则return关键字可以省略不写.

5.4 注意事项

方法与方法之间是平级关系, 不能嵌套定义.

方法必须先创建才可以使用, 该过程称为: 方法定义.

方法自身不会直接运行, 而是需要我们手动调用方法后, 它才会执行, 该过程称为方法调用.

方法的功能越单一越好.

定义方法的时候写在参数列表中的参数, 都是: 形参.

 形参: 形容调用方法的时候, 需要传入什么类型的参数.

调用方法的时候, 传入的具体的值(变量或者常量都可以), 叫实参.

 实参: 调用方法时, 实际参与运算的数据.

 

6. 无参无返回值的方法

6.1 定义无参无返回值的方法

定义方法时, 要做到三个明确, 这样定义方法就会变得非常简单了:

明确方法名, 即: 方法名要符合小驼峰命名法, 且要见名知意, 方便我们调用.

明确方法的参数列表. 即: 调用方法时, 我们需要给它(方法)什么数据.

明确方法的返回值类型, 即: 调用方法完毕后, 方法会返回给我们一个什么类型的数据.

具体格式

public static void 方法名() {
    //方法体;
}

 

需求 定义printHello()方法, 用来打印"Hello World!"字符串.

参考代码

public static void printHello() {
    System.out.println("Hello World!);
}

 

6.2 调用无参无返回值的方法

格式

方法名();

解释: 通过方法名();的形式, 可以直接根据方法名调用指定的方法.

 

6.3 方法调用图解

 

 

方法的好处:

可以提高代码的复用性, 方便我们维护程序.

即: 当一些代码被反复使用时，可以把它们提取出来，放到一个方法里，以方法的形式来使用这些代码。

 

7. 有参无返回值的方法

有参无返回值的方法的意思是: 调用方法时, 我们需要传入具体的参数, 但是方法执行完毕后, 并不会给我们返回具体的结果.

具体定义格式

public static void 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数
    //方法体;
}

具体调用格式

方法名(参数值1, 参数值2); //注意: 参数的个数, 以及对应的参数类型都要和定义方法的参数列表保持一致.

需求

定义方法isEvenNumber(), 该方法接收一个int类型的整数num.

判断num是奇数还是偶数, 并打印结果.

参考代码

略.

 

8. 无参有返回值的方法

无参有返回值的方法的意思是: 调用方法时, 我们不需要传入具体的参数, 但是方法执行完毕后, 会给我们返回具体的结果.

具体定义格式

public static 返回值的数据类型 方法名() {
    //方法体;
    return 具体的返回值;
}

具体调用格式

//直接调用, 无意义.
方法名();

//输出调用, 在课堂上我可能会经常用, 因为简单.
System.out.println(方法名());

//赋值调用,  实际开发中推荐使用.
数据类型 变量名 = 方法名();

 

8.1 示例一: 定义求和方法

需求

定义方法getSum(), 该方法内部有两个int类型的整数.

获取上述两个整数的和, 并返回.

在main方法中调用getSum()方法, 并打印结果.

参考代码

略.

图解 略.

8.2 示例二: 判断奇偶数

需求

定义方法isEvenNumber(), 该方法内部有一个整数num.

判断num是奇数还是偶数, 并返回结果.

在main方法中调用isEvenNumber()方法, 并打印结果.

参考代码

略.

 

9. 有参有返回值的方法

有参有返回值的方法的意思是: 调用方法时, 我们不仅需要传入具体的参数, 方法执行完毕后, 还会给我们返回具体的结果.

具体定义格式

下述这个格式就是方法的通用格式.

public static 返回值的数据类型 方法名(参数类型 参数1, 参数类型 参数2) {
    //方法体;
    return 具体的返回值;
}

具体调用格式

//直接调用
方法名(参数值1, 参数值2); //参数的个数, 及对应参数的类型要和定义方法时的参数列表保持一致.

//输出调用
System.out.println(方法名());

//赋值调用
数据类型 变量名 = 方法名();

 

9.1 示例一: 定义求和方法

需求

定义方法getSum(), 接收两个int类型的整数.

获取上述两个整数的和, 并返回.

在main方法中调用getSum()方法, 并打印结果.

参考代码

略.

图解 略.

9.2 示例二: 判断奇偶数

需求

定义方法isEvenNumber(), 该方法接收一个int类型的整数num.

判断num是奇数还是偶数, 并返回结果.

在main方法中调用isEvenNumber()方法, 并打印结果.

参考代码

略.

 

9.3 实例三: 获取最大值

需求

定义方法getMax(), 该方法接收两个整数.

通过该方法, 获取两个整数的最大值, 并返回.

在main方法中调用getMax()方法, 获取最大值并打印.

参考代码

略.

 

9.4 思考题

方法与方法之间可以嵌套定义吗?

方法没有具体的返回值时, 返回值的数据类型可以不写吗?

方法体中的`return关键字可以省略吗?

 

10. 练习

10.1 案例一: 遍历数组

需求

定义方法printArray(), 接收一个int类型的数组.

通过该方法, 实现遍历数组的功能.

在main方法中, 调用方法, 打印指定的数组.

参考代码

 

10.2 案例二: 获取数组最值

需求

定义方法getMax(), 接收一个int类型的数组.

通过该方法, 获取数组元素中的最大值.

在main方法中, 调用方法, 打印对应的结果.

参考代码

 

10.3 案例三: 模拟计算器

需求

定义方法, 接收两个int类型的整数.

分别获取这两个整数的加减乘除的运算结果, 然后返回.

在main方法中调用该方法, 并打印结果.

参考代码

 

 

11. 方法重载

11.1 概述

同一个类中, 出现方法名相同, 但是参数列表不同的两个或以上的方法时称为方法重载. 方法重载与方法的返回值的数据类型无关.

注意: 参数列表不同分为两种情况

参数的个数不同.

对应参数的数据类型不同.

 

11.2 示例代码

• 正确示例

 public class MethodDemo01 {
public static void fn(int a) { //function
     //方法体
    }
    public static int fn(double a) {
     //方法体
    }
}

public class MethodDemo02 {
public static float fn(int a) {
     //方法体
    }
    public static int fn(int a , int b) {
     //方法体
    }
}

• 错误示例

 public class MethodDemo01 {
public static void fn(int a) {
     //方法体
    }
    public static int fn(int a) { //错误原因: 参数列表相同.
     //方法体
    }
}

public class MethodDemo02 {
    public static void fn(int a) {
        //方法体
    }
}
public class MethodDemo03 {
    public static int fn(double a) { //错误原因：这是两个类的两个fn方法
        //方法体
    }
}

 

11.3 案例: 判断数据是否相等

需求

定义方法compare(), 用来比较两个整型数据是否相等.

要求兼容所有的整数类型, 即(byte, short, int, long)

参考代码

public class MethodDemo01 {
    public static void main(String[] args) {
        //定义不同数据类型的变量
        byte a = 10;
        byte b = 20;
        short c = 10;
        short d = 20;
        int e = 10;
        int f = 10;
        long g = 10;
        long h = 20;
        // 调用
        System.out.println(compare(a, b));
        System.out.println(compare(c, d));
        System.out.println(compare(e, f));
        System.out.println(compare(g, h));
    }

    // 两个byte类型的
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    // 两个short类型的
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    // 两个int类型的
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    // 两个long类型的
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

 

11.4 思考题

• 判断下述哪些方法是重载关系.

 public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}

 

12. 参数传递问题

12.1 概述

如果方法有参数列表, 则我们在调用该方法时, 需要传入指定的参数. 例如:

方法有两个整型参数, 则我们在调用方法时就得传入两个int类型的值.

方法有一个double类型的参数, 则我们在调用方法时就得传入一个double类型的值.

方法有一个String类型的参数, 则我们在调用方法时就得传入一个字符串值.

解释:

定义方法时，参数列表中的变量，我们称为形式参数.

调用方法时，传入给方法的数值，我们称为实际参数.

 

12.2 形参是基本类型

观察下述代码, 打印结果是什么呢?

public class MethodDemo02 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        change(number);  //实参.
        System.out.println("调用change方法后：" + number);
    }

    public static void change(int number) { //形参.
        number = 200;
    }
}

记忆: 基本类型作为参数时, 形参的改变对实参没有任何影响.

 

12.3 形参是引用类型

观察下述代码, 打印结果是什么呢?

public class MethodDemo03 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

记忆: 引用类型作为参数时, 形参的改变直接影响实参.

 

12.4 结论

基本类型作为形参时, 传递的是数值, 所以形参的改变对实参没有任何影响.

引用类型作为形参时, 传递的是地址值, 所以形参的改变直接影响实参.

 注意: String类型除外, 它当做形参时, 用法和基本类型一样, 传递的是数值(规定).

 

13. 案例: 遍历数组

需求

定义方法printArray(), 该方法用来打印数组.

打印格式为: [11, 22, 33, 44, 55]

参考代码

public class MethodDemo04 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + (i == arr.length - 1 ? "] " : ", "));
        }
    }
}

 

14. Debug调试

14.1 概述

Debug是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。

Debug调试窗口介绍

略

14.2 示例

需求

定义getSum()方法, 用来获取两个整数和.

在main方法中调用getSum()方法.

参考代码

public class MethodDemo05 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int sum = getSum(a, b);
        System.out.println("sum: " + sum);
    }

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

 

14.3 步骤

加断点. 哪里不会点哪里.

 即: 选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可

运行加了断点的程序, 就可以开始进行Debug调试了.

 即:在代码区域右键, 然后选择Debug开始执行.

开始调试时, 看哪里呢?

– Debugger窗口: 看代码执行到了哪里.

– Console窗口: 看程序执行过程中的结果展示(就是控制台).

– Variables窗口: 看代码执行过程中, 变量的变化.

如何进行下一步呢?

– F7: 逐过程调试.

– F8: 逐行调试.

– F9: 逐断点调试.

如何删除断点?

– 选择要删除的断点，单击鼠标左键即可

– 如果是多个断点，可以每一个再点击一次。也可以一次性全部删除.

 

案例: 演示有参无返回值的方法.

需求:
1.定义方法isEvenNumber(), 该方法接收一个int类型的整数num.
2.判断num是奇数还是偶数, 并打印结果.

方法简介:
概述:
就是把一些具有独立功能的代码整合到一起, 使其成为具有特殊功能的代码集.
格式:
修饰符 返回值的数据类型 方法名(数据类型 变量名1, 数据类型 变量名2...) {
方法体;
return 具体的返回值;
}
使用方法的6个步骤:
定义方法的3个明确:
1. 明确方法名. 最好做到见名知意.
2. 明确参数列表. 指的是调用方法的时候, 我们需要给方法的内容.
3. 明确返回值的数据类型. 方法执行完毕后, 返回给我们的数据.
调用方法的3个步骤:
1. 写 方法名();
2. 传参. 方法要什么类型的数据, 我们就传入什么类型的值.
3. 接收返回值. 方法返回什么数据, 我们就用对应的类型的变量来接收.

//定义方法

/**
* 该方法是用来求两个整数和的.
* @param a 要进行求和操作的第一个整数.
* @param b 要进行求和操作的第二个整数.
* @return 具体的求和结果
*/
public static int getSum(int a, int b) { //int a = ?, int b = ?
/* //求和
int sum = a + b;
//返回结果.
return sum;*/

return a + b;
}

//定义方法
public static void printArray(int[] arr) { //int[] arr = ?
//细节: 做非法值校验.
if (arr == null || arr.length == 0){
System.out.println("[]");
return; //记得结束方法.
}

System.out.print("[");
for (int i = 0; i < arr.length; i++) {
//arr[i] 就是数组中的每个元素.
//判断当前是否是最后一个元素, 如果不是, 后边就拼接,
if (i != arr.length - 1) {
System.out.print(arr[i] + ", ");
} else {
//走这里, 说明是最后一个元素.
System.out.println(arr[i] + "]");
}
}

方法重载简介:
概述:
1. 同一个类中,
2. 出现方法名相同,
3. 但是参数列表不同的, (情况1: 参数个数不同, 情况2: 对应参数的数据类型不同)
4. 两个或者以上的方法时, 称为 方法重载.
5. 方法重载与返回值的数据类型无关.

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

案例: Debug断点调试.

名词解释:
Bug:
俗称就是所有的非正常情况就叫: Bug.
Debug:
概述:
Debug是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。
Debug调试的步骤:
1. 加断点.
那里不会点哪里, 一般是方法的第一行有效代码处.
2. 启动调试页面.
在代码编辑区, 右键 -> Debug ...
3. 看哪里.
下左: Frames, 记录的是当前程序执行到哪里了, 类似于: 栈.
下中: Variables, 记录的是程序中 变量的变化的.
下右: Console, 即: 控制台, 用来展示程序运行结果的.
4. 如何进行下一步.
F7: 逐过程调试. 即一步一步的走, 遇到我们自定义的方法, 会进入到方法内部.
F8: 逐行调试. 即一行一行的走, 遇到我们自定的方法, 不会进入到方法内部, 而是当做一行代码来处理.
F9: 逐断点调试. 即一个断点一个断点的走, 如果当前断点已经是最后一个断点了, 再次按下F9即可结束 调试 过程.
5. 如何结束调试页面.
方式1: 点 红色正方形结束按钮.
方式2: 把整个程序都调试完.
方式3: 如果当前断点已经是最后一个断点了, 再次按下F9即可结束 调试 过程.
6. 如何清除断点.
方式1: 再次点击.
方式2: 选择"双点"图标(break points) -

案例: 面向对象相关的概述.

面向过程编程思想:
它是一种编程思想, 强调的是以过程为基础完成各种操作, 即: 每个动作都要我们亲力亲为.
代表语言: C语言.

面向对象编程思想:
概述:
它是一种编程思想, 强调的是以对象为基础完成各种操作, 它是基于面向过程的.
思想特点:
1. 跟符合我们的思考习惯.
2. 把复杂的事情简单化.
3. 把程序员从执行者变成指挥者.
面试答法: 概述, 思想特点, 举例, 总结.

问: 我们是如何描述现实世界的事物呢?
通过 名词(属性) 和 动词(行为) 来描述.
例如: 你给我描述一下 大象吧.
属性:
一对眼睛, 长鼻子, 四条腿, 名词.
行为:
吃饭, 睡觉,

Java是一门编程语言, 最基本的单位是: 类, 换言之, Java是通过类来描述现实世界事物的, 一些相关名词如下:
类: 是一个抽象的概念, 看不见, 也摸不着. 是属性和行为的集合.
对象: 是类的具体体现, 实现, 看得见, 也摸得着.
属性: 也叫成员变量, 是一个名词. 用来描述事物的外在特征的.
成员变量:
和以前定义变量一样, 只不过先写到 类中, 方法外.
行为: 也叫成员方法, 是一个动词, 用来指 事物能够做什么的.
成员方法:
和以前定义方法一样, 只不过先不写static.