Java基础语法精要：输入输出与流程控制

一.输出和输入语句

1.输出

• System.out.println()// 换行输出

• System.out.printf()，通过使用占位符%?，printf()可以把后面的参数变量，格式化成指定格式

• System.out.print()

格式化输出的占位符：

占位符	说明	适合类型
%d	格式化输出整数	整型
%x	格式化输出十六进制整数	整型
%f	格式化输出浮点数	浮点型
%e	格式化输出科学计数法表示的浮点数	浮点型
%s	格式化字符串	任意类型

注意：%表示占位符，那么连续两个%就表示字符本身咯。

2.输入

  Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        
        System.out.print("Input your name: "); // 打印提示
        String name = scanner.nextLine(); // 读取一行输入并获取字符串
        
        System.out.print("Input your age: "); // 打印提示
        int age = scanner.nextInt(); // 读取一行输入并获取整数
        
        System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出

注：使用scanner前必须导入java.util.Scanner.

二.if条件分支

1.基本语法

  if语句的基本语法是：根据if的计算结果（true还是false），JVM决定是否执行if语句块（即花括号{}包含的所有语句）。

if (条件) {
    // 条件满足时执行
}

public class Main {
    public static void main(String[] args) {
        int n = 70;
        if (n >= 60) {
            System.out.println("及格了");
        }
        System.out.println("END");
    }
}

注：if如果只有一行语句时候，尽量不要省略花括号，保持良好代码习惯。

2.else语句

  if语句还可以编写一个else { ... }，当条件判断为false时，将执行else的语句块。

public class Main {
    public static void main(String[] args) {
        int n = 70;
        if (n >= 60) {
            System.out.println("及格了");
        } else {
            System.out.println("挂科了");
        }
        System.out.println("END");
    }
}

注意，在语法结构中，else并不是必须的。

3.浮点数判断

由于浮点数在计算机中，无法精确表示，并且计算可能出现误差，因此，判断浮点数相等用==判断可能存在不准确的情况。

例如：

public class Main {
    public static void main(String[] args) {
        double x = 1 - 9.0 / 10;
        if (x == 0.1) {
            System.out.println("x is 0.1");
        } else {
            System.out.println("x is NOT 0.1"); // 错误结果
        }
    }
}

正确的做法应该用Math.abs(x-0.1)<0.00001判断。只要小于它的某个临界值

就返回true.代码如下：

public class Main {
    public static void main(String[] args) {
        double x = 1 - 9.0 / 10;
        if (Math.abs(x - 0.1) < 0.00001) {
            System.out.println("x is 0.1"); // 正确结果
        } else {
            System.out.println("x is NOT 0.1");
        }
    }
}

4.判断引用类型相等

  在Java中，判断基本数据类型的变量是否相等，可以使用==运算符。但是，判断引用类型的变量是否相等，==表示“引用的内存地址是否相等”，或者“是否指向同一个对象”。例如，下面的两个String类型，它们的内容是相同的，但是，分别指向不同的对象，

用==判断，结果为false。

正确的做法应该用equals()进行判断代码如下：

public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        
        System.out.println(s1);
        System.out.println(s2);
        
        if (s1.equals(s2)) {
            System.out.println("s1 equals s2"); // 正确结果
        } else {
            System.out.println("s1 not equals s2");
        }
    }
}

注意：执行语句s1.equals(s2)时，如果变量s1为null，会报NullPointerException空指针异常：

要避免NullPointerException错误，可以使用短路运算符&&：

三.switch

     根据一组多重判断条件，根据某个表达式的结果，分别去执行不同的代码分支。

1.基本语法

   switch语句根据switch (表达式)计算的结果，跳转到匹配的case结果，然后继续执行后续语句，直到遇到break结束执行。

表达式的类型可以是：int、char、String、枚举

switch(表达式) {
    case 1:
        // 表达式 等于 1
        System.out.println("执行case 1中的代码逻辑");
        break; // 退出switch
    case 2:
        // 表达式 等于 2
        System.out.println("执行case 2中的代码逻辑");
        break; // 退出switch
    default:
        // 默认情况(上述case值均不相等)
        System.out.println("执行默认情况的代码逻辑");
        break; // 退出switch
}

        如果option的值没有匹配到任何case，例如option = 99，那么，switch语句不会执行任何语句。这时，可以给switch语句加一个default，当没有匹配到任何case时，执行default：

2.break

       使用switch时，注意case语句并没有花括号{}。所以case语句具有“穿透性”，漏写break将导致意想不到的结果：当option = 2时，将依次输出"Selected 2"、"Selected 3"、"Not selected"，原因是从匹配到case 2开始，后续语句将全部执行，直到遇到break语句。因此，任何时候都不要忘记写break。

