Java - LogicControl -逻辑控制

前言

  本篇文章主要讲2个部分
  1. java中程序的逻辑控制语句
  2.java中的输入输出方式

---

 

正文开始

 

程序运行的三大结构

1.顺序结构

顺序结构比较简单. 像我们之前写过的代码就是顺序结构的, 按照代码书写的顺序一行一行执行

代码实例

public class LogicControl {
     
    public static void main(String[] args) {
     
        System.out.println("a");
        System.out.println("b");
        System.out.println("c");
    }
}
 这个我就不展示效果图了，
 结果就是
 a
 b
 c

---

 

2. 选择结构(分支结构)

 if      else     switch

---

 

3. 循环结构

        for    while        do while

---

 

分支结构(选择结构)

if语句

基本语法形式1

 if(布尔表达式){
    条件满足时执行的代码;
 }

---

 

基本语法形式2

 if(布尔表达式){
   条件满足时执行代码
 }else{
   条件不满足时执行代码
 }

---

 

基本语法形式3（多分支情况）

 if(布尔表达式){
   条件满足时执行代码;
 }else if(布尔表达式){
   条件满足时执行代码;
 }else{
   if 和 else if 的条件都不满足时执行代码 
 }

---

 

代码实例1

public class LogicControl {
     
    public static void main(String[] args) {
     
        int n =10;
        if(0 == n%2){
     //当 n 是偶数时，输出if输出语句
            System.out.println("偶数");//10是偶数，所以输出该语句的
        }else{
     // 当 n 不是是偶数时（不满足if条件时），输出else语句
            System.out.println("奇数");
        }
    }
}

. 那么这里我想自己输入一个数，来判断是否是奇偶数。
这里就要使用到 Scanner 函数，或者可以说是一种方法。

public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner =new Scanner(System.in);// 相当于 C语言中 scanf，从键盘输入一个数据
        int n = scanner.nextInt();// nextInt 意思是读取一个整形数据，赋给 整形变量 n

    }
}// 图1，为什么会显示找不到 Scanner 类， 因为没有引入 inport java.util.Scanner 类似C语言头文件的作用

图 1

---

.在这里有一个小技巧，在idea编译器中，只要你使用它推荐的方法Scanner ，它就会自动引入 inport java.util.Scanner
图 2 、图 3

图2

---

图3

---

 
如果你已经写完了 Scanner ，随便点击 Scanner 的一个位置，只要鼠标点完闪烁光标在 Scanner 上就行，按住 alt + 回车,它就会弹出框架，你只需选择就可以了,图4 和 图5

图4

---

图5

---

nextInt()的用法

图6

---

 

最终程序如下：

import java.util.Scanner;

public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);// 相当于 C语言中 scanf，从输入一个数据
        int n = scanner.nextInt();
// nextInt 意思是读取一个整形数据，赋给 整形变量 n，意味着你需要输入一个整形数据
// 因为Java对数据的类型非常严格，不同类型的值是无法进行赋值，就是说 如果你此时输入一个 非整形 的数据
// 那么程序 nextInt 读取数据毫无疑问会失败，导致程序运行不起来 图9
        if(0 == n%2){
     //当 n 是偶数时，输出if输出语句
            System.out.println("偶数");
        }else{
     // 当 n 不是是偶数时（不满足if条件时），输出else语句
            System.out.println("奇数");
        }
    }
}// 效果图 7, 8

图 7

---

图 8

---

图 9

---

 

你们是不是觉得 java输入好麻烦？

是的，主要因为Java 本身就不是用来开发控制台程序的，是用于 后台开发，偏应用性的语言

---

 

那么我们想输入输入一个字符串呢？

方法1

将 nextInt 的Int 改成 Line
即：nextLine

import java.util.Scanner;
### 代码如下
public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();// 把 Int 改成 Line就OK了，意思是读取一行的数据
        System.out.println(str);
        int n = scanner.nextInt();
        if(0 == n%2){
     //当 n 是偶数时，输出if输出语句
            System.out.println("偶数");
        }else{
     // 当 n 不是是偶数时（不满足if条件时），输出else语句
            System.out.println("奇数");
        }
    }
}//图10

