Java基础

JDK：
Javac和java就放在这个目录。

常用DOS命令：
Win+R->输入cmd->回车
操作 说明
盘符名称: 盘符切换
dir 查看当前路径下的内容
cd 目录 进入单级目录
cd … 回退到上一级目录
cd 目录1\目录2… 进入多级目录
cd\ 回退到盘符目录
cls 清屏
exit 退出命令提示窗口

Path环境变量的配置
此电脑->属性->高级系统设置->新建JAVA_HOME变量（高级->环境变量->系统变量下新建->输入，变量名：JAVA_HOME，变量值：（jdk的安装目录）->选中path变量->编辑->新建输入%JAVA_HOME%\bin->依次点击确定即可）

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序

注释分类：
单行注释 //注释信息
多行注释 /注释信息/
文档注释 /*注释信息/

关键字
概述：就是被Java语言赋予了特定含义的单词
特点：
关键字的字母全部小写

常量
概述：在程序运行过程中，其值不可以发生改变的量

常量分类
常量类型 说明 举例
字符串常量 用双引号括起来的内容 “HelloWorld”，“你好”
整数常量 不带小数的数字 666，-88
小数常量 带小数的数字 13.14，-5.21
字符常量 用单引号括起来的内容 ‘A’，‘0’，‘我’
布尔常量 布尔值，表示真假 只有两个值：true，false
空常量 一个特殊的值，空值 值是：null
注意：空常量是不能输出的

计算机存储设备最小的信息单元叫“位（bit）”，我们称之为“比特位”，通常用小写的字母“b”表示。而计算机中最小的存储单元叫“字节（byte）”，通常用大写字母“B”表示，字节是由连续的八个位组成。
1B=8bit
1KB=1024B
1MB=1024KB
1GB=1024MB
1TB=1024GB

数据类型

变量
变量：在程序运行过程中，其值可以发生改变的量
从本质上讲，变量是内存中一小块区域
暂存未知——>变量名
内容——>数据类型
有意义——>变量值
定义变量
格式：数据类型 变量名=变量值
Eg：int a=10;
变量的使用
取值格式：变量名
Eg：a

修改值格式：变量名=变量值
Eg：a=20;
定义变量
int a = 10;
输出变量
System.out.println(a);
修改变量
a = 20;
System.out.println(a);
变量使用的注意事项：
名字不能重复
变量未赋值不能使用
long类型的变量定义的时候，为了防止整数过大，后面加L
float类型的变量定义的时候，为了防止类型不兼容，后面要加F

标识符
标识符：就是给类，方法，变量等起名字的符号
定义规则：
由数字、字母、下划线（_）和美元符（$）组成
不能以数字开头
不能是关键字
区分大小写
常见命名约定
小驼峰命名法：方法、变量
约定1：标识符是一个单词的时候，首字母小写
范例1：name
约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
范例2：firstName
大驼峰命名法：类
约定1：标识符是一个单词的时候，首字母大写
范例1：Student
约定2：标识符由多个单词组成的时候，每个单词的首字母大写
范例2：GoodStudent

类型转换
A.自动类型转换
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量
范例：double d=10；

Byte到char不能转化
B.强制类型转换
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：目标数据类型 变量名=（目标数据类型）值或者变量；
范例：int k=(int)88.88;
System.out.println(k);//结果为88,，有数据丢失，一般不建议使用

运算符和表达式
运算符；对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。
举例说明：
int a=10;
int b=20;
int c=a+b;
+:是运算符，并且是算术运算符
a+b:是表达式，由于+是算术运算符，所以这个表达式叫算术表达式
符号 作用

• 加

• 减

• 乘
  / 除
  % 取余
  注意事项：
  /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
  整数操作只能得到整数，只想得到小数，必须有浮点数参与。

字符的“+”操作
//定义两个变量
int i=10;//
cahr c=‘A’;//‘A’的值是65
c=‘a’;//‘a’的值是97
c=‘0’；//‘0’的值是48
System.out.println(i+c);
int类型接收

字符串的“+”操作
拼接

当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算数运算。
“itheima0”+666
在“+”操作中，如果出现字符串，就是连接运算符，否则就是算术运算符。当连续进行“+”操作时，从左到右逐个执行。
1+99+“年黑马”

赋值运算符

符号 作用 说明
= 赋值 a=10,将10的值赋值给a
+= 加后赋值 a+=b,将a+b的值给a
-= 减后赋值 a-=b,将a-b的值给a
= 乘后赋值 a=b,将a*b的值给a
/= 除后赋值 a/=b,将a÷b的商给a
%= 取余后赋值 a%=b,将a÷b的余数给a
注意事项：
扩展的赋值运算符隐含了强制类型转换

自增自减运算符
符号 作用 说明
++ 自增 变量的值加1
– 自减 变量的值减1
注意事项：
++和—既可以放在变量的后面，也可以放在变量的前面。
单独使用的时候，++和—无论放在变量的前面还是后面，结果是一样的。
参与操作的时候，如果放在变量的后面，先拿变量参与操作，后拿变量做++或者–。
参与操作的时候，如果放在变量的前面，先拿变量做++或者–，后拿变量参与操作。

关系运算符

结果为布尔类型的
注意事项：
关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把“==”误写成“=”。

逻辑运算符

符号 作用 说明
& 逻辑与 a&b,a和b都是true，结果为true，否则为false
| 逻辑或 a|b,a和b都是false，结果为false，否则为true
^ 逻辑异或 a^b,a和b结果不同为true，相同为false
! 逻辑非 !a，结果和a的结果正好相反

短路逻辑运算符
符号 作用 说明
&& 短路与 作用和&相同，但是有短路效果
|| 短路或 作用和|相同，但是有短路效果
注意事项:
逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或|，无论左边是真假，右边都要执行。
短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

最常用的逻辑运算符：&&，||，！

三元运算符
格式：关系表达式？表达式1：表达式2；
范例：a>b?a:b;
计算规则：
首先计算关系表达式的值
如果值为true，表达式1的值就是运算结果
如果值为false，表达式2的值就是运算结果
Eg：

案例：两只老虎

int weight1 = 100;
int weight2 = 200;
boolean b = weight1 == weight2 ? true:false;//结果为true或者false，所以用boolean类型

案例：三个和尚

int height1 = 150;
int height2 = 210;
int height3 = 165;
int tempHeight = height1 > height2 ?height1:height2;
int maxHeight = tempHeight > height3 ?tempHeight:height3;
System.out.println(“maxHeight:”+maxHeight);

数据输入
Scanner使用的基本步骤
i导包：import java.util.Scanner;
导包的动作必须出现在类定义的上边；
ii创建对象：Scanner sc = new Scanner(System.in);
这个格式里面，只有sc是变量名，可以变，其他的都不允许变；
iii接收数据：int i = sc.nextInt();
这个格式里面，只有i是变量名，其他的都不允许变。

案例：三个和尚

Impot java.util.Scanner;

Scanner sc = new Scanner(System.in);
System.out.println(“请输入第一个和尚的身高：”);
int height1 = sc.nextInt();
System.out.println(“请输入第二个和尚的身高：”);
int height2 = sc.nextInt();
System.out.println(“请输入第三个和尚的身高：”);

int height3 = sc.nextInt();
int tempHeight = height1 > height2 ? height1:height2;
int maxHeight = tempHeight > height3 ? tempHeight:height3;
System.out.println(“这三个和尚中身高最高的是:”+maxHight+“cm”);

分支语句
流程控制语句

分类：
顺序结构
分支结构（if,switch）
循环结构（for,while,do…while）
顺序结构

If语句
格式：
if(关系表达式){
语句体;
}
执行流程：
首先计算关系表达式的值
如果关系表达式的值为true就执行语句体
如果关系表达式的值为false就不执行语句体
继续执行后面的语句内容

if语句格式2

案例：奇偶数

if语句格式3

案例：考试奖励

数据测试：准确数据，边界数据，错误数据

switch语句

案例：春夏秋冬

/*
春夏秋冬

需求：
	一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12

*/

