JAVA学习之Java流程控制-2021-08-05

于 2021-08-05 22:13:23 发布
阅读量165 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_59213918/article/details/119428442
版权
本文详细介绍了Java中的包机制，包括包的创建、导入以及其在组织类命名空间中的作用。同时，讲解了JavaDoc的使用，如何生成API文档，以及相关参数的设置。接着，文章深入探讨了Scanner类，展示了如何通过Scanner获取用户输入，包括next()和nextLine()方法的使用。最后，概述了Java的基本流程控制结构，如循环、选择结构和条件判断，以及break和continue的使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

包机制

  • 为了更好地组织类, Java提供了包机制,用于区别类名的命名空间。

  • 包语句的语法格式为

    :package pkg1[. pkg2[. pkg…] ;

  • 一般利用公司域名倒置作为包名;

  • 为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能

    import package1 [.package2…].(lassname|*);

JavaDoc

  • javadoc令是用来生成自己API文档的

    javadoc -encoding UTF-8 -charset UTF-8 Doc.java

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fo54AiH3-1628172291515)(C:\Users\十九婊哥\AppData\Roaming\Typora\typora-user-images\image-20210805152848916.png)]

  • 参数信息

    • @author作者名
    • @version 版本号
    • @since指明需要最早使用的jdk版本
    • @param 参数名
    • @return返回值情况
    • @throws异常抛出情况

使用IDEA生成doc文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XbnYEyGg-1628172291517)(C:\Users\十九婊哥\AppData\Roaming\Typora\typora-user-images\image-20210805153913313.png)]
2.

  1. 选择是整个项目还是模块还是单个文件
  2. 文档输出路径
  3. Locale 选择地区，这个决定了文档的语言，中文就是zh_CN
  4. 传入JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题”
  5. 注意：目录最好不要使用中文，不然会报错
  6. 然后会生成如下图所示

在这里插入图片描述
在这里插入图片描述

Java流程控制

Scanner对象

  • 之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。java.util.Scanner是Java5的新特征,我们可以通过Scanner类来获取用户的输入。

  • 基本语法:

    Scanner s = new Scanner (System.in);

  • 通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

  • next():

    1. 一定要读取到有效字符后才可以结束输入。
    2. 对输入有效字符之前遇到的空白, next()方法会自动将其去掉。
    3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
    4. next()不能得到带有空格的字符串。

  • nextLine):

    1. 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
    2. 可以获得空白。

代码块进行理解

Scanner基本使用1

​ Scanner scanner = new Scanner(System.in);
​ scanner.close();

package com.wyy.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()){//默认等于true
            //使用next方式接收
            String str = scanner.next();//程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源,要养成好习惯用完就关掉
        scanner.close();
    }
}

Scanner基本使用2

package com.wyy.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.hasNext()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

Scanner基本使用3

package com.wyy.scanner;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        //从键盘接受数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入数据：");

        String str = scanner.nextLine();
        System.out.println("输出的内容为："+str);
        scanner.close();
    }
}

Scanner基本使用4

package com.wyy.scanner;

import java.util.Scanner;

public class Demo04 {
    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();
    }
}

Scanner基本使用5

package com.wyy.scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字,并求其总和与平均数,厨输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果:
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()) {
            double x = scanner.nextDouble();
            m = m + 1;//m++
            sum = sum + x;
            System.out.println("你输入了第"+m+"个数据，然后当前的结果sum="+sum);

        }
        System.out.println(m + "个数的和为：" + sum);
        System.out.println(m + "个数的平均值为：" + (sum / m));


        scanner.close();

    }
}

顺序结构

  • JAVA的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行。

  • 顺序结构是最简单的算法结构。

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OqLwk61X-1628172291522)(C:\Users\十九婊哥\AppData\Roaming\Typora\typora-user-images\image-20210805174938936.png)]

  • 语句与语句之间,框与框之间是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的,它是任何一个算法都离不开的一种基本算法结构。

    package com.wyy.struct;

public class TheOrder {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

选择结构

  • if单选择结构

    • 我们很多时候需要去判断一个东西是否可行,然后我们才去执行,这样一个过程在程序中用if语句来表示

    • 语法:

