欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

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

程序员文章站 2022-07-15 07:53:40
...

第六章 方法入门

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

}
相关标签： Java

上一篇： Python 基本数据类型之【格式化问题】

下一篇： python3 format()格式化函数

推荐阅读