import java.util.Scanner;

public class SwitchTest {
public static void main(String[] args) {
//键盘录入月份数据，使用变量接收
Scanner sc = new Scanner(System.in);

	System.out.println("请输入一个月份：");
	int month = sc.nextInt();
	
	//多情况判断，这里采用switch语句实现
	//在每种情况中，完成输出对应的季节
	/*
	switch(month) {
		case 1:
			System.out.println("冬季");
			break;
		case 2:
			System.out.println("冬季");
			//break;
		case 3:
			System.out.println("春季");
			break;
		case 4:
			System.out.println("春季");
			break;
		case 5:
			System.out.println("春季");
			break;
		case 6:
			System.out.println("夏季");
			break;
		case 7:
			System.out.println("夏季");
			break;
		case 8:
			System.out.println("夏季");
			break;
		case 9:
			System.out.println("秋季");
			break;
		case 10:
			System.out.println("秋季");
			break;
		case 11:
			System.out.println("秋季");
			break;
		case 12:
			System.out.println("冬季");
			break;
		default:
			System.out.println("你输入的月份有误");
			//break;
	}
	*/

	//case穿透
	switch(month) {
		case 1:
		case 2:
		case 12:
			System.out.println("冬季");
			break;
		case 3:
		case 4:
		case 5:
			System.out.println("春季");
			break;
		case 6:
		case 7:
		case 8:
			System.out.println("夏季");
			break;
		case 9:
		case 10:
		case 11:
			System.out.println("秋季");
			break;
		default:
			System.out.println("你输入的月份有误");
	}		
}

}

