定义一个方法的格式：
public static void 方法名称() {
方法体
}
方法名称的命名规则和变量一样，使用小驼峰
方法体：大括号当中可以包含任意条语句
注意事项：
1. 方法定义的先后顺序无所谓。
2. 方法的定义不能产生嵌套包含关系。
3. 方法定义好了之后，不会执行的。如果要执行，一定要进行方法的【调用】。例如下文需在main方法中调用方法
如何调用方法，格式：
方法名称（）；
先把握整体，然后再细看局部。这就是方法带给我们更好的实践。
接下来是代码实现，助于理解：
public class Demo11Method {
public static void main(String[] args) {
farmer();// 调用农民的方法
seller();// 调用小商贩的方法
cook();// 调用厨子的方法
me();// 调用我的方法
}
// 农民伯伯
public static void farmer() {
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");
}
// 小商贩
public static void seller() {
System.out.println("运输到农贸市场");
System.out.println("抬高价格");
System.out.println("吆喝");
System.out.println("卖给厨子");
}
// 厨子
public static void cook() {
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");
}
// 我
public static void me() {
System.out.println("吃");
}
}
10.一些补充
对于byte、short、char，如果右侧赋值的数值没有超过范围
那么javac编译器将会自动隐含地为我们补上一个（byte）（short）（char）
1. 如果没超有过左侧的范围，编译器补上强转
2. 如果右侧超过了左侧范围，那么直接编译器报错
接下来是代码实现，助于理解：
public class Demo12Notice {
public static void main(String[] args) {
// 右侧确实是一个int类型，但是没有超过左侧的范围，就是正确的
// int --> byte，不是自动类型转换
byte num1 = 30;
System.out.println(num1);
//byte num2 = 128;// 右侧超过了左侧的范围，
// int --> char ,没有超过范围
//编译器将会主动补上一个隐含的（char）
char zifu = 65;
System.out.println(zifu);// A
}
}
在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量
那么编译器javac将会直接将若干个常量表达式计算得到结果
short result = 5 + 8;// 等号右边全是常量
编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result = 13;
右侧的常量结果数值，没有超过左侧范围，所以正确。
这称为编译器的常量优化
但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了
接下来是代码实现，助于理解：
public class Demo13Notice {
public static void main(String[] args) {
short num1 = 10;// 正确写法，右侧没有超过左侧范围，
short a = 5;
short b = 8;
// short + short --> int + int --> int
//short result = a + b;// 错误写法！左侧需要是int类型
// 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
short result = 5 + 8;
System.out.println(result);
short result2 = 5 + a + 8;//有变量参与因此无法进行常量优化！
System.out.println(result2);
}
}
11.结构
11.1顺序结构
Java的基本结构就是顺序结构，除非特别指明，否则就按照由上到下的顺序一句一句的执行。
顺序结构是最简单的算法结构。
11.2选择结构 11.2.1 if单选择结构判断if（），若为true则执行if的语句体，若为false则不执行if的语句体
接下来是代码实现，助于理解：
public class Demo15if {
public static void main(String[] args){
System.out.println("今天天气不错，正在压马路...突然发现一个快乐的地方：网吧");
int age = 19;
if (age >= 18) {
System.out.println("进入网吧，开始high");
System.out.println("遇到了一群猪队友，开始骂街");
System.out.println("感觉不爽，结账走人");
}
System.out.println("回家吃饭");
}
}
11.2.2 if双选择结构
在程序实际开发场景中，会有很多类似：判断某一个东西可行然后执行一些代码，否则执行另一段代码。
接下来是代码实现，助于理解：
public class Demo16ifElese {
public static void main(String[] args) {
int num = 13;
if (num % 2 == 0) { // 如果取模为0，说明是偶数
System.out.println("偶数");
} else {
System.out.println("奇数");
}
}
}
11.2.3 多重选择结构
比双选择if结构更复杂的业务场景，就要用到嵌套的if结构，比如：不断地判断某个东西是否符合条件，判断符合就执行对应的处理方法。
if else-if else-if ... else
接下来是代码实现，助于理解：
public class Demo17IfElseExt {
public static void main(String[] args) {
int x = 10;
int y;
if (x >= 3){
y = 2 * x + 1;
} else if (-1 < x && x < 3) {
y = 2 * x;
} else {
y = 2 * x - 1;
}
System.out.println("结果是" + y);
}
}
11.2.4 练习1
指定考试成绩，判断成绩的等级。
90-100 -->优秀，80-89-->好，70-79-->良好，60-69-->及格，60以下不及格
public class Demo18IfElsePractise {
public static void main(String[] args) {
int score = 25;
if (score < 0 || score > 100) {
System.out.println("你的成绩是错误的");
} else if (score > 90) {
System.out.println("你的成绩属于优秀");
} else if (score > 80) {
System.out.println("你的成绩属于好");
} else if (score > 70) {
System.out.println("你的成绩属于良好");
} else if (score > 60) {
System.out.println("你的成绩属于及格");
} else {
System.out.println("你的成绩属于不及格");
}
}
}
11.2.5练习2
使用三元运算符和标准的if-else分别实现：取两个数字当中的最大值
public class Demo19Max {
public static void main(String[] args) {
int a = 52;
int b = 20;
// 使用三元运算符
//int max = a > b ? a : b ;
// 使用if语句
int max;
if (a > b) {
max = a;
} else {
max = b;
}
System.out.println("最大值是" + max);
}
}
11.3switch选择结构
switch选择结构的格式：
public class Demo20 {
public static void main(String[] args) {
switch (表达式) {
case 常量值1:
语句体;
break;
case 常量值2:
语句体;
break;
...
default:
语句体n+1;
break;
}
}
}
接下来使用代码实现，助于理解：
public class Demo20Switch {
public static void main(String[] args) {
int num = 1;
switch (num) {
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;// 最后一个break语句可以省略，但不推荐省略
}
}
}
使用switch选择结构的注意事项：
switch语句使用的注意事项：
1. 多个case后面的数值不可以重复
2. switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
其他的都不行！！！
3. switch语句格式可以很灵活:前后顺序可以颠倒，而且break语句可以省略
--> case 之间的位置可以进行互换，并无影响
匹配到哪一个case就从哪一个位置向下执行，直到遇到了break或整体结束才会停止-->break省略后会向下穿透，经过其他case
接下来用代码实现，助于理解：
public class Demo21SwitchNotice {
public static void main(String[] args) {
int num = 2;
switch (num) {
case 1:
System.out.println("AAA");
break;
case 2:
System.out.println("BBB");
//break;
case 3:
System.out.println("CCC");
break;
default:
System.out.println("DDD");
break;
}
}
}
12.循环
12.1 for循环
for循环结构的基本组成部分，一般可以分成四部分：
1. 初始化语句：在循环开始最初执行，而且只做唯一一次
2. 条件判断： 如果成立，则循环继续；如果不成立，则循环退出
3. 循环体： 重复要做的事情内容，若干行语句
4. 步进语句： 每次循环之后都要进行的扫尾工作-->每次循环结束之后都要执行一次forf
for循环语句格式：
for（初始化表达式①；布尔表达式②；步进表达式④） {
循环体③
}
首先执行①初始化表达式，然后②布尔表达式，若为true，立刻进入大括号执行③循环体，然后④步进表达式，
之后重新回到②布尔表达式进行判断，若为true，则往复，直到布尔表达式为false，则结束。
接下来用代码实现，助于理解：
public class Demo22For {
public static void main(String[] args) {
for (int i = 1; i <= 100; i += 1) {
System.out.println("我错了！" + 1);
}
System.out.println("程序停止");
}
}
12.2 while循环
while循环有一个标准格式、一个扩展格式
标准格式：
while (条件判断){
循环体
}
扩展格式：
初始化语句;
while (条件判断) {
循环体;
步进语句;
}
接下来用代码实现，助于理解：
public class Demo23While {
public static void main(String[] args) {
int i = 1;
while (i <= 100) {
System.out.println("我错啦" + i);
i += 1;
}
}
}
12.3 do-while循环
do-while循环的标准格式：
do {
循环体
} while (条件判断);
无条件执行一次循环体，然后再进行条件判断
扩展格式：
初始化语句
do {
循环体
步进语句
} while （条件判断）;
接下来用代码实现，助于理解：
public class Demo24DoWhile {
public static void main(String[] args) {
int i = 1;
do {
System.out.println("我错啦" + i);
i += 1;
} while (i <= 100);
}
}
12.4 practice 求出1-100内偶数的和
思路：“
1. 既然范围已经确定了是1到100之间，那么晚我就从1、2、3...一直到100这么多数字一个一个进行检查
2. 总共有100哥数字，并非所有数字都能用，必须是偶数才能用，判断（if语句） 偶数： num % 2 == 0
3. 需要一个变量，用来进行累加 *** 作，也就好比是一个存钱罐
接下来分别用for循环、while循环、do-while循环
12.4.1 for循环public class Demo25practice1 {
public static void main(String[] args) {
int sum = 0;// 用来累加的存钱罐-->进行累加 *** 作的变量
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0){
sum += i;
}
}
System.out.println("结果是" + sum);
}
}
12.4.2 while循环
public class Demo25practice2 {
public static void main(String[] args) {
int sum = 0;
int i = 1;
while (i <= 100) {
if (i % 2 == 0){
sum += i;
}
i++;
}
System.out.println("结果是" + sum);
}
}
12.4.3 do-while循环
public class Demo25practice3 {
public static void main(String[] args) {
int sum = 0;
int i = 1;
do {
if (i % 2 == 0){
sum += i;
}
i++;
} while (i <= 100);
System.out.println("结果是" + sum);
}
}
12.5区别
1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但do-while循环会至少执行一次
2. for循环的变量在小括号中定义的话，只有循环内部才可以使用。
而while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用
接下来用代码实现，助于理解：
public class Demo26Difference {
public static void main(String[] args) {
for (int i = 1; i < 0; i += 1) {
System.out.println("Hello");
}
//System.out.println(i);//这一行是错误写法，因为变量i定义在for循环小括号内，只有for循环自己才能使用
System.out.println("====================");
int i = 1;
do {
System.out.println("World");
i += 1;
}while (i < 0);
}
}
12.6 break关键字
break关键字的用法有常见的两种：
1. 可以用在switch语句当中，一旦执行，整个switch语句立刻结束
2. 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环
关于循环的选择，有一个小建议：
凡是次数确定的场景多用for循环；否则多用while循环，；do-while使用较少
接下来用代码实现，助于理解：
public class Demo27Break {
public static void main(String[] args) {
for (int i = 1; i <= 10; i +=1) {
// 如果希望从第四次开始，后续全都不要了，就要打断循环
if (i == 4) {// 如果当前是第四次
break;//那么就打断整个循环
}
System.out.println("Hello" + i);
}
}
}
12.7 continue关键字
另一种循环控制语句是continue关键字
一旦执行，立刻跳过当前次循环剩余内容，马上进行下一次循环
接下来用代码实现，助于理解：
public class Demo28Continue {
public static void main(String[] args) {
for (int i = 1; i <= 10; i +=1) {
if (i ==4) {// 如果当前是第四层
continue;// 那么跳过当前循环，马上开始下一次
}
System.out.println(i + "层到了");
}
}
}
12.8 死循环
永远停不下来的循环，叫做死循环
(有情况可能自己需要)死循环的标准格式：
while （true） {
循环体
}
接下来用代码实现，助于理解：
public class Demo29DeadLoop {
public static void main(String[] args) {
while (true){
System.out.println("I Love You");
}
}
}
12.9 循环嵌套
在循环里还有循环。
接下来用代码实现，助于理解：
public class Demo30LoopHourAndMinute {
public static void main(String[] args) {
for (int hour = 0; hour < 24; hour++){ // 外层控制小时
for (int minute = 0; minute < 60; minute++){ // 里层控制小时之内的分钟
for (int second = 0; second < 60; second++){ // 最里面控制分钟之内的秒
System.out.println(hour + "点" + minute + "分" + second + "秒");
}
}
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）