JavaSE 03 方法入门、判断语句（if）、选择语句（switch）、循环（for、while）

第六章 方法入门

6.1 概述

为每个运算符单独的穿件一个新的类和main方法，我们发现这样编写代码非常的繁琐，而且重复的代码太多。要避免这些重复的代码，就需要使用方法来实现。

• 方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样既实现了代码的复用性，也解决了代码冗(rǒng)余的现象。

6.2 方法的定义

• 方法格式：

修饰符 返回值类型 方法名(参数列表) {
代码...
return;
}

public static void() {
方法体
}

• 定义格式解释： 方法名称的命名规则和变量一样，使用小驼峰。
• 方法体：就是大括号当中可以包含任意条语句。

注意：

方法定义的先后顺序无所谓。

方法的定义不能产生嵌套包含的关系。

方法定义好了之后，不会执行。如果想要执行，一定要进行方法的调用。

public class niu {
public static void main(string[] args) {

}

//定义方法a、b
public static void a() {
System.out.println("A");
}

public static void b() {
System.out.println("B");
}
}

6.3 方法的调用

• 格式：方法名称();

public class niu {
public static void main(string[] args) {
a();	//方法调用
}

public static void a() {	//方法a
System.out.println("A");
}
}

Jshell （JDK9后版本才有）

• 用于简易的开发，可以一次输入一个程序元素，立即查看结果，并根据需要进行调整。
• 运行方法
  启动CMD

jshell	//启动
/exit	//退出
/*
以详细模式启动JShell
jshell -v
*/

• 其他详细介绍参考

第七章 流程控制

• 在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

7.1 顺序结构

• 顺序执行，根据编写的顺序从上到下运行。

7.2 判断语句

7.2.1 if

1.if

• 格式：

if(关系表达式) {
语句体;
}

• 执行流程 首先判断关系表达式看其结果是true还是false
• 如果是true就执行语句体
• 如果是false就不执行语句体

2.if…else 标准的

• 格式：

if(关系表达式) {
语句体1;
} else {
语句体2;
}

• 执行流程 首先判断关系表达式看其结果是true还是false
• 如果是true就执行语句体1
• 如果是false就执行语句体2

3.if…else if…else 复合的扩展的

• 格式：

if (判断条件1) {
语句体1;
} else if (判断条件2) {
语句体2;
} ...
} else if (判断条件n) {
执行语句n;
} else {
执行语句n+1;
}

• 执行流程 首先判断关系表达式1看其结果是true还是false
• 如果是true就执行语句体1
• 如果是false就继续判断关系表达式2看其结果是true还是false
• 如果是true就执行语句体2
• 如果是false就继续判断关系表达式…看其结果是true还是false
• …

4. 用if语句替换三元运算符

int a = 10;
int b = 20;
int max = a > b ? a : b;

//用if-else语句实现
if (a > b) {
max = a ;
} else {
max = b;
}

7.3 选择语句

7.3.1 switch

• 格式：

switch (表达式) { 	//表达式也叫被检测量
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
default:
语句体n+1;
break;	//可以省略此break，但是不推荐这么做
}

• 执行流程：(匹配哪一个case就从哪一个位置向下执行，知道遇到了break或者整体结束为止) 首先计算出表达式的值。
• 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，遇到break就会结束。
• 最后，如果有的case都和表达式的值不匹配，就会执行default语句部分，然后程序结束。

7.3.2 case的穿透性

• 注意：

1. 多个case后的数值不可以重复。
2. switch后面小括号当中只能是以下数据类型：
   基本数据类型：byte/short/char/int
   引用数据类型：String字符串、enum枚举
3. switch语句格式可以很灵活；前后顺序可以颠倒；而且break语句还可以省略，直到遇到了下一个break或者整体结束才停止。

7.4循环语句

7.4.1 循环概述

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

7.4.2 for

• 格式：

for (初始化表达式①;布尔值表达式②；步进表达式③) {
循环体④
}

• 执行流程： 执行顺序：①②③④>②③④>②③④…②不满足为止。
• ①负责完成循环变量初始化。（在循环开始最初执行，只做唯一一次）
• ②负责判断是否满足循环条件，不满足则跳出循环。
• ③具体执行语句。（每次循环之后都要进行的扫尾工作）
• ④循环后，循环条件所涉及变量的变化情况（重复要做的内容）

实例：

for (int i = 1; i <= 100; i++) {
System.out.println("abc");
}

7.4.3 while

• 格式：

1. 标准格式：

while (布尔表达式) {
循环体
}