注意事项：
在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，不判断下一个case值的情况下，向下运行，直到遇到break，或者整体switch语句结束

for循环语句

循环结构的组成:
初始化语句:用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样；
条件判断语句:用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去；
循环体语句:用于表示循环反复执行的内容，简单说就是循环反复执行的事情；
条件控制语句:用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去。
循环结构对应的语法:
初始化语句:这里可以是一条或者多条语句，这些语句可以完成一些初始化操作；
条件判断语句:这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如: a<3；
循环体语句:这里可以是任意语句，这些语句将反复执行；
条件控制语句:这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见i++,i–这样的操作。
格式：
for(初始化语句；条件判断语句；条件控制语句){
循环体语句；
}
执行流程:
1)执行初始化语句
2)执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3)执行循环体语句
4)执行条件控制语句
5)回到②继续

案例：输出数据

for(int i=1;i<=5;i++){
System.out.println(i);
}
System.out.println(“-------”);
For(int i=5;i>=1;i–){
System.out.println(i);
}

案例：求和

sum += i; sum = sum + i;

案例：求偶数和

案例：水仙花
需求:在控制台输出所有的“水仙花数”
什么是“水仙花数”?
i水仙花数是一个三位数
111 222 333 370 371 520 999
ii水仙花数的个位、十位、百位的数字立方和等于原数
123 13+23+33= 1+8 +27 = 36 ≠ 123 不是水仙花数
371 33+73+13=27+ 343+1 = 371 = 371 是水仙花数

案例：统计

while循环语句
格式：
基本格式：
While (条件判断语句) {
循环语句;
}
完整格式：
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
执行流程:
i执行初始化语句
ii执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
iii执行循环体语句
iv执行条件控制语句
v回到ii继续

for循环和while循环要会互相转换

案例：珠穆朗玛峰

do while循环语句
格式：
基本格式:
do {
循环体语句;
}while(条件判断语句);
完整格式:
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判嘶语句);
执行流程:
i执行初始化语句
ii执行循环体语句
iii执行条件控制语句
iv执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
v回到ii继续

三种循环的区别

三种循环的区别:
for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行)
do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断)
for和while的区别:
条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
死循环格式:
for(😉{}
while(true){}
do( }while(true);

while的死循环格式是最常用的
命令提示符窗口中Ctrl+C可以结束死循环

跳转控制语句

循环嵌套

语句结构:
顺序语句 以分号结尾，表示一句话的结束
分支语句
1)一对大括号表示if的整体结构，整体描述一个完整的if语句
2)一对大括号表示switch的整体结构，整体描述一个完整的switch语句
循环语句
1)一对大括号表示for的整体结构，整体描述一个完整的for语句
2)一对大括号表示while的整体结构，整体描述一个完整的while语句do…while以分号结尾，整体描述一个完整的do…while语句

Random
作用:用于产生一个随机数
使用步骤:
1.导包
import java. util.Random;
导包的动作必须出现在类定义的上面
2.创建对象
Random r = new Random() ;
上面这个格式里面，r是变量名，可以变，其他的都不允许变
3.获取随机数
int number = r.nextInt(10);//获取数据的范围:[0,10)包括0，不包括10
上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变