图10

---

 

方法2

 把 nextLine 去掉 Line
 即 next

代码如下

import java.util.Scanner;
public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        // 此方法存在一个弊端，就是无法读取空格，且遇到空格后，不再读取后面的数据
        System.out.println(str);

        String str1=scanner.nextLine();// 而 nextLine 可以读取 空格数据，并往后一直读取
        System.out.println(str1);

    }
}//图11

图 11

---

 

但是请注意 如何我后面写的是 int n = scanner.nextInt的话，留下来的数据（ world） 与nextInt的要读取的数据类型不匹配，程序会报错。

代码如下

import java.util.Scanner;
public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        // 此方法存在一个弊端，就是无法读取空格，且遇到空格后，不再读取后面的数据
        System.out.println(str);

        int n =scanner.nextInt();
        System.out.println(n);

    }
}//图12

图12

---

 

在输入中，还需要注意一种情况

 public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String str = scanner.nextLine();
        System.out.println(str);
        if(0==n%2){
     
            System.out.println("偶数");
        }else{
     
            System.out.println("奇数");
        }
    }
} 图13

图13

这个问题是无法解决的，是java的缺陷，所以以后在我们想要输入字符串和 整形数据时，字符串输入语句要写在前面。注意在以后工作，做项目的时候，慎重使用 Scanner

---

 

代码实例2

判定一个数字是奇数还是偶数

public class LogicControl {
     
    public static void main(String[] args) {
     
        int num = 10;
        if (num > 0) {
     
          System.out.println("num 是正数");//满足if条件执行该语句，其它语句就不执行了

        } else if (num < 0) {
     
          System.out.println("num 是负数");//满足else if条件执行该语句，其它语句就不执行了
        } else {
     
          System.out.println("num 是 0");//不满足上面所有条件，执行该语句，其它语句就不执行了
        }

    }
}// 这个程序我就不讲了，你们自己看看就行，主要是了解一下 if语句的用法

---

 

代码示例3: 判定某一年份是否是闰年

图14

代码如下

public class LogicControl {
     
    public static void main(String[] args) {
     
        int year = 2000;
        if (year % 100 == 0) {
     
           // 判定世纪闰年
            if (year % 400 == 0) {
     
            System.out.println("是闰年");
            } else {
     
               System.out.println("不是闰年");
              }
        } else {
     // 不能被100 整除，走else语句
            // 普通闰年
           if (year % 4 == 0) {
     
              System.out.println("是闰年");
           } else {
     
               System.out.println("不是闰年");
             }
        }

    }

}

让我们来优化一下上程序

import java.util.Scanner;
public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        if ((year % 100 != 0 && 0 == year%4) || 0==year%400) {
     
            // 普通闰年
            System.out.println("普通闰年");
        }if(0 == year%100 && 0==year%400){
     
            // 实际闰年
            System.out.println("世纪闰年");
        }
     scanner.close();//这里跟C语言的文件操作时一样的，打开文件，就需要关闭文件
        // scanner在Java中是一种资源，System.in 相当于打开键盘，键盘其实也是一个文件
        // 所以更C语言文件操作是一样的，打开一个文件，就需要关闭一个文件
        // scanner.close 就类似于 C语言中 fclose()，都是关闭一个文件
        // 不管也没问题，但最好还是写一下，
    }

}

---

 

注意事项1：悬垂 if/else 问题

任何一行代码有括号就写上不要省略