1. 扩展格式：

初始化表达式①
while (布尔表达式②) {
循环体③
步进表达式④
}

• 执行流程： ①②③④>②③④>②③④…②不满足为止。
• ①负责完成循环变量初始化。
• ②负责判断是否满足循环条件，不满足则跳出循环。
• ③具体执行语句。（每次循环之后都要进行的扫尾工作）
• ④循环后，循环条件所涉及变量的变化情况（重复要做的内容）

实例：

int i = 1;
while (i <= 100) {
System.out.println("abc");
i++;
}

7.4.4 do…while

• do…while与if、while的区别，无条件先执行一次循环体。
• 格式：

1. 标准格式：

do {
循环体
} while (布尔表达式);

1. 扩展格式：

初始化表达式①
do {
循环体③
步进表达式④
} while (布尔表达式②);

• 执行流程： ①③④>②③④>②③④…②不满足为止。
• ①负责完成循环变量初始化。
• ②负责判断是否满足循环条件，不满足则跳出循环。
• ③具体执行语句。（每次循环之后都要进行的扫尾工作）
• ④循环后，循环条件所涉及变量的变化情况（重复要做的内容）

实例：

int i = 1;
do {
System.out.println("abc");
i++;
} while (i <= 100);

7.4.5 循环语句的区别

1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do…while循环会至少执行一次。
2. for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do…while循环的初始化语句本来就在外面，所以出循环之后还可以继续使用。

7.4.6 跳出语句

• break关键字 可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
• 还可以用在循环语句当中，整个循环语句立刻结束。

for (int i  = 1; i <= 10; i++) {
if(i == 4){	//程序执行3次后打断
break;
}
System.out.println("abc" + i);	//i只输出到3
}

• continue关键字
  一旦执行，立刻跳过当次循环剩余内容，马上开始下一次循环。

for (int i  = 1; i <= 5; i++) {
if(i == 4){	//程序执行到第4次时将跳过
continue;
}
System.out.println("abc" + i);	//i只输出1-3、5
}

• 关于循环的选择：（建议） 凡是次数确定的场景多用for循环；否则多用while循环。

7.4.7 死循环

永远停不下来的循环，叫做死循环。

• 在cmd中要强制停止程序用快捷键Ctrl+C
• 死循环的标准格式：

while(true){
循环体;
}

7.4.8 嵌套循环

• 所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for，就是嵌套循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
• 格式：

for(初始表达式①;循环条件②;步进表达式⑦) {
for(初始表达式③;循环条件④;步进表达式⑥){
执行语句⑤;
}
}

• 执行流程： 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
• 外循环一次，内循环多次。
• 比如做运动：一共做5组，每组10个。5组就是外循环，10个就是内循环。

实例：

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 + "秒");
}
}
}

第八章 定义方法

• 方法其实就是若干语句的功能集合。

  方法好比一个工厂
• 举例：
  蒙牛工厂 参数：原料：奶牛、饲料、水
  返回值：产出物：奶制品

参数：就是进入方法的数据

返回值：就是从方法中出来的数据

8.1 定义方法的完整格式

/*
修饰符 返回值类型 方法名称(参数类型 参数名称,...) {
方法体
return 返回值;
}
*/

修饰符：现阶段固定写法，public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
PS：参数如果有多个，使用逗号进行分隔
方法体：方法需要做的事情，若干行代码
return：两个作用，第一停止当前方法；第二将后面的返回值还给调用处。
返回值：也就是方法执行后最终产生的数据结果

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。

8.2 方法调用的三种方式

8.2.1 单独调用

//格式：方法名称(参数);
sum( a:10, b:20);

8.2.2 打印调用

//格式：System.out.println(方法名称(参数));
System.out.println(sum( a:10, b:20));

8.2.3 赋值调用

//格式：数据类型 变量名称 = 方法名称(参数);
int num = sum( a:10, b:20);

注意：此前学习的方法，返回值类型固定写为void，这种方法只能单独调用，不能进行打印调用和赋值调用。

8.3 参数 Parameter

8.3.1 方法有参数

小括号中有内容。当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。例如两个数字相加，必须知道两个数字是各自多少，才能相加。

public class Demo {

public static void main(Sting[] args) {
System.out.println(method( a:10, b:20));
}

public static void method(int a, int b) {
int result = a * b;
}
}

8.3.2 方法无参数

小括号留空。一个方法不需要任何数据的，自己就能独立完成任务，就是无参数。