可以用for循环输出固定个数的随机数

案例：猜数字

IDEA概述
IDEA全称IntelliJ IDEA，是用于Java语言开发的集成环境，它是业界公认的目前用于Java程序开发最好的工具。
集成环境:把代码编写，编译，执行，调试等多种功能综合到一起的开发工具。
IDEA的下载和安装
下载:https://www.jetbrains.com/idea/
安装:傻瓜式安装，建议修改安装路径。
安装流程

IDEA启动的基本配置

接着下一步…

IDEA中HelloWorld步骤
1)创建一个空项目(JavaSE_Code)
2)创建一个新模块(idea_test)
3)在idea_test模块下的src下创建一个包(conlitheima)
4)在com.itheima包下新建一个类(HelloWorld)
5)在HelloWorld类中编写代码
6)在idea中执行程序

IDEA项目结构

IDEA中内容辅助键和快捷键
内容辅助键
快速生成语句
快速生成main()方法: psvm，回车
快速生成输出语句: sout，回车
内容辅助键
Ctrl+Alt+space(内容提示，代码补全等)

快捷键
注释
单行:选中代码，Ctrl+/，再来一次。就是取消
多行:选中代码，Ctrl+Shift+/，再来一次。就是取消
格式化
Ctrl+Alt+L

IDEA中模块操作
新建模块
删除模块
导入模块
新建模块

删除模块

导入模块

数组
数组定义格式
数组初始化之动态初始化
数组元素访问
内存分配
数组初始化之静态初始化
数组操作的两个常见小问题
数组常见操作

数组定义格式
数组描述

a = 100
b = 100
c = 100
d = 100
e = 100
f = 100
g = 100
……
—次性声明大量的用于存储数据的变量
要存储的数据通常都是同类型数据，例如:考试成绩
什么是数组
数组(array)是一种用于存储多个相同类型数据的存储模型
数组的定义格式
格式—:数据类型[ ] 变量名
范例; int[ ] arr
格式二:数据类型 变量名[ ]
范例: int arr[ ]

数组初始化之动态初始化
Java中的数组必须先初始化,然后才能使用
所谓初始化:就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
数组初始化方式
动态初始化
静态初始化
动态初始化
动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式:数据类型[ ] 变量名= new 数据类型[数组长度]
范例:int[ ] arr = new int[3];

/*
左边：
int:说明数组中元素类型是int类型
[]:说明是一个数组
arr:这是数组的名称
右边：
new:维数组申请内存空间
int:说明数组中的元素类型是int类型
[]:说明这是一个数组
3:数组长度，其实就是数组中的元素个数
*/

数组元素访问
数组变量访问方式
格式:数组名

数组内部保存的数据的访问方式
格式:数组名[索引]
索引是什么？

索引是数组中数据的编号方式
作用:索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名
特征①:索引从0开始
特征②:索引是连续的
特征③:索引逐一增加，每次加1
public static void main(String[] args) {
int[] arr = new int[3];
/*
左边：
int:说明数组中元素类型是int类型
[]:说明是一个数组
arr:这是数组的名称
右边：
new:维数组申请内存空间
int:说明数组中的元素类型是int类型
[]:说明这是一个数组
3:数组长度，其实就是数组中的元素个数
*/
//输出数组名
System.out.println(arr);//[I@4554617c

//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

}

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

数组在初始化时，会为存储空间添加默认值
整数:默认值0
浮点数:默认值0.0
布尔值:默认值false
字符:默认值是空字符
引用数据类型:默认值是null

输出：

栈内存:存储局部变量
定义在方法中的变量，例如:arr使用完毕，立即消失
堆内存:存储new出来的内容(实体，对象)
数组在初始化时，会为存储空间添加默认值
整数:0
浮点数:0.0
布尔:false
字符:空字符
引用数据类型:null
每一个new出来的东西都有一个地址值使用完毕，会在垃圾回收器空闲时被回收

数组内存图（单个数组）

数组内存图（多个数组）

运行结果：

数组内存图（多个数组指向相同）

运行结果：

数组初始化之静态初始化
静态初始化:初始化时指定每个数组元素的初始值，由系统决定数组长度
格式:数据类型[ ] 变量名= new 数据类型[ ] {数据1，数据2，数据3，…};
范例: int [ ] arr = new int[ ] {1,2,3};
简化格式:数据类型[ ] 变量名={数据1，数据2，数据3，…}.;
范例： int[ ] arr={1,2,3};

