JAVA-02（语法介绍）

JAVA-02

Java流程控制

用户交互Scanner

Scanner类

属于IO流的类如果不关会一直占用资源
常用方法

​                【Scanner scanner = new Scanner(System.in);】
​        .next();                   遇到空格就结束接收
​        .nextLine();                遇到enter就结束接收
​        .hasNext()              判断是否有输入
​        .hasNextInt()         判断是否有整数输入
​        .close();                   关闭
举例【instance】

1. package com.xy.base;
3. import java.util.Scanner;
5. public class Demo11 {
6.     public static void main(String[] args) {
8.         //创建一个扫描对象，用于接收键盘数据
9.         Scanner scanner = new Scanner(System.in);
11.         System.out.println("使用next方式接收：");
12.         //判断用户有没有输入字符串
13.         if(scanner.hasNext()){
14.             //使用next接收
15.             String str = scanner.next();
16.             System.out.println("输入的内容为："+str);
17.         }
19.         System.out.println("使用nextLine方式接收：");
20.         if(scanner.hasNext()){
21.             //使用next接收
22.             String str1 = scanner.nextLine();
23.             System.out.println("输入的内容为："+str1);
24.         }
26.         System.out.println("请输入一个整数:");
27.         //判断输入的是否为整数【判断是否有整数输入】
28.         if(scanner.hasNextInt()){
29.             int i = scanner.nextInt();
30.             System.out.println("输入的整数为："+i);
31.         }else{
32.             System.out.println("输入的不是整数！");
33.         }
35.         //凡是属于IO流的类如果不关会一直占用资源
36.         scanner.close();
38.     }
39. }

复制代码

输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果

1. package com.xy.base;
3. import java.util.Scanner;
5. public class Demo11_instance {
7.     public static void main(String[] args) {
8.         //输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果
9.         int count = 0;
10.         double sum = 0;
12.         Scanner scanner = new Scanner(System.in);
13.         System.out.println("请输入数据：");
14.         //while判断是否是数字输入
15.         while (scanner.hasNextDouble()){
16.             count++;
17.             sum = sum + scanner.nextDouble();
18.         }
19.         System.out.println(count + "个数据总和为：" + sum);
20.         System.out.println(count + "个数据平均数为：" + sum/count);
22.         //关闭！！！！！！不要忘记
23.         scanner.close();
25.     }
26. }

复制代码

三种结构（顺序、选择、循环）

顺序结构

• Java最基本的结构，最简单的算法结构
  
• 任何算法都离不开的
  
• 一条一条从上到下执行
  

1. System.out.println("顺序结构！");
2. System.out.println("顺序结构！");
3. System.out.println("顺序结构！");

复制代码

选择结构

1. if单选择结构

1. if(条件式){
2.         //满足表达式执行的语句
3. }

复制代码

2. if...else双选择结构

