01 Java概述
1.1 Java语言发展史
CHHART： Java发展史
- Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言， 2009年Oracle甲骨文公司收购Sun公司
- Java之父：詹姆斯·高斯林（James Gosling
1.2 Java语言跨平台原理
- Java可以在任意操作系统上运行，Windows、Mac、Linux。我们只需要在运行Java应用程序的操作系统上，安装一个与操作系统对应的Java虚拟机（JVM Java Virtual Machine）就可以实现Java的跨平台使用了。
1.3 JRE和JDK
-
JRE（Java Runtime Environment）
- 是Java程序的运行时环境，它包括JVM和运行时所需要的核心类库
- 需要注意的是，JRE是包含JVM的，因此只安装JRE也是可以实现Java的跨平台使用的
-
JDK（Java Development Kit）
- 是Java程序的开发工具包，包含JRE和开发人员使用的工具
- 其中的开发工具包括：编译工具（javac.exe）和运行工具（java.exe）
- 如果想开发一个全新的Java程序，必须安装JDK
-
JDK、JRE和JVM的关系 由下图我们可以看出，JDK包含JRE，JRE包含JVM。对于开发人员来说，我们只需要使用JDK就可以满足一切开发和应用的需求
CHART： JDK、JRE和JVM的关系
02 第一个程序
2.1 常用DOS命令
| 命令 | 命令作用 |
|---|---|
| 盘符名称： | 盘符切换。E：回车，表示切换到E盘 |
| dir | 查看当前路径下的内容 |
| cd 目录 | 进入单级目录 |
| cd … | 回退到上一级目录 |
| cd 目录1\目录2… | 进入多级目录 |
| cd \ | 回退到盘符目录 |
| cls | 清屏 |
| exit | 退出命令提示符窗口 |
2.2 Path环境变量的配置
- 开发Java程序,需要使用JDK提供的开发工具，而这些工具在JDK的安装目录的bin目录下
为了在开发Java程序的时候，能够方便的使用javac和java这些命令，我们需要配置Path环境变量
2.3 HelloWorld案例
-
开发java程序的三个步骤：编写程序、编译程序、运行程序
-
编译：java 文件名.java
范例：java HelloWorld.java
-
执行：java 类名
范例：java HelloWorld
public class HelloWorld{
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
03 基础语法
3.1 注释
-
注释解析：注释是在程序指定位置添加的说明性信息
注释不参与程序运行，仅起到说明作用
-
注释的分类
注释类别 格式 单行注释 // 注释信息 多行注释 /* 注释信息 */ 文档注释 /** 注释信息 */ -
实例
/* Java程序中最基本的组成单位是类。 类的定义格式： public class 类名{ } 这是定义的HelloWorld类 */ public class HelloWorld{ /* 这是main方法 main方法是程序的入口，代码的执行是从main方法开始的 */ public static void main(String[] args) { // 这是输出语句，“”里面的内容是可以改变的 System.out.println("HelloWorld"); } }
3.2 关键字
- 关键字概述：关键字是被Java赋予了特定含义的单词
- 特点：
- 关键字的字母全部小写
- 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观
3.3 常量
-
概念：在程序运行过程中，其值不可以发生改变的量
-
常量分类
常量的分类：常量类型 说明 举例
|字符串常量|用双引号引起来的内容|“abc”、“123”、“Hello”|
|整数常量|不带小数的数字|100、200、0、-250|
|浮点数常量|带小数的数字|2.5、-3.14、0.0|
|字符常量|用单引号括起来的内容|‘a’、‘B’、‘9’、‘中’|
|布尔常量|布尔值，表示真假|只有两个值：ture、false|
|空常量|一个特殊的值，空值|值是：null|
3.4 数据类型
-
计算机存储单元：
- 计算机存储设备的最小信息单元是“位（bit）”，又称为比特位，常用小写字母“b”表示
- 计算机中最小的存储单元是“字节（byte）”，通常用大写字母“B”表示，字节是由连续的8个位组成
- 其他常用的存储单位如下：
1B = 8bit；
1KB = 1024B；
1MB = 1024KB；
1GB = 1024MB；
1TB = 1024GB
-
数据类型：
-
Java语言是强类型语言，对于每一种数据都给出了明确的数据类型
-
不同的数据类型也分配了不同的内存空间，所有它们表示的数据大小也是不一样的
CHART：数据类型
-
-
数据类型内存占用和取值范围：
CHART：数据类型内存占用和取值范围
3.5 变量
-
变量概述：变量是在程序运行过程中，其值可以改变的量
从本质上讲，变量是内存中一小块区域
-
变量定义：数据类型 变量名 = 变量值；
例如，int a = 10;
-
变量的使用：包括取值和修改值
public class VariableDemo{ public static void main(String[] args){ //定义变量 int a = 10; //输出变量 System.out.println(a); //修改变量 a = 20; System.out.println(a); } } -
变量使用的注意事项：
-
变量名称不能重复
-
变量必须先赋值再使用
-
long类型变量定义的时候，为了防止整数过大，后面要加L/l
（给出一个整数，默认是int类型的）
-
float类型变量定义的时候，为了防止类型不兼容，后面要加F/f
（给出一个浮点数，默认是double类型的）
-
3.6 标识符
- 概念：标识符是给类、方法、变量等起名字的符号
- 标识符定义规则：
- 由数字、字母、下划线_和美元符$ 组成
- 不能以数字开头
- 不能是关键字
- 要区分大小写
- 常见命名约定：
- 小骆峰命名法：方法、变量
约定1：标识符是一个单词的时候，首字母小写；eg：name
约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写；eg：firstNAME - 大骆峰命名法：类
约定1：标识符是一个单词的时候，首字母大写；eg：Student
约定2：标识符由多个单词组成的时候，每个单词的首字母大写；eg：GoodStudent
- 小骆峰命名法：方法、变量
3.7 类型转换
-
类型转换分类：自动类型转换、强制类型转换
-
自动类型转换：把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量
例如：double d = 10;
CHART： 自动类型转换
-
强制类型转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
例如：int k = (int)88.88; （可以实现但是不建议，会有数据的丢失）
04 运算符
4.1 算数运算符
-
运算符和表达式：
-
运算符：对常量或者变量进行操作的符号
-
表达式：用运算符把常量或者变量连接起来符合java语法的式子即为表达式。不同运算符连接的表达式体现的是不同类型的表达式
-
例如：int a =10; int b = 20; int c = a + b;
+：是运算符，并且是算术运算符
a + b：是表达式，由于+是算术运算符，所以这个表达式称为算术表达式
/* 算术运算符 */ public class OperatorDemo1{ public static void main(String[] args){ //定义两个变量 int a = 6; int b = 4; System.out.println(a + b); # out>>10 System.out.println(a - b); # out>>2 System.out.println(a * b); # out>>24 System.out.println(a / b); # out>>1 System.out.println(a % b); # out>>2 //除法(/)得到的是商，取余(%)得到的是余数 //整数相除只能得到整数，要想得到小数，必须有浮点数的参与 System.out.println(6.0 / 4); # out>>1.5 } } -
-
字符的 ‘+’ 操作
-
字符的 ‘+’ 操作是字符在计算机底层对应的数值来进行计算的
CHART： ‘A’——65；‘a’——97；‘0’——48
-
算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升
-
提升规则：
byte类型，short类型和char类型将被提升到int类型
整个表达式的类型自动提示到表达式中最高等级操作数同样的类型
等级顺序：byte, short, char ->int->long->float->double（char类型会被自动提升为int类型）
-
-
字符串的 ‘+’ 操作
package test; public class test { public static void main(String[] args) { System.out.println("hello"+"earth"); System.out.println("hello"+6666); System.out.println(6666+ "hello"); System.out.println("hello"+6+666); System.out.println(6+666+"hello"); } } //结果： helloearth hello6666 6666hello hello6666 672hello-
当 ‘+’ 操作中出现字符串时，这个 ‘+’ 是字符串连接符，而不是算术运算
-
在 ‘+’ 操作中，如果出现了字符串，就是连接运算符，否则就说算术运算
当连续进行 ‘+’ 操作时，从左到右逐个执行
-
4.2 赋值运算符
CHART： 赋值运算符
- 注意：扩展的赋值运算符隐含了强制转换
4.3 自增自减运算符
CHART： 自增自减运算符
-
注意：
++和–既可以放在变量的后面，也可以放在变量的前面
单独使用的时候，++和–无论放在前面还算后面，结果是是一样的
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–
参与操作的时候，如果放在变量的前边，先拿变量做++或者–-，后拿变量参与操作
package test;
public class test {
public static void main(String[] args) {
int i = 1;
System.out.println("i="+i);
//参与操作使用
int j = ++i;
System.out.println("i="+i);
System.out.println("j="+j);
}
}
//结果：
i=1
j=2
j=2
4.4 关系运算符
CHART：关系运算符
4.5 逻辑运算符
CHATR： 逻辑运算符(& | ^异或 !非)、短路逻辑运算符(&& ||)
- 注意：
（1）逻辑与&，无论左边真假，右边都要执行
（2）短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行
（3）逻辑或|，无论左边真假，右边都要执行
（4）短路或||，如果左边为假，右边执行；如果左边为真，右边不执
/*
注意事项：
1. 逻辑运算符只能是一个boolean值
2. 与、或需要左右各自有一个Boolean值，但是取反只需要有唯一的一个booolean即可
3. 与、或两种运算符，如果有多个条件，可以连续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C
TIPS：
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2;
1 < x && x < 3
*/
public class Demo09Logic {
public static void main(String args[]) {
System.out.println(true && false); // false
System.out.println(true && true); // true
// true && true --> true
System.out.println(3 < 4 && 10 > 5); // true
System.out.println("========");
System.out.println(true || false); // true
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println("=========");
System.out.println(true); // true
System.out.println(!true); // false
System.out.println("===========");
int a = 10;
System.out.println(3 > 4 && ++a < 100); // false
System.out.println(a); // 10
int b = 20;
System.out.println(3 < 4 || ++b < 100); // true
System.out.println(b); // 20
}
}
4.6 三元运算符
-
格式：关系表达式？表达式1：表达式2
-
计算规则：首先计算关系表达式的值
如果值为true，表达式1的值就是运算结果
如果值为false，表达式2的值就是运算结果
/*
三元运算符
*/
public class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 10;
int b = 20;
//获取两个数据中的较大值
int max = a > b ? a : b;
//输出结果
System.out.println("max:" + max); # out>>max:20
}
}
05 数据输入
-
Scanner使用的基本步骤：
-
导包：import java.util.Scanner;
导包的动作必须出现在类定义的上边
- 手动导包
- 快捷键导报：Alt+Enter
- 自动导报：输入Scan+Enter
-
创建对象：Scanner sc = new Scanner(System.in);
这里面只有sc是变量名，可以改变，其他的都不能变
-
接收数据：int i = sc.nextInt();
上面这个格式，只有i是变量名，可以变，其他都不能变
-
示例：
/* 数据输入： （1）导包： import java.util.Scanner; （2）创建对象： Scanner sc = new Scanner(System.in); （3）接收数据： int x = sc.nextInn(); */ //导包： import java.util.Scanner; public class ScannerDemo{ public static void main(String[] args){ //创建对象： Scanner sc = new Scanner(System.in); //接收数据： int x = sc.nextInt(); //输出数据： System.out.println("x:" + x); } }
-
06 分支语句
6.1 流程控制
-
流程控制语句分类：
（1）顺序结构
（2）分支结构（if, switch）
（3）循环结构(for, while, do…while)
-
顺序结构：顺序结构是程序中最简单、最基本的流程控制，没用特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
6.2 if语句
-
格式1
if (关系表达式){ 语句体; } /* 执行流程： 1.首先计算关系表达式的值； 2.如果关系表达式的值为true，则执行语句体； 3.如果关系表达式的值为false就不执行语句体； 4.继续执行后面的语句内容 */ -
格式2
if (关系表达式){ 语句体1； }else{ 语句体2； } /* 执行流程： 1.首先计算关系表达式的值； 2.如果关系表达式的值为true，则执行语句体1； 3.如果关系表达式的值为false，则执行语句体2； 4.继续执行后面的语句内容 */ -
格式3
if (关系表达式1){ 语句体1; }else if(关系表达式2){ 语句体2; } ··· else{ 语句体n+1; } /* 执行流程： 1.首先计算关系表达式的值； 2.如果关系表达式的值为true，则执行语句体1； 3.如果关系表达式的值为false，则执行语句体2； 4.继续执行后面的语句内容 */
6.3 switch语句
switch(表达式){
case 值1：
语句体1;
break;
case 值2：
语句体2；
break;
···
default：
语句体n+1;
[break;]
}
/*
格式说明：
1.表达式：取值为byte, short, int, char, string.
2.case：后面跟的是要和表达式进行比较的值。
3.break：表示中断，结束的意思，用来结束switch语句。
4.default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
*/
07 循环语句
7.1 for循环语句
for (初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
/*
执行流程：
1.执行初始化语句；
2.执行条件判断语句,看其结果是true还是false
如果是false，循环结束，如果是true，继续执行；
3.执行循环体语句；
4.执行条件控制语句；
5.回到(2)继续
*/
7.2 while循环语句
初始化语句;
while (条件判断语句){
循环体语句;
条件控制语句;
}
//执行流程：同for
7.3 do…while循环语句
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
/*
执行流程：
1.执行初始化语句；
2.执行循环体语句；
3.执行条件控制语句；
4.执行条件判断语句，看其结果是true还是false
如果是false，循环结束，如果是true，继续执行；
5.回到(2)继续
-
三种循环的区别：
（1）for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
（2）do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断） -
for和while的区别：
（1）条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问了
（2）条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用 -
死循环格式：
（1）for( ; ; ){ }
（2）while(true){ }
（3）do{ }while(true);while的死循环结构是最常见的，命令提示符窗口中Crtl+C可以结束死循环
7.4 跳转控制语句
- break：用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
- continue：用在循环中，基于条件控制，终止循环内容的执行，也就是说结束当前的整个循环
7.5 Random
-
作用： 产生一个随机数
-
使用步骤：
-
导包：import java.util.Random;
导包的动作必须出现在类的定义的上面
-
创建对象：Random r = new Random();
r是变量名，可以变，其他的都不允许变
-
获取随机数：int number = r.nextInt(10); //获取数据的范围：[0,10]，包括0，不包括10
number是变量名，可以变，数字10可以变，其他的都不允许变
-
-
示例：
/* Random */ //导包： import java.util.Random public class RandomDemo{ public static void main(String[] args){ //创建对象： Random r = new Random(); //用循环获取10个随机数 for(int i=0; i<10; i++){ //获取随机数： int number = r.nextInt(10); System.out.println("number:" + number); //需求：获取一个1-100之间的随机数 int x = r.nextInt(100) + 1; System.out.println(x); } } }
08 IEDA
8.1 IDEA概述
- IDEA全称IntelliJ IDEA，是用于Java语言开发的集成环境，是业界公认的目前用于Java程序开发最好的工具
- 集成环境：把代码编写、编译、执行、调试等多种功能综合到一起的开发工具
8.2 IDEA中的HelloWorld
- 步骤：
- 创建一个空项目（JavaSE_Code）
- 创建一个新模块（idea_test）
- 在idea_test模块下的src下创建一个包（com.itheima）
- 在com.itheima包下新建一个类（Helloworld）
- 在Helloworld类中编写代码
- 在idea中执行程序
8.3 IDEA中项目结构
- Project–>模块–>包–>类
CHART： IDEA中项目结构
8.4 IDEA中内容辅助键和快捷键
-
快速生成语句：
-
快速生成main()方法：psvm，回车
-
快速生成输出语句：sout，回车
（Ctrl+Alt解决无法使用的情况）
-
-
内容辅助键：
- ctrl+alt+space，内容提示，代码补全等
-
快捷键：
- 注释：
单行：选中代码，ctrl+/
多行：选址代码，ctrl+shift+/ - 格式化：
ctrl+alt+L
- 注释：
8.5 IDEA中模块的作用
- IDEA中模块操作分类：新建模块、删除模块、导入模块
09 数组
9.1 数组定义格式
- 数组概念：数组（array）是一种用于存储多个相同类型数据的存储模型
- 数组的定义格式：
（1）格式1：数据类型[ ] 变量名，例如：int [ ] arr。定义了一个int类型的数组，数组名是arr
（2）格式2：数据类型 变量名[ ]， 例如：int arr[ ]。定义了一个int类型的变量，变量名是arr数组
9.2 数组初始化之动态初始化
-
数组初始化概述：就说为数组中的数组元素分配内存空间，并为每个数组元素赋值
-
数组初始化类型：动态初始化、静态初始化
-
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型 [ ] 变量名 = new 数据类型[数组长度]，例如：int [] arr = new int[3]
public class ArrayDemo{ public static void main(String[] args){ int[] arr = new int[3]; /* 左边： int：说明数组中的元素是int类型 []：说明这是一个数组 arr：这是数组的名称 右边： new：为数组申请内存空间 int：说明数组中的元素类型是int类型 []：说明这是一个数组 3：数组长度，其实就说数组中的元素个数 */ } } -
静态初始化：9.5部分
-
9.3 数组元素访问
-
数组变量访问方式：数组名
数组内部保存数据的访问方式：数组名[索引]
-
索引：索引是数组中数据的编号方式，用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名
注意：1.索引是从0开始的、2.索引是连续的、3.索引逐一增加，每次加1
public class ArrayDemo{ public static void main(String[] args){ int[] arr = new int[3] //输出数组名 System.out.println(arr); # out>> [i@880ec60 表示内存地址值 //输出数组中的元素 System.out.println(arr[0]); # out>> 0 System.out.println(arr[1]); # out>> 0 System.out.println(arr[2]); # out>> 0 } }
9.4 Java中内存分配
-
栈内存：存储局部变量
定义在方法中的变量，例如：arr
使用完毕，立即消失
-
堆内存：存储new出来的内容（实体，对象）
数组在初始化时，会为存储空间添加默认值
- 整数：0
- 浮点数：0.0
- 布尔：false
- 字符：空字符
- 引用数据类型：null
每一个new出来的东西都会有一个地址值
使用完毕，会在垃圾回收器空闲时被收回
CHATR： Java中内存分配
9.5 数组初始化之静态初始化
-
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
-
格式1：数据类型 [ ] 变量名 = new 数据类型[ ] {数据1， 数据2， 数据3， …}，
例如：int [ ] arr = new int[ ] {1, 2, 3};
-
格式2：数据类型 [ ] 变量名 = {数据1， 数据2， 数据3， …}，
例如：int [ ] arr = {1, 2, 3};
-
9.6 数组操作的两个常见小问题
-
索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题
-
空指针异常：访问是数组已经不再指向堆内存的数据，造成空指针异常
null：空值，引用数据类型的默认值，表示不指向任何有效对象，arr = null;
9.7 数组常见操作
-
遍历：for循环 + 数组名.length
public class ArrayTest01{ public static void main(String[] args){ //定义数组 int[] arr = {1 , 2, 3, 4, 5}; //使用通用的遍历格式 for(int x=0; x<arr.length; x++){ System.out.println(arr[x]); } } } -
获取元素个数：数组名.length，例：arr.length
-
获取最值：
- 定义一个变量，用于保存最大值（或最大值）
- 取数组中第一个元素作为变量的初始值
- 与数组中剩余的数据逐个比较
public class test1 { public static void main(String []args ) { //获取最值 //定义一个数组 int[] arr = {3,1,2,4}; //定义存放最大值,令他等于数组第一个元素 int max = arr [0]; //循环比较找出真正的最大值 for(int i = 1;i < arr.length;i++) { if(max <= arr[i]) { max = arr[i]; } } System.out.println(max); } }
10 方法
10.1 方法概述
- 概念：方法（Method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
注意：- 方法必须先创建才可以使用，该过程称为方法定义
- 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用
10.2 方法的定义和调用
-
方法定义与调用：
// 方法定义 public static void method_name(){ //方法体 } //方法调用 method_name()示例：
public class MethodDemo { public static void main(String[] args) { //调用方法 isEvenNumber(); } //需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数 public static void isEvenNumber() { //定义变量 int number = 10; number = 9; //判断该数是否是偶数 if(number%2 ==0) { System.out.println(true); } else { Systm.println(false); } } }
10.3 带参数方法的定义和调用
-
带参数方法定义：
格式1：public static void 方法名(参数){...} 格式2（单个参数）：public static void 方法名(数据类型 变量名){...} 格式3（多个参数）：public static void 方法名(数据类型 变量名1, 数据类型 变量名2, ...){...}注意：
- 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错；
- 方法定义时，多个参数之间使用逗号分隔
-
带参数方法调用：
格式1：方法名(参数); 格式2（单个参数）：方法名(变量名/常量值); 格式3（多个参数）：方法名(变量名1/常量值1， 变量名2/常量值2);注意：方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
-
形参和实参：
- 形参：方法定义中的参数，等同于变量定义格式。例：int number;
- 实参：方法调用中的参数，等同于使用变量或常量。例：10 number
10.4 带返回值方法的定义和调用
-
带返回值方法定义：
格式：public static 数据类型 方法名(参数){ return 数据; }注意：方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
-
带返回值方法调用:
格式1：方法名(参数); 格式2：数据类型 方法名(参数);注意：方法的返回值通常会使用变量接收，否则该返回值将无意义
10.5 方法的注意事项
-
注意事项：
- 方法不能嵌套定义
- void表示无返回值，可以省略return，也可以单独书写return，后面不加数据
-
方法的通用格式：
public static 返回值类型 方法名(参数) { 方法体； return 数据; } 其中： public static----修饰符，目前先记住这个格式 返回值类型--------方法操作完毕之后返回的数据的数据类型 方法名------------调用方法的时候使用的标识 参数--------------由数据类型和变量名组成，多个参数之间使用逗号隔开 方法体------------完成功能的代码块 return-----------如果方法操作完毕，有数据返回，用于把数据返回给调用者定义方法时，要做到两个明确：
- 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没用，写void；如果有，写对应的数据类型
- 明确参数：主要是明确参数的类型和数量
方法调用时：
- void类型的方法可以直接调用
- 非void类型的方法，推荐用变量接收调用
10.6 方法重载
-
方法重载概念：方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载：
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不相同，类型不同或者数量不同
-
方法重载特点：
- 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式；
- 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判断两个方法是否相互构成重载
示例：
/* 方法重载： 多个方法在同一个类中； 多个方法具有相同的方法名； 多个方法的参数不相同，类型不同或者数量不同 与返回值无关，在调用方法的时候，Java虚拟机会通过参数的不同来区分同名的方法 */ public class MethoDemo { public static void main(String[] args) { //调用方法 int result = sum(a:10, b:20); System.out.println(result1); double result2 = sum(a:10.0, b:20.0); System.out.println(result2); int reslult3 = sum(a:10, b:20, c:30); System.out.println(result3); //需求1：求两个int类型数据和的方法 public static int sum(int a, int b) { return a + b; } //需求2：求两个double类型数据和的方法 public static int sum(double a, double b) { return a + b; } //需求3：求三个int类型数据和的方法 public static int sum(int a, int b, int c) { return a + b + c; } }
10.7 方法的参数的传递
-
对于基本数据类型的参数，形参的改变，不影响实际参数的值
CHART： 基本数据类型 参数不传递
-
对于引用类型的参数，形参的改变，影响实际参数的值
CHART： 引用类型 参数传递
11 Debug
- Debug概述：是供程序员使用的程序调试的工具，它用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序
- Debug操作流程：Debug调试，又被称为断点调试，断点其实是一个标记，告诉我们从哪里开始查看
- 注意事项：如果数据来自键盘输入，一定要记住输入数据，不然就不能继续往下查看了
案例
Test_1 减肥计划
package com.example;
//导包
import java.util.Scanner;
public class Test_01 {
public static void main(String[] args) {
//键盘录入一个星期数，用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数： ");
int week = sc.nextInt();
//对星期数进行判断，这里用if语句实现
if (week < 1 || week > 7) {
System.out.println("你输入的星期数有误 ");
} else if (week == 1) {
System.out.println("跑步");
} else if (week == 2) {
System.out.println("游泳");
} else if (week == 3) {
System.out.println("慢走");
} else if (week == 4) {
System.out.println("动感单车");
} else if (week == 5) {
System.out.println("拳击");
} else if (week == 6) {
System.out.println("爬山");
} else {
System.out.println("好好吃一顿");
}
}
}
//switch实现
package com.example;
import java.util.Scanner;
public class Test_02 {
public static void main(String[] args) {
//键盘录入一个星期数，用一个变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数：");
int week = sc.nextInt();
//对星期数进行判断，这里用 switch 语句实现
switch (week) {
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
//...
default:
System.out.println("你输入的星期数有误");
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