public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3};

//输出数组名
System.out.println(arr);

//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

}
运行结果：

数组操作的两个常见的小问题
索引越界:访问了数组中不存在的索引对应的元素，造成索引越界问题
ArrayIndexOutOfBoundsException
空指针异常:访问的数组已经不再指向堆内存的数据，造成空指针异常
NullPointerException
注：null:空值。引用数据类型的默认值，表示不指向任何有效对象
索引越界

索引越界:访问了数组中不存在的索引对应的元素，造成索引越界问题
Eg：

空指针异常

空指针异常:访问的数组已经不再指向堆内存的数据，造成空指针异常
注：null:空值，引用数据类型的默认值，表示不指向任何有效对象

数组常见操作
遍历

获取数组元素数量

格式:数组名.length
范例：arr.length

遍历的通用格式

Eg：

获取最值

Eg：找最大值

public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
int max = arr[0];
for(int x=1;x<arr.length;x++){
if(arr[x]>max){
max = arr[x];
}
}
System.out.println(“max:”+max);
}

Eg：找最小值

public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
int min = arr[0];
for(int x=1;x<arr.length;x++){
if(arr[x]<min){
min = arr[x];
}
}
System.out.println(“min:”+min);
}

方法
方法概述
方法的定义和调用
带参数方法的定义和调用
带返回值方法的定义和调用
方法的注意事项
方法重载
方法的参数传递

方法概述
方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
注意:
方法必须先创建才可以使用，该过程称为方法定义
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用

方法的定义和调用
方法的定义
格式: public static void方法名(){
//方法体
}
范例: public static void isEvenNumber(){
//方法体
}
方法调用
格式:方法名();
范例:isEvenNumber();
注意：
方法必须先定义后调用，否则程序将报错
Eg：

public static void main(String[] args) {
//调用方法
isEvenNumber();
}
//需求，定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
public static void isEvenNumber(){
//定义变量
int number = 10;

//判断该数据是否是偶数
if(number%2 == 0){
    System.out.println(true);
}else {
    System.out.println(false);
}

}

方法调用过程

方法练习
需求:设计一个方法用于打印两个数中的较大数

public static void main(String[] args) {
//在main()方法中调用定义好的方法
getMax();
}
//定义一个方法，用于打印两个数字中的较大数，例如getMax()
public static void getMax() {
int a=10;
int b=20;

//使用分支语句分两种情况对两个数字的大小关系进行处理
if(a>b){
    System.out.println(a);
} else {
    System.out.println(b);
}

}

带参数方法的定义和调用
带参数方法的定义
格式: public static void 方法名(参数){…}
格式(单个参数): public static void 方法名 (数据类型 变量名){ …}
范例(单个参数): public static void isEvenNumber(int number ) { … …}
格式(多个参数)︰
public static void方法名(数据类型 变量名1，数据类型 变量名2，… …){……}
范例(多个参数):
public static void getMax(int number1 , int number2 ) {…}
注意:
方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
方法定义时，多个参数之间使用逗引(，)分隔
带参数方法调用
格式:方法名(参数);
格式(单个参数)∶方法名(变量名/常量值);
范例（单个参数)∶isEvenNumber ( 5);
格式(多个参数):方法名(变量名1/常量值1，变量名2/常量值2);
范例(多个参数):getMax ( 5，6);
注意:
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

public static void main(String[] args) {
//常量值的调用
isEvenNumber(10);

//变量的调用
int number = 10;
isEvenNumber(number);

}
//需求，定义一个方法，该方法接收一个参数，判断该数据是否为偶数
public static void isEvenNumber(int number) {
if (number%2==0){
System.out.println(true);
}else {
System.out.println(false);
}
}

形参和实参
形参：方法定义中的参数
等同于变量定义格式，例如: int number
实参:方法调用中的参数
等同于使用变量或常量，例如:10 number

带参数方法练习
需求:设计一个方法用于打印两个数中的较大数，数据来自于方法参数