例如

 if(布尔表达式）
    System.out.println("hehe");
 else
    System.out.println("haha");


 虽然if后面可以不加括号，但是它只能管一条语句，代码一多就容易出现问题
 
 所有我们要保持良好的习惯，要这么写
if(布尔表达式){
     
   System.out.println("hehe");
 }
else{
     
   System.out.println("haha");
 }

---

 

注意事项2： 代码风格问题

代码写得好不好，主要看可读性高不高（等价于 注释 和 风格好不好看） 和 效率高不高（程序运行速度快不快）

java程序的代码风格，代码示例

java程序的代码风格
if(布尔表达式){
     
   System.out.println("hehe");
 }else{
     
   System.out.println("haha");
 }

 C语言的风格
if(布尔表达式)
 {
     
   System.out.println("hehe");
 }
else
 {
     
   System.out.println("haha");
 }

 注意 Java跟C语言的代码风格不同，两者不能混淆
 我们现在是在学Java，所以写Java代码时，一定要使用Java的代码风格！！！
 前花括号一定要跟在 表达式/类/方法 的后面，这是Java中代码风格

---

 

注意事项3 分号问题

代码示例

if(布尔表达式);{
     // 这样写会导致后面的花括号里面的内容成为了，无条件都能执行，因为if(布尔表达式);的管理范围 到 分号就结束了。
所以对花括号里的内容起不到限制作用，所以后面的花括号里的内容，只要程序运行，它就会被无条件运行
   System.out.println("hehe");
 }
else{
     
   System.out.println("haha");
 }

---

&ensp

switch 语句

基本语法

public class LogicControl {
     
    public static void main(String[] args) {
     
        switch(整数|枚举|字符|字符串){
     
            case 内容1 : {
     
                内容满足时执行语句;
                break;
            }
            case 内容2 : {
     
                内容满足时执行语句;
                break;
            }
             .....
             ....
            default:{
     
                内容都不满足时执行语句;
                break;
            }
        }
    }
}

---

 

代码实例

public class LogicControl {
     
    public static void main(String[] args) {
     
        int a =1;
        switch (a){
     
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}//图 15

图15

---

 

现在让我们来看看看那些类型 数据 不可以运用到 switch 语句中(int 是绝对可以的)

byte

public class LogicControl {
     
    public static void main(String[] args) {
     
        byte a =1;
        switch (a){
     
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}//图 16，有结果得知可以

图16

---

 

short

public class LogicControl {
     
    public static void main(String[] args) {
     
        short a =1;
        switch (a){
     
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}//图 17，有结果得知可以

图17

---

 

long

public class LogicControl {
     
    public static void main(String[] args) {
     
        long a =1;
        switch(a){
     
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}//图 18，有结果得知不可以

图18

---

 

float 、double

public class LogicControl {
     
    public static void main(String[] args) {
     
//        float a =1.0f;
         double a =1.0;
        switch(a){
     
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}//图 19、20，由结果得知都不可以

图19

---

图20

---

 

char

public class LogicControl {
     
    public static void main(String[] args) {
     
       char a = 'f';//可以

        switch (a){
     
            case 'f':
                System.out.println("1");
                break;
            case 'g':
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}// 图21，由结果可知可以

图21

---

 

boolean

public class LogicControl {
     
    public static void main(String[] args) {
     
        boolean a = true;
        switch(a){
     
            case true:
                System.out.println("1");
                break;
            case false:
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}// 图22，由结果可知不可以

图22

总结：在Java中的八大基础数据类型，有4种（long、double、float、boolean）不能运用在switch语句中

---

 

我们再来试试Java中特有的字符串类型

public class LogicControl {
     
    public static void main(String[] args) {
     
        String a = "hehe";
        switch(a){
     
            case "hehe":
                System.out.println("1");
                break;
            case "haha":
                System.out.println("2");
                break;
            default:
                System.out.println("参数不能匹配");
                break;
        }
    }
}// 图23，由结果可知可以

图23

---

 

在jdk1.5开始，引入了枚举，枚举是可以运行到switch语句中的，这点和C语言一样。在这里就不举例子，讲到枚举时，再细讲

---

 

注意事项1: break 不要遗漏, 否则会失去 “多分支选择” 的效果(就是说会输出 其他条件的case语句)

public class LogicControl {
     
    public static void main(String[] args) {
     
        int day =1;
        switch (day){
     
            case 1:
                System.out.println("1");
            case 2:
                System.out.println("2");
                break;
        }
    }
}// 图24

图24

---

 

注意事项2 switch 中的值只能是 整数|枚举|字符|字符串，这个就不多说，前面已经讲了

---

 

注意事项3 switch 不能表达复杂的条件

例如: 如果 num 的值在 0 到 10 之间, 就打印 hehe，这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示.

 if (num > 0 && num < 10) {
     
    System.out.println("hehe");
 }// 图 25

图25

---

 

注意事项4 switch 虽然支持嵌套, 但是很丑~,歪七扭八的

public class LogicControl {
     
    public static void main(String[] args) {
     
        int x = 1;
        int y = 1;
        switch(x) {
     
            case 1:
                switch(y) {
     
                    case 1:
                        System.out.println("hehe");
                        break;
                }
                break;
            case 2:
                System.out.println("haha");
                break;
        }
    }
}

结论 代码的美观程度也是一个重要的标准. 毕竟这是看脸的世界

---

 

循环结构

while(布尔表达式)        do while(布尔表达式)    for(表达式1;布尔表达式2;表达式3)

while 循环

基本语法格式:

while(循环条件){
     
    循环语句;
}
循环条件（布尔表达式）为 true, 则执行循环语句; 否则结束循环

代码实例 1

(把 1~10 全部按加起来)

public class LogicControl {
     
    public static void main(String[] args) {
     
        int i =1;
        int sum = 0;
        while(i<=3){
     // 1.i==1、 2.i==2、3,i==3、 4.i == 4 不满足循环条件，为假（false）。跳出循环
            sum= sum+i;
            // 1. sum = sum+i == 0+1==1
            // 2. sum = sum +i == 1 + 2 == 3
            // 3. sum = sum +i == 3 + 3 == 6
            i++;
            // 1.i =2;
            // 2.i = 3
            // 3.i = 4;
        }
        System.out.println(sum);//6
    }
}// 图27，28 ，29，30

图27

---

图28

---

图29

---

图30

---

 

注意 千万不要像C语言一样这样写死循环 while(1)，在Java中，while里面放的是 布尔类型表达式,你只能这么写 while(true),明白嘛。

---

 

代码实例2（求阶乘）

public class LogicControl {
     
    public static void main(String[] args) {
     
        int n = 1;
        int num = 1;// 这里num设置为1，不设置为0，是因为，设置0的话
        // 后面while循环求阶乘，就没有意义了。 0 乘以任何数都为0.
        while (n <= 5) {
     
            num *= n;
            // num = num * n
            // 1. num = 1 * 1 == 1 (n==1)
            // 2. num = 1 * 2 == 2 (n==2)
            // 3. num = 2 * 3 == 6 (n==3)
            // 4. num = 6 * 4 == 24(n ==4)
            // 5. num = 24 * 5 == 120(n==5)
               等价于  1 * 2 * 3 * 4  * 5 == 120（5的阶乘）
            n++;
            //1. n = 2
            //2. n = 3
            //3. n = 4
            //4. n = 5
            //5. n = 6(在第五次循环时，n 自增加一等于6，返回while，判断循环条件不成立，跳出循环)
        }
        System.out.println(n);// 跳出循环后 n == 6
        System.out.println(num);// num == 120
    }
}// 图 31

图31

---

 

代码实例3（求 n！ 的阶乘之和）

这里我们求3！的阶乘之和
 1*1 + 1*2 + 1*2*3 == 1 + 2 + 6 == 9

public class LogicControl {
     
    public static void main(String[] args) {
     
        int n = 1;
        int sum = 0; // 用来接收 num 计算出的每个阶乘值
        int num = 1;// 这里num设置为1，不设置为0，是因为，设置0的话
        // 后面while循环求阶乘，就没有意义了。 0 乘以任何数都为0.
        while (n <= 3) {
     
            num *= n;// n的阶乘
            // num = num * n
            // 1. num = 1 * 1 == 1 (n==1)
            // 2. num = 1 * 2 == 2 (n==2)
            // 3. num = 2 * 3 == 6 (n==3)
       //这里我们只需要用一个 整形变量来 累积加上成 num算出的每个 阶乘值
            sum = sum +num;
            n++;
            //1. n = 2
            //2. n = 3
            //3. n = 4  (在第3次循环时，n 自增加一等于4，返回while，判断循环条件不成立，跳出循环)

        }
        System.out.println(n);// 跳出循环后 n == 4
        System.out.println(num);// num == 6
        System.out.println(sum);// 根据我们的分析，sum应该是 9
    }
}// 图 32

图32

**
 

注意事项

    1. 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
    2. 和 if 类似, while 后面的 { 建议和 while 写在同一行.
    3. 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行

情况3 int i = 10;

           while(i>0);{
     
            i--；
           }
 如果你这样写， while(i>0);循环 是一个死循环,因为分号 将while 和 后面的循环体 给截断了，while一直在循环，因为 没有循环体的限制，i一直都是10
 所以一直在死循环，不打印任何数据，while 只有一个循环条件判断，没有循环体，也就意味着没有任务可以交给程序去执行

---

 

break

break 的功能是让循环提前结束

代码如下

找到 100 - 200 中第一个 6 的倍数
public class LogicControl {
     
    public static void main(String[] args) {
     
        int num = 100;
        while (num <= 200) {
     
            if (num % 6 == 0) {
     
                break;// 找到 100 - 200 中第一个 6 的倍数之后，直接中断循环
//                也就是说 执行到 break 就会让循环结束
            }
            num++;
        }
        System.out.println("找到了 6 的倍数, 为:" + num);// 此时打印的 num 就是 100~200之间的 第一个 6 的倍数
    }
}//图 33

图33

---

 

continue

 continue 的功能是跳过这次循环, 立即进入下次循环

继续拿上面的例子

 这一次我们要找到 100 - 200 中 6 的倍数
public class LogicControl {
     
    public static void main(String[] args) {
     
        int num = 100;
        while (num <= 200) {
     
            if (num % 6 == 0) {
     // 判断num 是否为 100~200之间 6 的的倍数
                System.out.println("找到了 6 的倍数, 为:" + num);// 打印 找到的 100~200之间 6 的倍数

                num++; // num++; 在这里写一个，是为了 在找到 6的倍数之后，自增加一，避免造成死循环
                // 如果没有这个num++; num 将恒为第一个6的倍数102 == 17*6，永远小于200，也就意味着永远都满足while的循环条件，从而造成死循环

                continue;
                // 找到 100 - 200 中 6 的倍数之后，直接返回while判断条件，让while去判断 num 是否符合循环条件
                // 符合就再重复执行一遍上述程序，直至不满足 while 的循环条件 或者 不满足 if 语句的判断条件
                // 跳出while循环 或者 执行 num++ 语句。
            }
            num++;// 这个num++ 是为了让程序遍历 100~200 之间的所有数值，且避免了死循环
            比如说 假设这个num++没写，循环进来的时候，100 不满足if条件，所以不执行if语句，
             但是 没有任何语句去改变 num的值，所以会导致num一直都是100，其结果就是 程序在死循环巡行，且不打印任何值
            因为 除了 if 语句， 循环体里没有任何语句需要它去执行，况且100 也不满足if语句的执行条件

        }
    }
}//图 34

图34

---

 

总结

执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的语句

---

另外，请注意， break 和 continue 都必须写循环中，才能使用，这是规则。切记！！！

特殊：break 还可以在switch中使用。这一点是break独有的，也请记住!

说到这里还要额外提醒大家一个点，在Java中是没有 goto语句，就算有 你们也不要用，它太灵活了你们把握不住，而且以后可能会被 同事 和老板 diss,如果你想被分尸，你就去用，我不拦着，也不敢，

---

 

for 循环

for(表达式1;布尔表达式2;表达式3){
     循环体;
}
    表达式1: 用于初始化循环变量.
    表达式2: 循环条件
    表达式3: 更新循环变量
和 while 循环相比较, for 循环将这三个部分合并在一起, 写代码时不容易遗漏

代码实例

 输出 1~100 中，能被 3 和 5 整除的数
public class LogicControl {
     
    public static void main(String[] args) {
     
        int i =0;
        for(i = 1;i < 100; i++){
     
            if(0 == i%3 && 0 == i%5){
     
                System.out.println(i);
            }
        }
        System.out.println("haha");
    }
}// 图35、流程图
 我在这里只讲解for循环一次是怎么循环的
  表达式将 i 初始化一个值，然后执行布尔表达式2（i<100），判断是否满足小于100的条件
 满足就执行 循环体的内容，然后回到表达式3，更新循环变量 i的值，
 然后再执行 布尔表达式2，判断是否满足小于100的条件，满足就重复上述步骤
 不满足就跳出循环，执行下方程序 直至程序结束

图35

---

流程图

---

 

for 循环嵌套

public class LogicControl {
     
    public static void main(String[] args) {
     
        int i =0;
        for(i = 1;i < 5;i++){
     
            int j = 0;
            for(j=1;j<=i;j++){
     
                System.out.print(j);
            }
            System.out.print("\n");
        }
    }

}// 图36， 详解图

图 36

---

详解图

---

 

注意事项 (和while循环类似)

    1. 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }
    2. 和 if 类似, for 后面的 { 建议和 while一样， 写在同一行.
    3. 和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行

---

 

do while

基本语法

do{
     
    循环语句;
}while(循环条件);

 do while 循环有些特别，它的特别之处，就是它会先把循环体运行一次,不管你有什么限制条件，
 然后，再去判断while的循环条件 是否成立，成立就像for循环一样，再执行一遍循环体。循此往复。
 不满足，就跳出循环
 
简单来说：do while先执行循环语句, 再判定循环条件

程序实例

public class LogicControl {
     
    public static void main(String[] args) {
     
        int i =1;
        int sum=0;
        do{
     
            sum += i;
            System.out.println(sum);
        }while(i>1);// 注意 此时 i == 1的，是不满足while的循环条件的
    }
}// 我们来看看结果是如何，图37

图37

---

 

注意事项

    1. do while 循环最后的分号不要忘记
    2. 一般 do while 很少用到, 更推荐使用 for 和 while.

---

 

输入输出

输出到控制台

基本语法

System.out.println(数据); // 输出一个数据, 带换行
        System.out.print(数据); // 输出一个数据, 不带换行
        System.out.printf(format, msg); // 格式化输出

println 输出的内容自带 \n, 
print 不带 \n
printf 的格式化输出方式和 C 语言的 printf 是基本一致的

代码实例

public class LogicControl {
     
    public static void main(String[] args) {
     
        int a = 10;
        System.out.println(a);
        System.out.print(a);
        System.out.printf("%d\n",a);
    }
}//图38

图38

---

 

格式化字符串

转换符	类型	举
d	十进制整数	("%d", 100)	100
x	十六进制整数	("%x", 100)	64 == 16*6 +4
o	八进制整数	("%o", 100)	144 == 1*(8 * 8)+4*(8*1) +4
f	定点浮点数	("%f", 100f)	100.000000
e	指数浮点数	("%e", 100f)	1.000000e+02
g	通用浮点数	("%g", 100f)	100.000
a	十六进制浮点数	("%a", 100)	0x1.9p6
s	字符串	("%s", 100)	100
c	字符	("%c", ‘1’)	1
b	布尔值	("%b", 100)	true
h	散列码	("%h", 100)	64
%	百分号	("%.2f%%", 2/7f)	0.29%

这个表格没必要记住, 收藏起来，用到时候拿出来看

---

 

从键盘输入

读入一个字符

        直接使用 System.in.read 可以读入一个字符. 但是需要搭配异常处理 throws IOException (后面会重点讲到).
import java.io.IOException;
public class LogicControl {
     
    public static void main(String[] args) throws IOException {
     
        System.out.print("Enter a Char:");// 输入一个字符
        char i = (char) System.in.read();// System.in 意思是可以从键盘上读取一个整数强转成字符
        System.out.println("your char is :"+i);
    }
}// 效果图 41

图41

---

 
如果你的read出现警告波浪线，是因为你 main方法括号和 public的类
前面没有 throws IOException 和 import java.io.IOException;
除了 你自己写上去，还可以使用以下方法

图39

---

图40

---

 

但是这种输入方式， 我不推荐使用。因为我们每次使用read的时候，都需要加上 throws IOException（处理一个异常）, 这样就会导致输入非常麻烦

---

 

如果我要输入一个数据，我推荐 Scanner

import java.util.Scanner;
public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);// 如果你的Scanner是红色的，按照处理read的方式去处理就可以了
        // 选择完后，你会发现程序顶部多一个 import java.util.Scanner;，这代表这我们就能使用 Scanner
        // 但是为什么是这么写的，如图 42，43（下翻找到 rt.jar，在rt.jar目录下，找到java，在java的目下找到 util，打开它）
        // 继续往下翻，找到S开头的，Scanner 就在里面 图 44
        // 回过头一看，诶，这不就是文件路径的格式嘛。
        // 确实，现在你了解为什么使用Scanner类的时候，要引用 import java.util.Scanner;了吧
        // 就像你吃方便面一样，你只需把人家准备好的三包调料，打开放进去，就好了

        // 而 System.in 的意思就是从键盘读取数据

        // 接下来我们要读取一个整数
        int n = scanner.nextInt();// 这就读取一个 整数，并将其赋给 n
        System.out.println(n);// 这里是将n的值打印
        // 图45

        double d = scanner.nextDouble();// 读取一个小数，将其赋给 d。
        System.out.println(d);// 输出 d 的值
        // 图 46

         总得来说，读取一个类型的数据，就next+类型（首字母要大写）就OK了
        // 图47

    }
}

图42

---

 

图 43

---

 

图 44

---

 

图 45

---

 

图 46

---

 

图 47

---

 

我再演示一下输入一个字符串数据，因为它有点不同

1.它不能在 输入 数字数据之后，继续输入一个字符串(无法解决，该问题属于Java的缺陷)

 java 将输入输出字符串的语句给跳过。所以输入字符串的语句，要放在输入数字数据的前面
 输入数字类型的数据，就不受位置的影响，放在输入字符串数据，也可以进行读取工作
 图 48，50

图48

---

图50

这个我前面也讲了,我就不细说了

---

 

2.它使用是的是 nextInt() 和 next().

不像其它类型数据，next类型名（）,类型名的第一个字母大写

现在，我们正式输入一个字符串数据

import java.util.Scanner;
public  class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        String Str = scanner.next();// 读取一行数据，遇到空格停止读取
        String str = scanner.nextLine();// 读取一行数据，空格也可以读取
        int a = scanner.nextInt();
        System.out.println(a);
        System.out.println(Str);
        System.out.println(str);//图 49
        scanner.colse();// 经过 Scanner的讲解，你们可以将其当做是一个文件
          
    }
}

打开一个文件，用完了就肯定要关闭，这点 scanner.colse() 跟C语言的 fclose 的是一样的道理，有兴趣的可以看看我的这篇文章 Operator File(操作文件).

图 49

---

 

使用 Scanner 循环读取 N 个数字

import java.util.Scanner;
public class LogicControl {
     
    public static void main(String[] args) {
     
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNextInt()){
     
            // hasNextInt() 是用来判断 我们输入的数据是否为 int 类型
            // 是 就 返回 true，否，则返回 false
            // 当返回 true时，进入循环体
            // 将我们刚才输入的整形数据，赋予  scanner.nextInt() 
            // 再通过 scanner.nextInt() 再将其值，赋予 n
            int n = scanner.nextInt();
            System.out.println(n);// 这里就是打印 n 的值
            // 图52
        }

    }
}

图52

---

 

本文结束