Java
Base01
HelloWorld 案例
| NotePad/… | 文件类型 | Dos指令 |
|---|---|---|
| 编写 | .java | |
| 编译 | .class（字节码文件） | javac 文件名.java |
| 运行 | java 类名.class |
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld!");
}
}
注释
-
程序指定位置添加的说明性信息，不参与运行，仅起到说明作用
-
分类
-
单行注释 //
-
多行注释 /* */
-
文档注释 /** */
-
/*
Java程序中最基本的组成单位是类
类的定义格式：
public class 类名{}
*/
public class HelloWorld{
/*
主方法 main
main方法是程序的入口方法，代码的执行是从main方法开始的
*/
public static void main(String[] args){
// 程序的输出语句，"" 引号内容可改变
System.out.println("HelloWorld!");
}
}
关键字
-
被Java语言赋予了特定含义的单词
-
特点
-
关键字母全小写
-
常见的代码编辑器，针对关键字有特殊的颜色标记，非常直观
-
/*
关键字
1.public
2.class
3.void
...
*/
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld!");
}
}
常量
-
在程序运行过程中，其值不可以发生改变的量
-
分类
-
字符串常量 “”
-
字符常量 ”
-
整数常量
-
小数常量
-
布尔常量 true/false
-
空常量 null 空常量不能直接输出
-
public class HelloWorld{
public static void main(String[] args){
// 字符串常量
System.out.println("HelloWorld!");
System.out.println("-----------");
// 字符常量
System.out.println('A');
System.out.println("-----------");
// 整数常量
System.out.println(15);
System.out.println("-----------");
// 小数常量
System.out.println(3.14);
System.out.println("-----------");
// 布尔常量
System.out.println(true);
System.out.println("-----------");
// 空常量
// 空常量不能直接输出
// System.out.println(null);
System.out.println("-----------");
}
}
数据类型
-
Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的
-
分类
基本数据类型 占用字节 数值类型 整数类型 byte 1 int 默认 2 short 4 long 8 浮点类型 float 4 double 默认 8 字符型 char 2 非数值类型 布尔类型 boolean 1 引用数据类型 类 class 接口 interface 数组 []
变量
-
在程序运行过程中，其值可以发生改变的量，本质上讲，变量是内存中一小块区域
-
三要素
-
数据类型
-
变量名
-
变量值
-
-
先声明后使用
public class HelloWorld{
public static void main(String[] args){
// 声明变量
int a = 15;
// 使用变量
System.out.println(a);
// 修改变量的值
a = 13777;
// 再次使用变量
System.out.println(a);
}
}
-
变量使用的注意事项
-
声明时变量名不能重复
-
变量时未赋值不能使用
-
long类型赋值时须在值后加L，防止整数过大
-
float类型赋值时须在值后加F，防止不兼容的类型
-
标识符
-
给类，方法，变量等命名的符号
-
定义规则
-
由数字、字母、下划线_和美元夫$组成
-
不能以数字开头
-
不能是关键字
-
区分大小写
-
-
常见命名规定
-
小驼峰命名法 方法、变量
-
大驼峰命名法 类
-
类型转换
-
分类
-
自动类型转换 数据范围小的数值或者变量赋值给另一个数据范围大的变量
-
强制类型转换 数据范围大的数值或者变量赋值给另一个数据范围小的变量
-
public class HelloWorld{
public static void main(String[] args){
// 自动类型转换
// byte -> short -> int -> long -> float -> double
// char -> int -> long -> float -> double
double a = 10; // 10 int a double
System.out.println(a);
// 强制类型转换
int x = (int)88.88;
System.out.println(x);
}
}
运算符和表达式
-
运算符：对常量或者变量进行操作的符号
-
表达式：用运算符把常量或者变量连起来符合java语法的式子就可以称为表达式，不同运算符连接的表达式体现的是不同类型的表达式
算数运算符
-
加减乘除取余
public class HelloWorld{
public static void main(String[] args){
/*
算数运算符 + - * / %
*/
int x = 6;
int y = 4;
System.out.println(x + y); // 加 10
System.out.println(x - y); // 减 2
System.out.println(x * y); // 乘 24
System.out.println(x / y); // 除 1 被除数和除数为整数，商也为整数，被除数和除数存在浮点数，商为浮点数
System.out.println(x % y); // 模 2
}
}
字符的+操作
-
算数表达式中包含多个基本数据类型的值的时候，整个算数表达式的类型会自动进行提升
-
‘A’ -> 65 A-Z是连续的’，a’ -> 97 a-z是连续的，’0′ -> 48 0-9是连续的
public class HelloWorld{
public static void main(String[] args){
/*
字符的 + 操作
'A' -> 65 A-Z是连续的
'a' -> 97 a-z是连续的
'0' -> 48 0-9是连续的
算数表达式中包含多个基本数据类型的值的时候，整个算数表达式的类型会自动进行提升
*/
int a = 10;
char c = 'A';
System.out.println(a + c); // 10+65
c = 'a';
System.out.println(a + c); // 10+97
c = '0';
System.out.println(a + c); // 10+48
}
}
字符串的+操作
-
在 + 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算，当连续进行 + 操作时，从左到右做个执行
public class HelloWorld{
public static void main(String[] args){
/*
字符串的+操作
当 + 操作符出现字符串时，这个 + 是字符串连接符，而不是算数运算符
在 + 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算，当连续进行 + 操作时，从左到右做个执行
*/
System.out.println("it" + "heima"); // itheima
System.out.println("it" + 666); // it666
System.out.println(666 + "heima"); // 666heima
System.out.println("it" + 6 + 66); // it666
System.out.println(6 + 66 + "heima"); // 72heima
}
}
赋值运算符
public class HelloWorld{
public static void main(String[] args){
/*
赋值运算符 = += -= *= /= %=
扩展的赋值运算符隐含强制类型转换
*/
int i =10; // 将10赋值给int类型的变量i
System.out.println("i:" + i);
System.out.println("---------");
i += 20; // i = i + 20 左右数据相加，结果赋值给左边
System.out.println("i:" + i);
System.out.println("---------");
// x+=y 与 x=x+y 不完全等价 前者隐含强制类型转换
short x = 1;
// x = x + 10; 此时输出x，则报错不兼容的类型,算数表达式的类型会自动进行提升，此时x+10为int型，而x为short型
x+=10; // 隐含强制类型转换，即该表达式等价于 x=short(x+10)
System.out.println("short:" + x );
}
}
自增自减运算符
-
参与操作时，如果是后置自增自减，先拿变量参与操作，后拿变量单独进行自增自减
-
参与操作时，如果是前置自增自减，先拿变量单独进行自增自减，后拿变量参与操作
public class HelloWorld{
public static void main(String[] args){
/*
自增自减运算符 ++ --
参与操作时，如果是后置自增自减，先拿变量参与操作，后拿变量单独进行自增自减
参与操作时，如果是前置自增自减，先拿变量进行自增自减，后拿变量参与操作
*/
// ++ -- 单独使用 前置与后置效果相同
int i = 10;
System.out.println("i:" + i); // 10
System.out.println("----------");
i++;
System.out.println("i:" + i); // 11
System.out.println("----------");
++i;
System.out.println("i:" + i); // 12
System.out.println("----------");
i--;
System.out.println("i:" + i); //11
System.out.println("----------");
--i;
System.out.println("i:" + i); // 10
System.out.println("----------");
// ++ -- 参与操作使用
int j = i++; // 此时 j = 10,i = 11,执行完此行代码后，进行i++;
System.out.println("i:" + i); // 11
System.out.println("j:" + j); // 10
int j = ++i; // // 此时 j = 12,i = 12,执行此行代码时，进行++i;
}
}
关系运算符
public class HelloWorld{
public static void main(String[] args){
/*
关系运算符 == != > < >= <=
*/
int i = 10;
int j = 20;
int k = 10;
// ==
System.out.println(i == j); // false
System.out.println(i == k); // true
System.out.println("----------");
// !=
System.out.println(i != j); // true
System.out.println(i != k); // false
System.out.println("----------");
// >
System.out.println(i > j); // false
System.out.println(i > k); // false
System.out.println("----------");
// >=
System.out.println(i >= j); // false
System.out.println(i >= k); // true
System.out.println("----------");
// 将 j 的值 赋值给 i 并输出 i 的值
System.out.println(i = j); // 20
}
}
逻辑运算符
public class HelloWorld{
public static void main(String[] args){
/*
逻辑运算符 & | ^ ！/ 与 或 异或 非
*/
int i = 10;
int j = 20;
int k = 30;
//& 有f则f
System.out.println(i > j & i > k); // f&f f
System.out.println(i < j & i > k); // t&f f
System.out.println(i > j & i < k); // f&t f
System.out.println(i < j & i < k); // t&t t
System.out.println("--------------");
//| 有t则t
System.out.println(i > j | i > k); // f|f f
System.out.println(i < j | i > k); // t|f t
System.out.println(i > j | i < k); // f|t t
System.out.println(i < j | i < k); // t|t t
System.out.println("--------------");
//^ 相同为f，不同为t
System.out.println(i > j ^ i > k); // f^f f
System.out.println(i < j ^ i > k); // t^f t
System.out.println(i > j ^ i < k); // f^t t
System.out.println(i < j ^ i < k); // t^t f
System.out.println("--------------");
//！
System.out.println(!(i > j | i > k)); // !(f|f) t
System.out.println("--------------");
短路逻辑运算符
-
逻辑与或，无论左边真假，右边都要执行
-
短路逻辑与或，左边为假真，右边不执行
public class HelloWorld{
public static void main(String[] args){
/*
短路逻辑运算符 && || 短路与 短路或
*/
int i = 10;
int j = 20;
int k = 30;
//& 有f则f
System.out.println(i > j && i > k); // f&f f
System.out.println(i < j && i > k); // t&f f
System.out.println(i > j && i < k); // f&t f
System.out.println(i < j && i < k); // t&t t
System.out.println("--------------");
//| 有t则t
System.out.println(i > j || i > k); // f|f f
System.out.println(i < j || i > k); // t|f t
System.out.println(i > j || i < k); // f|t t
System.out.println(i < j || i < k); // t|t t
System.out.println("--------------");
// 结果相同，但有短路效果，即短路与，有f则f的前提条件下，如第一个逻辑表达式结果为f，则不执行第二个逻辑表达式
System.out.println(i++ > 100 && j++ > 100); // f&&f f&&f
System.out.println("i:" + i); // 10+1
System.out.println("j:" + j); // 20
}
}
三元运算符
public class HelloWorld{
public static void main(String[] args){
/*
三元运算符 关系表达式？表达式1：表达式2
首先计算关系表达式的值
如果值为true，表达式1的值为运算结果
如果值为false，表达式2的值为运算结果
*/
int a = 10;
int b = 20;
// 获取两个数中的较大值
int max = a > b ? a : b;
System.out.println("max:" + max);
}
}
数据输入
-
导包 import java.util.Scanner; 导包的动作必须出现在类定义的上边
-
创建对象 Scanner sc = new Scanner(System.in);
-
接收数据 int i = sc.nextInt();
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
/*
数据输入 Sannner
导包 import java.util.Scanner; 导包的动作必须出现在类定义的上边
创建对象 Scanner sc = new Scanner(System.in);
接收数据 int i = sc.nextInt();
*/
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
int x = sc.nextInt();
// 输出变量
System.out.println(x);
}
}
Base02
流程控制语句分类
-
顺序结构
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行
public class HelloWorld{
public static void main(String[] args){
/*
顺序结构
*/
System.out.println("开始");
System.out.println("A");
System.out.println("B");
System.out.println("C");
System.out.println("结束");
}
}
-
分支结构
if 语句
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
/*
if 语句
1.if(关系表达式){语句体}; true 执行语句体，false 不执行语句体 单分支
2.if(关系表达式){语句体1} else{语句体2}; true 执行语句体1，false 不执行语句体2 双分支
3.if(关系表达式1){语句体1}
else if(关系表达式2){语句体2}
else if(关系表达式3){语句体3}
else if(关系表达式4){语句体4}
...
else{语句块n};
关系表达式为true 执行该语句体，false 不执行该语句体
*/
// 1 单分支
int a = 10;
int b = 20;
if(a == b)
{
System.out.println("a=b");
}
// 2 双分支
// 奇偶数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = sc.nextInt();
if(number % 2 == 0)
{
System.out.println(number + "为偶数");
}
else{
System.out.println(number + "为奇数");
}
// 3 多分支
// 星期几
Scanner sc1 = new Scanner(System.in);
System.out.println("请输入一个星期数（1-7）");
int day = sc1.nextInt();
if(day == 1)
{
System.out.println("星期一");
}
else if(day == 2)
{
System.out.println("星期二");
}
else if(day == 3)
{
System.out.println("星期三");
}
else if(day == 4)
{
System.out.println("星期四");
}
else if(day == 5)
{
System.out.println("星期五");
}
else if(day == 6)
{
System.out.println("星期六");
}
else if(day == 7)
{
System.out.println("星期天");
}
// 成绩
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
Scanner sc2 = new Scanner(System.in);
System.out.println("请输入成绩：");
// 接收数据
int score = sc2.nextInt();
// 逻辑判断
// 正确数据 边界数据 错误数据 保证程序的健壮性
if(score > 100 && score < 0)
{
System.out.println("你输入的数据有误");
}
else if(score >= 95)
{
System.out.println("山地自行车一辆");
}
else if(score >= 90)
{
System.out.println("游乐场一次");
}
else if(score >= 80)
{
System.out.println("变形金刚玩具一个");
}
else{
System.out.println("胖揍一顿");
}
}
}
switch 语句
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
/*
switch 语句
switch(表达式)
{
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
[break;]
}
表达式：取值可以是byte，short，int，char，jdk5新增枚举，jdk7新增String
case：后面跟的是要与表达式进行比较的值
break：表示中断，结束的意思，用来结束switch语句
default：表示所有情况都不匹配的时候，就执行该处的内容
*/
// 键盘录入一个星期数，输出对应的星期一...
// 创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数");
// 接收数据
int day = sc.nextInt();
// 逻辑判断
switch(day){
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;
default:
System.out.println("你输入的星期数有误");
break;
}
}
}import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
/*
case穿透：case控制的语句体后面不屑break，将出现穿透现象，在不判断下一个case值的情况下，向下运行直到遇见break，或者整体switch遇语句结束
*/
// 键盘录入一个月份数，输出对应的季节...
// 创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份");
// 接收数据
int day = sc.nextInt();
// 逻辑判断
switch(day){
case 12:
case 1:
case 2:
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("你输入的月份有误");
}
}
}
正确值，边界值，错误值，保证程序的健壮性
-
循环结构
初始化语句：用于表示循环开启时的起始状态
条件判断语句：用于表示循环反复执行的条件
循环体语句：用于表示循环反复执行的内容
条件控制语句：用于表示循环执行中每次变化的内容
-
for 循环语句
public class HelloWorld{
public static void main(String[] args){
/*
for 循环语句
for(初始化语句;条件判断语句;条件控制语句)
{
循环体语句;
}
*/
// 需求：在控制台输出五次 HelloWorld
for(int i = 0; i < 5; i++)
{
System.out.println("HelloWorld");
}
// 需求：输出1-5和5-1的数据
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);
}
// 需求：求1-5之间的数据和，并把求和结果在控制台输出
int sum = 0;
for(int i = 1; i <= 5; i++)
{
sum+=i;
}
System.out.println(sum);
// 需求：求1-100之间的偶数和，并把求和结果在控制台输出
int sum1 = 0;
for(int i = 1; i <= 100; i++)
{
if(i % 2 == 0){
sum1+=i;
}
}
System.out.println(sum1);
// 需求：在控制台输出所有的水仙花数
// 水仙花数是一个三位数，水仙花数的个位、十位、百位的数字立方和等于原数
// 最高位整除，最低位则取余
// 求任意数在指定位上的数：先使用整数操作将要求的数字移动到个位上，再使用取余操作取出最后一位上的值
for(int i = 100; i <= 999; i++)
{
int x = i % 10; // 个位
int y = i / 10 % 10; // 十位
int z = i / 100;
int sum2 = x * x * x + y * y * y + z * z * z;
if(sum2 == i)
{
System.out.println(i);
}
}
// 需求：统计水仙花数一共有多少个，并在控制台输出个数
int count = 0;
for(int i = 100; i <= 999; i++)
{
int x = i % 10; // 个位
int y = i / 10 % 10; // 十位
int z = i / 100;
int sum2 = x * x * x + y * y * y + z * z * z;
if(sum2 == i)
{
count++;
System.out.println(i);
}
}
System.out.println(count);
}
}-
while 循环语句
public class HelloWorld{
public static void main(String[] args){
/*
while 循环语句
初始化语句;
while(条件判断语句)
{
循环体语句;
条件控制语句
}
*/
// 需求：在控制台输出五次HelloWorld
int i = 0;
while(i < 5)
{
System.out.println("HelloWorld");
i++;
}
// 需求：世界最高山峰是珠穆朗玛峰8844430毫米，假如我有一张足够大的纸，它的厚度是0.1毫米，请问我折叠多少次到达珠穆朗玛峰的高度
double h = 0.1;
int count = 0;
while(h <= 8844430)
{
count++;
h*=2;
}
System.out.println(count);
// 需求：
}
}-
do…while 循环语句
public class HelloWorld{
public static void main(String[] args){
/*
do...while 循环语句
初始化语句;
do
{
循环体语句;
条件控制语句;
}while(条件控制语句);
*/
// 需求：在控制台输出五次HelloWorld
int i = 0;
do{
System.out.println("HelloWorld");
i++;
}while(i < 5);
}
}-
三种循环的区别
-
do…while 至少执行一次
-
for 初始化量与while、do…while初始化变量的使用范围不同
-
死循环 for(;;){}、while(true){}、do{}while(true)
-
命令提示窗口 CTRL+C 结束死循环
-
-
跳转控制语句
-
contiune：跳过某次循环体内容的执行，使用基于条件控制
-
break：终止循环体内容的执行，使用基于条件控制
public class HelloWorld{
public static void main(String[] args){
/*
跳转控制语句
contiune：跳过某次循环体内容的执行，使用基于条件控制
break：终止循环体内容的执行，使用基于条件控制
*/
for(int i = 1; i <= 5; i++)
{
if(i % 2 ==0)
{
// continue;
break;
}
System.out.println(i);
}
}
}
循环嵌套
public class HelloWorld{
public static void main(String[] args){
/*
循环嵌套
*/
// 需求：在控制台输出一天的小时和分钟
for(int i = 1; i < 13; i++)
{
for(int j = 0; j < 61; j++)
{
System.out.println(i + "时" + j + "分");
}
}
}
}
Random
-
Random 用于产生一个随机数
-
导包 import java.util.Random;
-
创建对象 Random r = new Random();
-
获取随机数 int number = r.nextInt(10); 取值范围：[0,10) 包括0不包括10
import java.util.Random;
import java.util.Scanner;
public class HelloWorld{
public static void main(String[] args){
/*
Random 用于产生一个随机数
1.导包 import java.util.Random;
2.创建对象 Random r = new Random();
3.获取随机数 int number = r.nextInt(10); 取值范围：[0,10) 包括0不包括10
*/
// 创建对象
Random r = new Random();
// 获取随机数
int number = r.nextInt(10);
// 输出
System.out.println(number);
// 需求：用循环获取十个随机数,取值范围0-100
for(int i = 0;i < 10; i++)
{
System.out.println(r.nextInt(101));
}
// 需求：猜数字
int number1 = r.nextInt(101);
Scanner s = new Scanner(System.in);
while(true){
System.out.println("请输入一个整数");
int number2 = s.nextInt();
if(number1 > number2)
{
System.out.println("猜小了");
}
else if(number1 < number2)
{
System.out.println("猜大了");
}
else{
System.out.println("猜对了");
break;
}
}
}
}
idea HelloWorld 步骤
创建一个空项目 JavaSe_Code
创建一个新模块 idea_test
在idea_test模块下的src下创建一个包 com.itheima
在com.itheima包下创建一个类 HelloWorld
在HelloWorld类中编写代码
在idea中执行程序
idea 项目结构
项目Project
模块Module
包Package
类Class
idea 内容辅助键和快捷键
快速生成
psvm main
sout 输出
内容辅助键
Ctrl + Alt + Space
快捷键
注释 单行注释 Ctrl + / 多行注释 Ctrl + Shift + /
格式化 Ctrl + Alt + L
idea 模块操作
新建模块
删除模块
导入模块
Base03
数组
package com.itheima;
public class ArrayDemo {
/*
数组：用于存储多个相同类型数据的存储模型
数组定义：
1.数据类型[] 数组名 推荐使用 定义了一个int类型的数组，数组名为~
2.数据类型 数组名[] 定义了一个int类型的变量，变量名是~的数组
数组初始化：
1.动态初始化：只指定数组的长度，由系统为数组分配初始值 数据类型[] 变量名 = new 数据类型[数组长度] 范例：int[] arr = new int[3];
2.数组在初始化时，会为存储空间添加默认值，整数默认值0，浮点数默认值0.0，布尔默认值false，字符默认值空字符，引用数据类型默认值null
3.静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度 数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3...} -> 数据类型[] 变量名 = {数据1，数据2，数据3...}
数组元素访问：
1.数组变量访问方式： 格式：数组名
2.数组内部保存的数据的访问方式：格式：数组名[索引/下标] 索引/下标：是数组中数据的编号方式，从0开始，连续且逐一增加
数组操作常见问题：
1.索引/下标越界：访问了数组中不存在的索引/下标对应元素
2.空指针异常：访问数组已经不再指向堆内存的数据
3.null：空指，一引用数据类型的默认值，表示不指向任何有效对象
数组常见操作：
1.遍历 数组名.length
2.获取最值
*/
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr); // [I@1b6d3586 地址
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("----------");
// 索引下标越界
// System.out.println(arr[3]);
// 遍历
for(int i = 0; i < arr.length; i++)
{
System.out.println(arr[i]);
}
System.out.println("----------");
int[] arr01 = {1,2,3};
System.out.println(arr01); // [I@1b6d3586 地址
System.out.println(arr01[0]);
System.out.println(arr01[1]);
System.out.println(arr01[2]);
System.out.println("----------");
// 遍历
for(int i = 0; i < arr01.length; i++)
{
System.out.println(arr01[i]);
}
System.out.println("----------");
// 空指针异常
// arr01 = null;
// System.out.println(arr01[0]);
// 获取最值
int max = arr01[0];
for(int i = 1; i < arr01.length; i++)
{
max = max > arr01[i] ? max : arr01[i];
}
System.out.println("最大值:" + max);
}
}
方法
package com.itheima;
public class myMethod {
/*
方法：具有独立功能的代码块组织成一个整体，使其具有特殊功能的代码集，方法定义后才能进行方法调用
方法的定义：public static void 方法名(){方法体}
方法的调用：方法名()；
带参数方法的定义和调用：
1.定义：public static void 方法名（参数(数据类型 变量名)）{方法体} 参数可单个也可多个，参数数量类型与变量名不可少，且多个参数之间用,分隔
2.调用：方法名(参数(变量名/常量值)); 参数的数量与类型必须与方法中的设置相匹配
形参和实参：
1.形参：方法定义中的参数
2.实参：方法调用中的参数
带返回值方法的定义和调用
1.定义：public static 数据类型 方法名(参数){ ... return 数据} 返回值必须与方法定义上的数据类型匹配
2.调用：数据类型 变量名 = 方法(参数)； 方法的返回值通常会使用变量接收，否则返回值无意义
方法的注意事项：
1.方法不能嵌套定义，方法之间为平级关系
2.void表示无返回值，可以省略return，也可以单独书写return;，后面不加数据
方法的通用格式：public static 返回值类型 方法名(参数){方法体；return [数据];}
*/
public static void main(String[] args) {
// 调用方法
isEvenNumber();
getMax();
System.out.println("----------");
// 带参数方法的调用
int x = 30;
int a = 50;
int b = 60;
// 变量名传参调用
isEvenNumber01(x);
getMax01(a,b);
System.out.println("----------");
// 常量值传参调用
isEvenNumber01(40);
getMax01(70,80);
System.out.println("----------");
// 带参数与返回值方法的调用
boolean res = isEvenNumber02(10);
System.out.println(res);
System.out.println("----------");
// 带参数与返回值方法的调用
int res01 = getMax02(a,b);
System.out.println(res01);
System.out.println(getMax02(a,b));
System.out.println("----------");
}
// 需求：定义一个方法，在方法中定义一个变量，判断该数据是否为偶数
public static void isEvenNumber(){
// 定义变量
int number = 10;
// 判断该数据是否为偶数
if(number % 2 == 0)
{
System.out.println(true);
} else{
System.out.println(false);
}
}
// 需求：设计一个方法用于打印两个数中的较大数
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 isEvenNumber01(int number)
{
// 判断该数据是否为偶数
if(number % 2