      if(布尔表达式){
//如果布尔表达式为true将执行的语句
}


    package com.wyy.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于等于60就是及格，小于60分就不及格

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score>=60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();
    }
}

  • if双选择结构

    • 那现在有个需求,公司要收购一个软件,成功了,给人支付100万元,失败了,自己找人开发。这样的需求用一个if就搞不定了,我们需要有两个判断,需要一个双选择结构,所以就有了ifelse结构。

    • 语法:

      if（布尔表达式）{    //如果布尔表达式的值为true}else{    //如果布尔表达式的值为false}



package com.wyy.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于等于60就是及格，小于60分就不及格

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score>=60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
        scanner.close();
    }
}

  • if多选择结构

    • 我们发现刚才的代码不符合实际情况,真实的情况还可能存在ABCD,存在区间多级判断。比如90-100就是A, 80-90就是B.等等,在生活中我们很多时候的选择也不仅仅只有两个,所以我们需要一个多选择结构来处理这类问题!

    • 语法:

      if(布尔表达式1){
    //如果布尔表达式1的值为true执行代码
}else if(布表达式2){//如果布尔表达式2的值为true执行代码
}else if(布尔表达式3)//如果布尔表达式3的值为true执行代码
}else {//如果以上布尔表达式都不为true执行代码


    package com.wyy.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        //考试分数大于等于60就是及格，小于60分就不及格

        Scanner scanner = new Scanner(System.in);
        /**
         * if语句至多有1个else 语句, eLse语句在所有的else if语句之后
         * if 语句可以有若干个else if语句，它们必须在else语句之前。
         * 一旦其中一个else if语句检测为true,其他的else if以及else语句都将跳过执行。
         */
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();//有小数的可以把类型改为double

        if (score == 100) {
            System.out.println("恭喜满分");
        } else if (score < 100 && score >= 90) {
            System.out.println("A级");
        } else if (score < 90 && score >= 80) {
            System.out.println("B级");
        } else if (score < 80 && score >= 70) {
            System.out.println("C级");
        } else if (score < 70 && score >= 60) {
            System.out.println("D级");
        } else if (score < 60&& score >= 0) {
            System.out.println("不及格");
        } else {
            System.out.println("成绩不合法");
        }
        scanner.close();
    }
}

  • 嵌套的if结构

    • 使用嵌套的if.else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或者else if语句。你可以像if语句一样嵌套else if…else

    • 语法:

      if(布尔表达式1){
    //如果布尔表达式1的值为true执行代码
    if(布尔表达式2){
        //如果布尔表达式2的值为true执行代码
    }
}

  • switch多选择结构

    • 多选择结构还有一个实现方式就是switch case语句。witch case语句判断一个变量与系列值中某个值是否相等,每个值称为一个分支。

    • switch语句中的变量类型可以是：

      • byte, short, int或者char.
      • 从Java SE7开始switch支持字符串String类型了
      • 同时case标签必须为字符串常量或字面量。
      switch(expression){
    case value :
        //语句
        break; //可选
    case value
        //语句
        break; //可选
        //你可以有任意数量的case语句
    default : //可选
        //语句
}

      例1

      package com.wyy.struct;
      
public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透    //switch 匹配一个具体的值
      
        char grade = 'C';
        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("未知等级");
      
        }
    }
}

      例2

      package com.wyy.struct;
      
public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透    //switch 匹配一个具体的值
      
        char grade = 'C';
        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("未知等级");
      
        }
    }
}

循环结构

  • while循环

    • while是最基本的循环,它的结构为:

      while(布尔表达式) {
    //循环内容
  }

    • 只要布尔表达式为true,循环就会一直执行下去。

    • 我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环。

    • 少部分情况需要循环一直执行,比如服务器的请求响应监听等。

    • 循环条件一直为true就会造成无限循环【死循环】 ,我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃

    • 思考:计算1+2+3+…100?

      package com.wyy.struct;
      