1. if(条件式){
2.         //满足表达式执行的语句
3. }else{        //不满足表达式执行的语句}

复制代码

3. if...else if多选择结构

1. if(条件式1){
2.         //满足表达式1执行的语句
3. }else if(条件式2){
4.         //满足表达式2执行的语句
5. }else{
6.         //都不满足执行的语句
7. }

复制代码

4. 嵌套的if结构

1. if(条件式1){
2.         if(条件式1){
3.                 //满足表达式1和2执行的语句
4.         }
5. }else{
6.         //不满足表达式1执行的语句
7. }

复制代码

5. switch多选择结构

• 语法：
  1. switch(expression){        //expression变量
  2.         case value:        //【可选】判断变量的值是否等于value值
  3.                 //语句
  4.                 break;        //【可选】  若不选，会有case穿透效果
  5.         case value:
  6.                 //语句
  7.                 break;
  8.         ...
  9.         default:        //【可选】 以上case都不满足时执行default
  10.                 //语句
  11. }

  复制代码
• case穿透效果：如果当前case满足且结束没有break语句，那么将会执行下面所有的case，直到遇见break语句。
  
• switch中的变量类型 ：byte、short、int或者char
  
• 从Java SE7开始支持字符串String类型
  1. String  x = "注意";
  2. switch (x){
  3.         case "注意":
  4.                 System.out.println("注意");
  5.     case  "协议":
  6.         System.out.println("协议");
  7.         break;
  8.     default:
  9.         System.out.println("default");
  10. }

  复制代码

循环结构

1. while循环

• 语法
  1. while(布尔表达式){
  2.         //循环内容
  3. }

  复制代码

2. do...while循环

• 语法
  1. do{
  2.         //循环内容
  3. }while(布尔表达式);

  复制代码
• while和do...while的区别
  
  
  
  • while先判断再执行，do...while先执行在判断
    
  • do...while至少执行一次，while可以一次也不执行
    
  
  

3. for循环

• 语法
  1. for(初始化;布尔表达式;更新){
  2.         //循环内容
  3. }

  复制代码
• 最有效，最灵活的循环结构
  
• 循环次数是在执行之前就已经确定的
  
• fou循环 ：先初始化，在判断真假，若为真则执行循环体，然后更新；若为假，则跳出循环
  1. for (int i = 0; i < 5; i++) {
  2.         System.out.println("i:" + i);
  3.     System.out.println("第" + i + "次循环！");
  4. }

  复制代码
• 练习：打印九九乘法表
  1. for(int i = 1 ; i < 10 ; i ++){
  2.     for (int j = 1 ; j <= i ; j ++){
  3.             //输出乘法并输出一个tab空格
  4.             System.out.print(j + "*" +i +"=" + j*i + "\t");
  5.     }
  6.     //换行
  7.     System.out.println(); //等价于 System.out.print("\n");
  8. }

  复制代码
  动态初始化
  
  1. int[] num = {10,20,30,40,50};
  2. for(int n:num){
  3.         System.out.println(n);
  4. }

  复制代码
  数组默认初始化
  
  数组是引用类型，他的元素相当于类的实例变量，因此数组在一分配空间时就已经被默认初始为相应类型的默认值了。
  数组的特点
  
  
  
  
  • 数组一经创建就长度确定
    
  • 同一数组元素类型相同
    
  • 数组中的元素可以是任何数据类型
    
  • 数组变量属于引用类型，数组也可以看成对象
    
  • 数组对象本身是在堆中的
    
  Arrays类（import java.util.Arrays）
  
  学会使用官方API帮助文档，这里介绍两个
  1. int i = 0;
  2. while(i < 100){
  3.     i++;
  4.     if(i == 10){
  5.             break;
  6.     }
  7.     System.out.println(i);
  8. }

  复制代码
  冒泡排序
  
  1. int j = 0;
  2. while (j < 10){
  3.     j++;
  4.     if (j%2 == 0) {
  5.             continue;
  6.     }
  7.     System.out.println(j);
  8. }

  复制代码
  稀疏数组
  
  
  
  
  • 定义：当一个数组中大部分元素都为0或同一数据时，可以使用稀疏数组来保存。
    
  • 处理方式：
    
    
    
    • 记录数组一共有几行几列，有多少个不同值
      
    • 把具有不同值的元素的行和列以及值记录在一个小规模的数组中，从而缩小程序的规模
      
    
    
  1. public class Demo13_instance {
  2.     public static void main(String[] args) {
  3.         //规定5行
  4.         for(int i = 1 ; i <= 5 ; i ++){
  5.             //打印空的倒直角三角形
  6.             for(int j = 5 ; j >= i ; j --){
  7.                 System.out.print(" ");
  8.             }
  9.             //打印正直角三角形
  10.             for (int j = 1 ; j <= i ; j ++){
  11.                 System.out.print("*");
  12.             }
  13.             //打印关于另一半直角三角形
  14.             for(int j = 1 ; j <= i ; j ++){
  15.                 System.out.print("*");
  16.             }
  17.             //换行
  18.             System.out.println();
  19.         }
  20.     }
  21. }

  复制代码
  免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！