敞开掘金成长之旅！这是我参与「掘金日新计划 12 月更文挑战」的第4天，点击检查活动详情

前言

本文为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全栈学习技能清单~

Java流程控制与Java方法相关知识总结分享

前言

一、Java流程操控

1.用户交互Scanner

2.次序结构

3.挑选结构

4.循环结构

5.Break & Continue

二、Java办法

1.何谓办法？

2.办法的界说

3.办法的运用

4.办法的重载

5.可变参数

跋文

作者信息

Java流程控制与Java方法相关知识总结分享

前言

一、Java流程操控

1.用户交互Scanner

2.次序结构

3.挑选结构

4.循环结构

5.Break & Continue

二、Java办法

1.何谓办法？

2.办法的界说

3.办法的运用

4.办法的重载

5.可变参数

跋文

相关文章

活动的生命周期

在2022年，与Emacs再重逢

字节：成员变量，局部变量，存放在哪里，为什么局部变量需要初始化

挖一挖Retrofit源码（一）

作者信息