public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+...+100=?
        int i = 0;
        int sum = 0;
      
        while (i<=100){
            sum = sum + i;
            i++;
        }
        System.out.println(sum);
    }
}

  • do…while循环

    • 对于while语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。

    • do…while循环和while循环相似,不同的是, do.while循环至少会执行一次。

       do{
     //代码语句
 }while(布尔表达式);

    • While和do-While的区别:

      • while先判断后执行。

      • dowhile是先执行后判断!Do…whil总是保证循环体会被至少执行一次!这是他们的主要差别。

    package com.wyy.struct;

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);
    }
}//结果为：
//==========================
//0

  • for循环在

    • 虽然所有循环结构都可以用while或者dowhile表示,但Java提供了另一种语句循环,使一些循环结构变得更加简单。

    • for循环语句是支持送代的一种通用结构,是最有效、最灵活的循环结构。

    • for循环执行的次数是在执行前就确定的。语法格式如下:

    for(初始化；布尔表达式；更新){ 
   //代码语句
   }

    练习1:计算0到100之间的奇数和偶数的和

    
package com.wyy.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //练习1:计算0到100之间的奇数和偶数的和

        int oddSum = 0;//奇数
        int evenSum = 0;//偶数
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                oddSum += i;
            } else {
                evenSum += i;
            }
        }
        System.out.println("奇数的和：" + oddSum);//奇数的和：2500
        System.out.println("偶数的和：" + evenSum);//偶数的和：2550
    }
}

    练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个

    
package com.wyy.struct;

public class ForDemo03 {
    public static void main(String[] args) {
//练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个

        for (int i = 1; i <= 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){//实现换行
                System.out.println();
//                System.out.print("\n");
            }
        }
        // printLn输出完会换行
        // print 翰出完不会换行
        

    }
}

    练习3:打印九九乘法表

      
  package com.wyy.struct;
  
  /**
   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
   */
  
  public class ForDemo04 {
      public static void main(String[] args) {
          //1.我们先打印第1列,这个人家应该部公
          // 2.我们把固定的1再用一个新环包起来"
          // 3.去掉重复项, i <=j
          // 4,调整样式
          for (int j = 1; j <= 9; j++) {
              for (int i = 1; i <= j; i++) {
                  System.out.print(j+"*"+i+"="+(j*i)+"\t");
              }
              System.out.println();
          }
  
  
      }
  }

  • Java5中引入了一种主要用于数组的增强型for循环。

    • 这里我们先只是见一面,做个了解,之后数组我们重点使用

    • Java5 引入了一种主要用于数组或集合的增强型for循环。

    • Java增强for循环语法格式如下:

    for(声明式：表达式){
    //代码句子
}
    • 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
    • 表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
    package com.wyy.struct;

/**
10
20
30
40
50
============
10
20
30
40
50
*/
public class ForDemo05 {
   public static void main(String[] args) {
       int[] numbers = {10,20,30,40,50};//定义了一个数组

       for (int i =0;i<5;i++){
           System.out.println(numbers[i]);
       }
       System.out.println("============");
       //遍历数组的元素
       for (int x:numbers){
           System.out.println(x);
       }
   }
}

break和continue

  • break在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(breaki句也在switch语句中使用)

    package com.wyy.struct;

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语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句接着进行下一次是否执行循环的判定。

    package com.wyy.struct;

public class ContinueDemo01 {
    public static void main(String[] args) {
        int i =0;
        while (i<100){
            i++;
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i+"\t");

            //break在任何循环语句的主体部分,均可用break控制循坏的流程。
            // break用于强行退出循坏,不执行循坏中剩余的语句。(break语句也在switch语句中使用)
            //
            //continue 语句用在循环语句体中,用于终止某次循坏过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
        }
    }
}

  • 关于goto关键字goto关键字

    • 很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字,但并未在语言中得到正式使用; Java没有goto,然而,在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子–带标签的break和continue.
    • "标签”是指后面跟一个冒号的标识符,例如: label:
    • 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另个循环,由于break和continue关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方。
    package com.wyy.struct;

public class LableDemo01 {

    public static void main(String[] args) {
        //打印101-150之间的质数
        //顺质数是指在大于1的自然数中,除1和它本身以外,不再有其他因数的自然数。

        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");

        }
    }
}

流程控制练习

package com.wyy.struct;

public class TestDemo01 {
    public static void main(String[] args) {
        //打印三角形     5行
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j =1;j < i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }
}
十九婊哥
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值