public static void main(String[] args) {
//在main()方法中调用定义好的方法（使用常量）
getMax(10,20);
//调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的

//在main()方法中调用定义好的方法（使用常量）
int a = 10;
int b = 20;
getMax(a,b);

}
//定义一个方法，用于打印两个数字中的较大数，例如getMax()
//为方法定义两个参数，用于接收两个数字
public static void getMax(int a,int b) {
//使用分支语句分两种情况对两个数字的大小关系进行处理
if(a>b){
System.out.println(a);
}else {
System.out.println(b);
}
}

带返回值方法的定义和调用
带返回值方法定义
格式: public static 数据类型 方法名(参数){
return数据;
}
范例1: public static boolean isEvenNumber( int number ) {
return true ;
}
范例2: public static int getMax( int a， int b ) {
return 100;
}
注意:
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
带返回值方法调用
格式1:方法名(参数);
范例:isEvenNumber ( 5 ) ;
格式2:数据类型 变量名=方法名(参数);
范例:boolean flag = isEvenNumber ( 5 );
注意:
方法的返回值通常会使用变量接收，否则该返回值将无意义

public static void main(String[] args) {
//1:方法名（参数）；
// isEvenNumber(10);
// true;

    //2:数据类型 变量名 = 方法名（参数）;
    boolean flag = isEvenNumber(10);
    //boolean flag = true;
    System.out.println(flag);
}
//需求：定义一个方法，该方法接收一个参数，判断该数据是否为偶数，并返回真假值
public static boolean isEvenNumber(int number) {
    if(number%2==0){
        return true;
    }else {
        return false;
    }
}

带返回值方法练习
需求:设计一个方法可以获取两个数的较大值，数据来自于参数

public static void main(String[] args) {
//在main()方法中调用定义好的方法并使用变量保存
int result = getMax(10,20);
System.out.println(result);

//在main()方法中调用定义好的方法并直接打印结果
System.out.println(getMax(10,20));

}
//定义一个方法，用于获取两个数字中的较大值
public static int getMax(int a,int b){
//使用分支语句分两种情况对两个数字的大小关系进行处理
//根据题设分别设置两种情况下对应的返回结果
if(a>b){
return a;
}else {
return b;
}
}

方法的注意事项
方法不能嵌套定义
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

public static void main(String[] args) {

}
public static void methodOne(){

}
public static void methodTwo(){
return;
}

方法的通用格式
格式:public static 返回值类型 方法名(参数){
方法体;
return数据;
}
public static 修饰符，目前先记住这个格式
返回值类型 方法操作完毕之后返回的数据的数据类型
如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名 调用方法时使用的标识
参数 由数据类型和变量名组成，多个参数之间用逗号隔开
方法体 完成功能的代码块
return 如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确
明确返回值类型:主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
明确参数:主要是明确参数的类型和数量
调用方法时
void类型的方法，直接调用即可
非void类型的方法，推荐用变量接收调用

方法重载
方法重载概述
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

方法重载特点
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

*/
方法重载：
多个方法在同一个类中（在MethodDemo类中）
多个方法具有相同的方法名（相同的sum方法名）
多个方法的参数不相同，类型不同或者数量不同（1、2类型不同，1、3个数不同，2、3类型和个数都不相同）

  注：与返回值无关
     在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法

*/

public class MethodDemo {
public static void main(String[] args) {
//调用方法
int result = sum(10,20);
System.out.println(result);

    double result2 = sum(10.0,20.0);
    System.out.println(result2);

    int result3 = sum(10,20,30);
    System.out.println(result3);
}
//需求1：求两个int类型数据和的方法
public static int sum(int a,int b) {
    return a+b;
}

//需求2：求两个double类型数据和方法
public static double sum(double a,double b) {
    return a + b;
}

//需求3：求三个int类型数据和的方法
public static int sum(int a,int b,int c) {
    return a + b + c;
}

方法重载练习
需求:使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型(byte,short,intlong)

public static void main(String[] args) {
//调用方法
System.out.println(compare(10,20));
System.out.println(compare((byte)10,(byte)20));
System.out.println(compare((short)10,(short)20));
System.out.println(compare(10L,20L));
}
//int
public static boolean compare(int a,int b) {
System.out.println(“int”);
return a == b;
}

//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;
}

//long
public static boolean compare(long a,long b) {
System.out.println(“long”);
return a == b;
}

方法参数传递
方法参数传递（基本类型）