public class Demo {

public static void main(Sting[] args) {
method();
}

public static void method() {
for (int i = 0; i < 5; i++) {
System.out.println("test" + i);
}
}
}

8.4 返回值 Return

8.4.1 有返回值

/*
定义一个方法，用来==求出==两个数字之和。（方法来计算，算完把结果告诉我，我来显示。）
*/
public class Demo {

public static void main(Sting[] args) {
int num = getSum( a: 10, b: 20);
System.out.println(num);
}

public static int getSum(int a; int b) {
int result = a + b;
return result;
}
}

8.4.2 无返回值

/*
定义一个方法，用来==打印==两个数字之和。（方法来计算，算完之后自己负责显示结果。）
*/
public class Demo {

public static void main(Sting[] args) {
printSum( a: 10, b: 20);
}

public static void printSum(int a; int b) {
int result = a + b;
System.out.println(result);
}
}

**注意：**对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。但是对于无返回值得方法只能使用单独调用。

8.5 练习

1. 定义一个方法，用来判断两个数字是否相同。

public class Demo {
public static void main(String[] args) {
System.out.println(isSame( a: 10, b: 20));
}

pubilc static boolean isSame(int a, int b) {
/*
方法1：
boolean same = a == b ? true : false;
return same;
*/
/*
方法2：
boolean same = a == b；
return same;
*/
/*
方法3：
boolean same;
if (a == b) {
same = true;
} else {
same = false;
}
return same;
*/
//方法4:
return a == b;
}

}

1. 定义一个方法用来求a、b之间所有数字之和。

pubilc class Demo {

public static void main(String[] args) {
System.out.println("结果是：" + getSum( a: 1, b: 100));
}

public static int getSum(int a, int b) {
int sum = 0;
for (int i = a; i <= b; i++) {
sum += i;
}
return sum;
}

}

1. 定义一个方法，用来打印指定次数的HelloWorld。

pubilc class Demo {

public static void main(String[] args) {
printCount( num: 100);
}

public static viod printCount(int num) {
for(int i = 0; i <= num; i++) {
System.out.println("HelloWorld" + (i + 1));
}
}

}

8.6 使用方法的注意事项

1. 方法应该定义在类当中，但是不能再方法中再定义方法。
2. 方法定义的前后顺序无所谓。
3. 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
4. 如果方法有返回值，那么必须写上“return 返回值;”。
5. return后的返回值类型必须和方法的返回值类型对应起来。
6. 对于一个void没有返回值的方法，只能写return。
7. 对于方法最后一行没有返回值的return可以省略不写。
8. 一个方法可以有多个return，但是必须保证同时只有一个会被执行。

8.7 方法重载 Overload

8.7.1 基本使用

对于功能类似的方法，因为参数不同，却要记住那么多不同的变量名称，于是引入了方法重载。

• 方法名称相同，方法的内容不同。调用时根据参数来自动识别。

public class Demo {
public static void main(String[] args) {
sum( a: 10, b: 20);	/根据参数会自动识别用哪个方法
}

public static int sum(int a, int b) {
return a + b;
}

public static int sum(int a, int b, int c) {
return a + b + c;
}

public static int sum(int a, int b, int c, int d) {
return a + b + c + d;
}

}

• 注意事项：
• （方法重载与下列因素有关）

1. 参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同

public static int sum(int a, double b) {
return (int) (a + b);
}

public static int sum(double a, int b) {
return (int) (a + b);
}

• （方法重载与下列因素无关）

1. 与参数的名称无关

/*
public static int sum(int x, double y) {
return x + y;
}

public static int sum(int a, int b) {
return a + b;
}
*/

1. 与方法的返回值类型无关

/*
public static int sum(int a, int b) {
return a + b;
}

public static double sum(int a, int b) {
return a + b + 0.0;
}
*/

8.7.2 重载练习

1.分别比较两个byte、short、int、long类型大小

public class Demo {
public static void main(String[] args) {
System.out.println(isSame((byte) 10, (byte) 20));
System.out.println(isSame((short) 10, (short) 20));
System.out.println(isSame( a: 10, b: 20));
System.out.println(isSame( a: 10L, b: 20L);
}

public static boolean isSame(byte a, byte b) {
return a = b;
}

public static boolean isSame(short a, short b) {
return a = b;
}

public static boolean isSame(int a, int b) {
return a = b;
}

public static boolean isSame(long a, long b) {
return a = b;
}

}

• 点赞
• 收藏
• 分享
• 文章举报

Niiuu 发布了13 篇原创文章 · 获赞 0 · 访问量 206 私信 关注