public class Main {
    public static void main(String[] args) {
        int option = 2;
        switch (option) {
        case 1:
            System.out.println("Selected 1");
        case 2:
            System.out.println("Selected 2");
        case 3:
            System.out.println("Selected 3");
        default:
            System.out.println("Not selected");
        }
    }
}

例如：根据当前月份，判断该月有多少天？

int month = 6;

switch (month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        System.out.println("当前月份共计31天");
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        System.out.println("当前月份共计30天");
        break;
    default:
        // 计算平年闰年
        int year = LocalDate.now().getYear();
        if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            // 闰年
            System.out.println("今年为闰年，2月共计29天");
        }else {
            // 平年
            System.out.println("今年为平年，2月共计28天");
        }
        break;
}

总结switch基本用法：

• switch语句可以实现多重选择的逻辑结构，然后执行匹配的case语句的后续代码
• switch的计算结果必须是整型、字符型、字符串或枚举类型
• break用于退出switch语句结构
• default用于当没有匹配到任何case时，执行默认逻辑

四.循环

1.while基本语法

Java提供的while条件循环。它的基本语法是：while循环在每次循环开始前，首先判断条件是否成立。如果计算结果为true，就把循环体内的语句执行一遍，如果计算结果为false，那就直接跳到while循环的末尾，继续往下执行。

while (条件表达式) {
    循环语句
}
// 继续执行后续代码

注意：

• 如果循环条件永远满足，那这个循环就变成了死循环。死循环将导致100%的CPU占用，用户会感觉电脑运行缓慢，所以要避免编写死循环代码。

• 循环条件变量n的值溢出，导致特殊结果：下述代码中的while循环不是一个死循环。但是，Java的int类型有最大值，达到最大值后，再加1会变成负数，结果，意外退出了while循环，导致错误的运行结果。（如果保持初值不变，就不会溢出会一直循环）

2.do...while循环基础

while循环是先判断循环条件，再执行循环。而另一种do while循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出。所以，do while循环会至少循环一次。

do {
    执行循环语句
} while (条件表达式);

3.for循环

   for循环的功能非常强大，它使用计数器变量实现循环。for循环会先初始化计数器变量，然后，在每次循环前，通过计数器变量检测循环条件，在每次循环后更新计数器变量。计数器变量通常命名为i。

注：区别：

while循环与do...while循环更适合不固定次数的循环，因为它们的语法结构中，更容易表达一个boolean类型的条件表达式。而for循环的语法结构中，存在三个语法位置，可以分别去控制循环变量的初始化、循环条件的判断、循环变量的改变，所以for循环更适合使用计数器循环遍历来控制固定次数的循环使用场景。

while循环与do...while循环适合不固定次数的循环使用场景：

Scanner input = new Scanner(System.in);
String answer = "";
do{
    System.out.println("请输入选择：yes/no");
    answer = input.nextLine();

}while(answer.equalsIgnoreCase("no"));

for循环适合使用计数器循环遍历来控制固定次数的循环使用场景：

for (int x = 1; x <= 50; x++) {
    System.out.println("do........sth........");
}

4.for循环特殊用法

   for循环还可以缺少初始化语句、循环条件和每次循环更新语句。通常不推荐这样写，但是，某些情况下，为了配合一些特殊的逻辑，语法规则上是允许省略for循环的某些语句的。

例如：

• 不设置结束条件

for (int i=0; ; i++) {
    ...
}

• 不设置结束条件和更新语句

for (int i=0; ;) {
    ...
}

• 死循环

for (;;) {
    ...
}

5.foreach

for循环经常用来遍历数组，因为通过计数器可以根据索引来访问数组的每个元素：

int[] ns = { 1, 4, 9, 16, 25 };
for (int i = 0; i < ns.length; i++) {
    System.out.println(ns[i]);
}

foreach访问：

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}

 注意：  for each和for相比，for each循环的变量n不再是计数器，而是直接对应到数组的每个元素。for each循环的写法也更简洁。但是，for each循环无法指定遍历顺序，也无法获取数组的索引下标，去改变数组元素的值。

例如：将数组中的每个数字扩大2倍

// for each 循环不能改变数组中每个元素的值
int[] ns = { 1, 4, 9, 16, 25 };
for(int temp : ns) {
    temp = temp << 1;
    System.out.println(temp);
}

// 输出[1, 4, 9, 16, 25]
System.out.println(Arrays.toString(ns));

扩展：除了数组外，for each循环能够遍历所有“可迭代”的数据类型，包括后面会介绍的List、Map等集合类。