Java流程控制与Java方法相关知识总结分享
站长
· 阅读数 40
前言
本文为Java流程控制与方法相关知识，具体包含用户交互Scanner的使用，Java中的顺序结构，选择结构，循环结构以及Break & Continue；Java方法的定义，使用与重载，以及方法中的可变参数介绍，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
一、Java流程控制
在程序中， 程序运行的流程控制决定程序是如何执行的， 主要有三大流程控制语句：
- 顺序控制
- 分支控制
- 循环控制
1.用户交互Scanner
Scanner对象
首先我们来了解一下Java中的用户交互Scanner对象，通过Scanner类中的next()与nextLine()方法可以获取用户输入的字符串，从而实现与用户的交互。
- 可以通过Scanner类来获取用户输入的内容
- Scanner的基本语法：
通过Scanner类的next()与nextLine()方法获取输入的字符串，
在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
// next()
/*
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
- 只用输入有效字符后才能将其后面输入的空白作为分隔符或者结束符。
- **next()不能得到带有空格的字符串。**
*/
package com.wang.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner=new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if (scanner.hasNext()){
//使用next方式接收
String str=scanner.next();
System.out.println("输出的内容为:"+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源，用完要将其关掉
scanner.close();
}
}
// nextLine():
/*以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白
*/
package com.wang.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner=new Scanner(System.in);
System.out.println("使用nextline方式接收:");
//判断是否还有输入
if (scanner.hasNextLine()){
String str=scanner.nextLine();
System.out.println("输出的内容为:"+str);
}
scanner.close();
}
}
- 代码实例1：
package com.wang.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
//从键盘接收数据
int i=0;
float f=0.0f;
System.out.println("请输入整数：");
if (scanner.hasNextInt()){
i=scanner.nextInt();
System.out.println("整数数据："+i);
}else{
System.out.println("输入的不是整数数据！");
}
System.out.println("请输入小数：");
//如果...那么
if (scanner.hasNextFloat()){
f=scanner.nextFloat();
System.out.println("小数数据："+f);
}else{
System.out.println("输入的不是小数数据！");
}
scanner.close();
}
}
- 代码实例2：
package com.wang.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
/*我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，
通过输入非数字来结束输入并输出执行结果;
*/
Scanner scanner=new Scanner(System.in);
System.out.println("请输入数据：");
//和
double sum=0;
//计算输入了多少个数字
int m=0;
//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while (scanner.hasNextDouble()){
double x=scanner.nextDouble();
m++;
sum+=x;
System.out.println("你输入了第"+ m + "个数据，当前结果sum="+sum);
System.out.println("请继续输入数据：");
}
System.out.println(m+"个数和为"+sum);
System.out.println(m+"个数的平均值为"+(sum/m));
scanner.close();
}
}
2.顺序结构
JAVA的基本结构就是顺序结构，除非特别指明，否则就按顺序一句一句执行。顺序控制就是程序会由上而下，由左及右依次逐行执行，就和我们写文章一样。顺序结构是任何一个算法都不会离开的一种基本算法结构。顺序结构就不需要过多介绍，大家很容易就可以理解。
3.选择结构
选择结构也叫条件分支控制语句。条件是什么，选择了不同的条件就会有不同的结果，比如：
- 打游戏，有一个npc吐血了就还是不就，可能接下来的主线剧情就会发生变化。
- 高考完，成绩不理想选择复读还是独一个差一点的学校你的人生就不一样。分支控制语句做的就是这样的事情。
分支控制语句能让程序有选择的的执行相应的代码，分支控制有三种形式：
- 单分支 if
- 双分支 if ... else...
- 多分支 if ... else if ... else
if单选择结构
先来看一下if单选择结构，语法如下：
if(布尔表达式){
//如果布尔值表达式为true将执行的语句
}
举一个例子：
酒驾的定义：驾驶人员每100毫升血液酒精含量大于或等于20毫克，并每100毫升血液酒精含量小于80毫克为饮酒后驾车。每100毫升血液酒精含量大于或等于80毫克为醉酒驾车。
实现思路：
- 路口站着一个警察叔叔，让你不断的吹气，我们用scanner来代替。
- 把你的酒精含量存入一个变量值中。
- 如果大于20ml，带走，其他人通行。
// 超级明确的告诉你，这一行你超就行了，不用知道为什么
import java.util.Scanner;
public class TestIf {
public static void main(String[] args) {
// 超级明确的告诉你，这一行你超就行了，不用知道为什么
// 知道能让你在黑窗口输入数字就行了
Scanner scanner = new Scanner(System.in);
int alcohol = scanner.nextInt();
if (alcohol >= 20){
System.out.println("被警察叔叔带走了...");
}
System.out.println("继续开车...");
}
}
if双选择结构
if双选择对于if的判断如果失败也会给予相应的处理。
- 语法
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
说实话，其实上边的if单选择结构的例子多少有一些不严谨，我们使用双分支对上边例子的实现进行改造一下：
import java.util.Scanner;
public class TestIf {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int alcohol = scanner.nextInt();
if (alcohol >= 20){
System.out.println("被警察叔叔带走了...");
} else {
System.out.println("继续开车...");
}
}
}
if多选择结构
- 语法
if(布尔表达式1){
//如果布尔表达式1的值为true执行代码
}else if(布尔表达式2){
//如果布尔表达式2的值为true执行代码
}else if(布尔表达式3){
//如果布尔表达式3的值为true执行代码
}else{
//如果布尔表达式的值都为false执行代码
}
还是上边的例子，进行延伸，到了警局里，对抓来的人进行重新校验：
import java.util.Scanner;
public class TestIf {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int alcohol = scanner.nextInt();
if (alcohol >= 80){
System.out.println("兄弟，你这是醉驾...");
} else if(alcohol >= 20){
System.out.println("兄弟，你这是酒驾...");
} else {
System.out.println("不好意思兄弟，抓错了");
}
}
}
对于这个例子有一个小问题值得大家思考一下：alcohol >= 20能放在alcohol >= 80 之前吗？答案当然是不可以的 。我们可以试想这样做的后果会是什么，如果我们将对于alcohol >= 20的判断放在前边的话，那么即便alcohol的值大于等于80，但它又因为同时满足大于等于20的条件，就会被直接判断为酒驾，这显然是不符合逻辑的。
- 因此对于if多选择结构需要注意以下几点： if语句至多有1个else语句，else语句在所有的else if语句之后。 if语句可以有若干个else if语句，它们必须在else语句之前。 一旦其中一个else if语句检测为true,其他的else if以及else语句都将跳过执行。
嵌套的if结构
对于if结构还有比较复杂的嵌套if结构，就是在if判断结构里边还会有另外的if判断，这种判断可能会嵌套很多层。在一个分支结构中又完整的嵌套了另一个完整的分支结构， 里面的分支的结构称为内层分支外面的分支结构称为外层分支。嵌套分支会影响代码的可读性，建议最好不要超过 3 层，你套十层神仙也看不懂了。
- 嵌套的if结构的语法
if(布尔表达式1){
//如果布尔表达式1的值为true执行代码
if(布尔表达式2){
//如果布尔表达式2的值为true执行代码
}
}
举个例子吧：
动物园的门票分淡季旺季，淡季20元，旺季30元，其中（1，代表淡季，2，代表旺季）
- 儿童（0~7）免费
- 学生（8~22）岁半价
- 成人（23~60）不打折
- 老人（>60岁）打三折
代码实现：
package com.wang;
import java.util.Scanner;
public class TestIf {
public static void main(String[] args) {
System.out.println("请输入季节（1，代表淡季，2，代表旺季）：");
Scanner scanner = new Scanner(System.in);
int season = scanner.nextInt();
double ticketPrice1 = 20;
double ticketPrice2 = 30;
if (season == 1){
System.out.println("请输入年龄：");
int age = scanner.nextInt();
if(age > 0 && age <8){
System.out.println("您的票价是：免费");
} else if (age >= 8 && age <=22){
System.out.println("您的票价是：" + (ticketPrice1 * 0.5));
} else if (age >= 23 && age <=60){
System.out.println("您的票价是：" + ticketPrice1);
} else if(age >60 && age <=120){
System.out.println("您的票价是：" + (ticketPrice1 * 0.3));
} else {
System.out.println("您输入的年龄不合法");
}
} else if(season == 2){
System.out.println("请输入年龄：");
int age = scanner.nextInt();
if(age > 0 && age <8){
System.out.println("您的票价是：免费");
} else if (age >= 8 && age <=22){
System.out.println("您的票价是：" + (ticketPrice2 * 0.5));
} else if (age >= 23 && age <=60){
System.out.println("您的票价是：" + ticketPrice2);
} else if(age >60 && age <=120){
System.out.println("您的票价是：" + (ticketPrice2 * 0.3));
} else {
System.out.println("您输入的年龄不合法");
}
}
}
}
switch多选择结构
对于多选择结构，除了使用if语句来实现外，使用switch多选择结构也可以实现同样的作用，而且实现相对来说比if语句更为简单。
- switch case 语句判断一个变量与一系列值中的某个值是否相等，每一个值称为一个分支。
- switch语句中的变量类型可以是：
- byte、short、int或者char
- 从Java SE 7开始 switch支持字符串String类型了
- 同时case标签必须为字符串常量或字面量
- switch多选择结构的语法
switch(expression){
case value:
//语句
break;//可选
case value:
//语句
break;//可选
//可以有任意数量的case语句
default://可选
//
}
- 代码示例
对于成绩等级的判断：A：优秀，B：良好，C:及格，D:再接再厉，E:挂科...要求呢输入一个成绩分数可以判断出它的等级，实现起来还是比较简单的。
package com.wang.structure;
public class SwitchDemo01 {
public static void main(String[] args) {
//case穿透 未加break输出满足该条件以下语句所有可输出内容
// switch匹配一个具体的值
char grade='A';
switch (grade){
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
case 'C':
System.out.println("及格");
break;
case 'D':
System.out.println("再接再厉");
break;
case 'E':
System.out.println("挂科");
break;
default:
System.out.println("未知等级");
}
}
}
以下是switch的执行流程图，可以帮助大家理解。
- switch和if有点像，但凡switch能解决的问题，if也能解决。
- switch后不能是long型，但可以 byte shor int 也可以是String 。
- switch的default只能有一个。
- switch不加break会继续进入下一个判断。
4.循环结构
while循环
- while是最基本的循环，它的结构为：
while(布尔表达式){
//循环内容
}
- 只要布尔表达式为true,循环就会一直执行下去。
- 大多数情况下需要让循环停下来，需要一个让表达式失效的方式来结束循环。
- 少部分情况需要循环一直执行，比如服务器的请求响应监听等。
- 循环条件一直为true就会造成无限循环，其会影响程序性能或者造成程序卡死崩溃，需避免死循环。
- 代码示例：
package com.wang.structure;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1~100
int i=0;
int sum=0;
while(i<100){
i++;
System.out.println(i);
}
//计算1到100的和
int c=0;
while(c<100){
c++;
sum+=c;
}System.out.println(sum);
}
}
do…while循环
- 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
- do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
do{
//代码语句
}while(布尔表达式);
- 代码示例
package com.wang.structure;
public class DoWhileDemo01 {
public static void main(String[] args) {
int i=0;
int sum=0;
do{
sum=sum+i;
i++;
}while(i<=100);
System.out.println(sum);
}
}
While和do-while的区别
- while先判断后执行。do-while先执行后判断
- do-while总是保证循环体被至少执行一次
- 代码示例
package com.wang.structure;
public class DoWhileDemo02 {
public static void main(String[] args) {
int a=0;
while(a<0){
System.out.println(a);
a++;
}
System.out.println("======================================");
do{
System.out.println(a);
a++;
}while(a<0);
}
}
for循环
- for循环可以使一些循环结构变得更简单
- for循环是支持迭代的一种通用格式，是最有效、最灵活的循环结构
- for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化;布尔表达式;更新){
//代码语句
}
- 代码示例：
package com.wang.structure;
public class ForDemo01 {
public static void main(String[] args) {
int a=1;//初始化条件
while(a<=100){//条件判断
System.out.println(a);//循环体
a+=2;//迭代
}
System.out.println("while循环结束！");
// 初始化 //条件判断 //迭代
for (int i=1;i<=100;i++){
System.out.println(i);
}
System.out.println("for循环结束！");
//死循环
for(; ;){}
}
}
来个比较难的 例子吧，打印一下九九乘法表如下：
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
先找规律：
- 两个乘数都是 1到9，共有九行九列。
- 第一行有一个，第二行有两个。
- 第一个乘数都是小于等于第二个乘数。
代码实现：
// 每一个的第一个乘数就是行号
public static void main(String[] args) {
for (int i=1; i<=9; i++){
for (int j=1; j<=9; j++){
if(i >= j){
System.out.print(i+"*"+j+"="+(i*j)+" ");
}
}
System.out.println();
}
}
我们发现，使用循环的话简单几行代码就可以打印出乘法表那么多的内容。
- 关于for循环的几点说明： 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。 然后检测布尔表达式的值。如果为true,循环体被执行。如果为false,循环终止，开始执行循环体后面的语句。 执行一次循环后，更新循环控制变量； 再次检测布尔表达式。循环执行上面的过程。
5.Break & Continue
break
- 在任何循环语句的主体部分，均可用break控制循环流程。break用于强行退出循环，不执行循环中剩余的语句（也在switch语句中使用）
package com.wang.structure;
public class BreakDemo01 {
public static void main(String[] args) {
int i=0;
while (i<100){
i++;
System.out.println(i);
if (i==30){
break;
}
}
System.out.println("123");
}
}
continue
- continue语句用在循环语句体中,用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
package com.wang.structure;
public class ContinueDemo {
public static void main(String[] args) {
for(int i=1;i<100;i++){
if(i%10==0){
System.out.println();
continue;
}
System.out.print(i+"\t");
}
}
}
goto关键字
goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto.然而，在break和continue这两个关键字的中，我们仍能看出一些goto的影子—-带标签的break和continue “标签”是指后面跟一个冒号的标识符，例如：label:对与Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
- 代码示例：
package com.wang.structure;
public class LabelDemo {
public static void main(String[] args) {
//打印101-150之间所有的质数
int count=0;
outer:for(int i=101;i<150;i++){
for(int j=2;j<i/2;j++) {
if (i % j == 0){
continue outer;
}
}
System.out.print(i+"\t");
}
}
}
二、Java方法
1.何谓方法？
System.out.println()，到底是个什么？答：解释为调用系统System的标准输出对象out中的方法println。 在Java中我们用的最多的其实还是定义好的大量的方法，首先我们要知道什么是方法，对于方法的解释总结如下：
- Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序集合。
- 方法包含于类型或者对象中。
- 方法在程序中被创建，在其他地方被引用。
我们在设计方法的时候需要遵循一些原则原则：方法的本意是功能块，就是实现某个功能的语句的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，这样利于我们后期的拓展。 在对方法进行命名时也要遵循一些规则：方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头。示例：demoFunction，也就是所谓的驼峰命名规则。
2.方法的定义
Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，方法包含一个方法和一个方法体
一个 完整的方法一般包含修饰符，返回值类型，方法名，参数类型，以及方法体 几部分。
一个方法包含以下几部分：
- 修饰符：修饰符，可选，告诉编译器如何调用方法，定义该方法的访问类型。
- 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型，有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType的关键字是void。
- 方法名：是方法的实际名称，方法和参数表共同构成方法签名。
- 参数类型：参数是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型、顺序和参数的个数，参数是可选的，方法可以不包含任何参数。形参：在方法被调用时用于接收外界的数据。实参：被调用方法时实际传给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能。
方法的格式：
修饰符 返回值类型 方法名(参数类型 参数名){
方法体
return 返回值; //返回值要与返回值的类型对应
}
3.方法的使用
接下来我们通过代码实例来介绍一下在Java中方法是如何使用的。例：使用方法实现加法运算，以及大小比较。
public class Method {
public static void main(String[] arg){
Scanner a = new Scanner(System.in);
Scanner b = new Scanner(System.in);
//两种调用方法
//方法1：
int sum = add(a.nextInt(),b.nextInt());
System.out.println(sum);
//方法2：
System.out.println("大小比较");
System.out.println(Max(a.nextInt(),b.nextInt()));
}
//方法
public static int add(int a,int b){
return a+b;
}
public static int Max(int a,int b){
int max = 0;
if (a == b){
System.out.println("两个数相等");
return 0;
}
if (a < b){
max = b;
return max;
}else {
max = a;
return max;
}
}
}
4.方法的重载
首先我们需要了解方法的重载是什么意思：重载就是在一个类中，有相同的函数名称，但形参不同的函数。
在对方法进行重载时需要遵循的规则：方法的名称必须相同；参数列表必须不同（个数不同、类型不同、顺序不同）；方法的返回类型可以相同，也可以不相同；仅返回类型不同不足以成为方法的重载。
方法重载的实现理论：方法名称相同时，编译器会根据调用方法的参数的个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
- 语法格式
public static int add(double a, double b){ return a+b; }
public static int add(int a, int b){ return a+b; }
public static int add(int a, int b, int c){return a+b+c;}
- 代码示例
public class java {
public static void main(String[] arg){
//此为方法的重载。简单解释为方法名相同，但值可能不同不起冲突实现重载的功能。
//方法重载的规则:
// .方法名必须相同
// .参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
// .方法返回值类型可以相同也可以不相同
// .仅仅返回类型不同不足以成为方法的重载
int sum = add(1,2);
int sum1 = add(1,2,3);
System.out.println(sum);
System.out.println(sum1);
}
public static int add(int a, int b){ return a+b; }
public static int add(int a, int b, int c){
return a+b+c;
}
}
5.可变参数
从 JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
可变参数定义方法：在方法的声明中，在指定参数类型后加一个省略号（…）。
需要注意的是：一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
- 代码示例：
// 找出最大值
public class java {
public static void main(String[] args){
java12 max = new java12();
max.printMax(45,78,96,74,52,63,82,71,93);
}
//可变参数
public void printMax(double... i){
if (i.length == 0){
System.out.println("You didn't type the numbers");
return;
}
//比较大小
double max = i[0];
for (int j=1 ; j<i.length ; j++){
if (i[j] > max){
max = i[j];
}
}
System.out.println("The maximum number is "+max);
}
}
后记
本文为大家介绍了Java流程控制与Java方法相关知识。
对于Java流程控制具体介绍了用户交互Scanner的使用，Java中的顺序结构，选择结构，循环结构以及Break & Continue。
对于Java方法的介绍具体介绍了Java方法的定义，使用与重载，以及方法中的可变参数。
如果你想进一步学习Java的知识与技术，可以参考以下的Java学习路线分享： Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
转载自:https://juejin.cn/post/7171703703588569095