数组&方法
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 ? "]\r\n" : ", "));
}
}
}
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.
