Java基础篇之顺序、选择、循环结构

程序流程

 java程序语句执行的顺序包括4种基本控制结构：顺序结构、选择结构、循环结构、异常处理逻辑结构。

顺序结构

 Java程序中，语句执行的基本顺序按各语句出现的位置先后顺序执行，即为顺序结构。

• 例1：顺序结构：已知三角形三边，求三角形面积：

public class Inorder {
    public static void main(String[] args) {
     double a, b, c, p,area;
        Scanner scan = new Scanner(System.in);//Scanner可用于扫描控制台输入
        System.out.print("请输入三角形的边A:  ");
        String s = scan.nextLine();
        a = Double.parseDouble(s); //将数字字符串转换成等效的双精度浮点数
        System.out.print("请输入三角形的边B：  ");
        s = scan.nextLine();
        b = Double.parseDouble(s); //将数字字符串转换成等效的双精度浮点数
        System.out.print("请输入三角形的边C：  ");
        s = scan.nextLine();
        c = Double.parseDouble(s); //将数字字符串转换成等效的双精度浮点数
        System.out.printf("三角形的三边分别为：a =%6.1f,b=%6.1f,c=%6.1f\n",a,b,c);
        p = (a+b+c)/2;
        area = Math.sqrt(p*(p-a)*(p-b)*(p-c));
        System.out.printf("三角形的面积是= %8.1f\n",area);
    }
 }

• 运行结果：

请输入三角形的边A:  3
请输入三角形的边B：  4
请输入三角形的边C：  5
三角形的三边分别为：a =   3.0,b=   4.0,c=   5.0
三角形的面积是=      6.0

• 这里用到了Scanner类，Java 5添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。例子中用到到了Scanner类的一个常用方法nextline()，同时下面将nextline()和next()两个方法做简单对比：

package kkee;
import java.util.Scanner; //导入包
/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 15:44
 */
public class Text {
    public static void main(String []args) {
        Scanner scanner = new Scanner(System.in);
      //  System.out.println("请输入一个字符串(中间能加空格或符号)");
        // String a = scanner.nextLine();
        System.out.println("请输入一个字符串(中间不能加空格或符号)");
        String b = scanner.next();
       /* System.out.println("请输入一个整数");
        int c;
        c = scanner.nextInt();
        System.out.println("请输入一个double类型的小数");
        double d = scanner.nextDouble();
        System.out.println("请输入一个float类型的小数");
        float f = scanner.nextFloat();
        System.out.println("按顺序输出abcdf的值：");
        System.out.println(a);*/
        System.out.println(b);
       // System.out.println(c);
       // System.out.println(d);
       // System.out.println(f);
    }
}

• 运行结果：

请输入一个字符串(中间能加空格或符号)
solo
请输入一个字符串(中间不能加空格或符号)
solo
请输入一个整数
123
请输入一个double类型的小数
12.1234
请输入一个float类型的小数
2.34567
按顺序输出abcdf的值：
solo
solo
123
12.1234
2.34567

• 当在next()方法下，输入带符号或空格的值，所得结果：

请输入一个字符串(中间不能加空格或符号)
so lo
so

  总结：
（1) next():只读取输入直到空格，无法识别空格键，遇到即退出。它不能读两个由空格或符号隔开的单词。此外，next()在读取输入后将光标放在同一行中。(next()只读空格之前的数据,并且光标指向本行)
（2）nextLine():读取输入，包括单词之间的空格和除回车以外的所有符号。读取输入后，nextLine()将光标定位在下一行。
（3）nextlnt():只读取int值，就是只能读取整数类型的数据，如果输入了非整型的数据（浮点型字符串等）就会报错。 nextFloat()、nextDouble()这些也是以此类推，只能读取符合该类型的数据。

选择结构

 选择结构根据条件来控制代码的执行分支，也成分支结构。Java包括两种控制分支的条件语句，if语句、switch语句。

• if语句包含多种形式：单分支、双分支、多分支。
• （1）单分支：语法形式：
   if(条件表达式)
    语句/语句块；
   该语句的作用是当条件表达式的值为真（true）时，执行if后的语句（块），否则不做任何操作，控制转到if语句的结束点。
• 典例：判断当前年，是否为闰年？
• 1.年份能被4整除并且不能被100整除；
  2.能被400整除；

public class Year {
        public static boolean loopYear ( int year){
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                return true;
            }
            return false;
        }
    public static void main(String[] args) {
       boolean k = loopYear(2018);
       System.out.println(k);
    }
}

false

• （2）双分支：语法形式：
   if(条件表达式)
    语句/语句块1；
  else
   语句/语句块2；
   该语句的作用是当条件表达式的值为真时，执行if后的语句/语句块1，否则执行语句/语句块2。
• 典例：输入两个数，判断两个数的大小。

public class Copab {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入2个整数：");
        int a = s.nextInt();
        int b = s.nextInt();
        if(a < b){
            System.out.println("a < b");
        }else{
            System.out.println("a>b");
        }
    }

请输入2个整数：
2
3
a < b

• (3)多分支：
   if(条件表达式1)
    语句/语句块1；
  else if(条件表达式2)
   语句/语句块2；
  else if(条件表达式2)
   语句/语句块2；
  ……
• 典例:已知课程的成绩，根据成绩80-100、70-80、60-70、60以下，将其分等级为A、B、C、D。输入成绩时，输出评价。

public class Grade {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int mark = scanner.nextInt();
        if(mark >= 80) {
            System.out.println('A');
        } else  if(mark >=70   && mark <=80 ){
            System.out.println('B');
        }else if(mark >=60 && mark <=70 ){
            System.out.println('C');
        }else if(mark <60 ){
            System.out.println('D');
        }
    }
}

请输入成绩：
68
C

• (4)if语句的嵌套:
   if(条件表达式1){
    if(条件表达式2){
    语句/语句块1;
   }else{
   语句/语句块2;}
  }
• switch语句是一个控制语句，它通过将控制传递给其体内的case语句来处理多个选择和枚举。
  -语法形式：
  switch(表达式){
  case 常量表达式1: 语句1;
  break;
  case 常量表达式2: 语句2;
  break;
  …
  case 常量表达式n: 语句n;
  break;
  default: 语句n+1;
  break;
  }
• 典例：已知课程的成绩，根据成绩80-100、70-80、60-70、60以下，将其分等级为A、B、C、D。输入等级时，输出成绩范围。

package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 22:26
 */
public class School {
    public static char fun(char ch) {
        switch (ch) {
            case 'A':
                System.out.println("80-100");
                break;
            case 'B':
                System.out.println("70-80");
                break;
            case 'C':
                System.out.println("60-70");
                break;
            case 'D':
                System.out.println("60以下");
                break;
            default:
                System.out.println("没救了！");
                break;
        }
        return ch;
    }
    public static void main(String[] args) {
        char k = fun('A');
        System.out.println(k);

    }
}

80-100
A

• 注意：
   （1）switch控制表达式所允许的数据类型：整型类型（byte、short、int）、字符类型（char）和枚举类型；不能允许的数据类型有：double、long、float。
   （2）case标签后的常量表达式只能是常数或者常量，不能为变量。

循环结构

 Java提供了4种不同的循环机制：for、while、do…while、for each，在满足某个条件之前，可以重复执行代码块。

• for循环是计数型循环语句，一般用于已知循环次数的情况，所以也称定次循环。
• for(初始化设置表达式；循环执行条件；循环变量的增减量)
  { 循环语句序列 }
• 典例：求输入的数字是否为素数？

 public static boolean isPrime(int n){
        for (int a = 2; a > 2; a++){
           if( n % a == 0) {
               return false;
           }
        }
        return true;
    }

• 典例：求5的阶乘。

package kkee;



/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 23:05
 */
public class fun {
     public static int Pulse(int n) {
        int j = 1;
        for (int i = 1; i <= n; i++) {
            j = j * i;
        }
         return  j;
    }
    public static void main(String[] args) {
        int k = Pulse(5);
        System.out.println(k);
    }
}

• 典例：求1-100之内的和，1-100之内奇数的和。

package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 23:17
 */
public class SumAll {
    public static void main(String[] args) {
        int sum = 0;
        int sumOdd = 0;//奇数和
        int sumEven = 0;//偶数和
        for(int i = 1;i <= 100;i += 1){
            sum += i;
        }
        for(int i = 1;i <= 100;i += 2){
            sumOdd += i;
        }
        for(int i = 2;i <= 100;i += 2){
            sumEven += i;
        }
        System.out.printf("1-100中所有数的和为%d、奇数和为%d、偶数和为%d\n",sum,sumEven,sumOdd);
    }
}

1-100中所有数的和为5050、奇数和为2550、偶数和为2500

• 注意：
   （1）for 循环中，第二个参数若没有，则默认为真；
   （2）for 循环结构中的3个表达式都可省略。例如，下列程序片创造了一个无限循环，for（；；）{ //This will run forever }
• Tips:
• (1)求斐波那契数列的前40项的和？
   斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……特别指出：第0项是0，第1项是第一个1。这个数列从第3项开始，每一项都等于前两项之和。

package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 14:04
 */
public class Main {
    public int Fob(int n){
        if (n < 0)
            return -1;//终止递归
        if ( n == 1 || n == 2)
            return 1;
        return Fob(n-1)+Fob(n-2);//递归调用
    }
    public static void main(String[] args) {
        Main main = new Main();//实例化对象
        int sum = 0;
        for (int i = 1; i <= 40 ; i++) { //循环次数40,即前40项
            sum += main.Fob(i);//求和
        }
        System.out.println(sum);//打印并输出
    }
}

267914295

• (2)用for循环产生20个随机数（10-20）。
   应用Math类的Random()方法，Math.random() – 返回0和1之间的伪随机数 可能为0，但总是小于1，[0,1)； a-b： Math.random() *(b-a)+a 。

package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 10:47
 */
// 用for循环产生20个随机数（10-20）
//  a-b;  Math.random() *(b-a)+a      Math.random():[0,1)  double
public class RandomNumber {
    public static void main(String[] args) {
        for(int i = 0; i < 20; i++){      //控制循环次数，即产生随机数个数
            double a = (double) (Math.random()*10+10);
                                       //a-b;  Math.random() *(b-a)+a
                                      //设置随机数产生范围10-20
            System.out.print(a+"\n");//换行输出
        }
    }
}

12.981837264734592
13.006022254093143
12.487037794538924
13.145405893027164
12.458942902107488
15.43507744667718
14.259679971672586
15.509221626909214
19.940084712858457
19.772918004113755
13.68682288744929
14.386686400881068
17.878611177117385
10.93307850365068
17.73783786843079
17.264961318332702
11.128319978032376
16.24171939063554
10.588602457917593
10.624208022042762

• (3)输入一个数字，求他是几位数，并且顺序输出，逆序输出。
   charAt(int index)方法是一个能够用来检索特定索引下的字符的String实例的方法，charAt()方法返回指定索引位置的char值。

package kkee;
import java.util.Scanner;//导入Scanner

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 11:43
 */
public class Order {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//获得从控制台输入的参数
        String str = scanner.nextLine();//nextline()方法
        System.out.println("这个数是：" + str.length() + "位");
        System.out.println("顺序输出为：" + str);
        System.out.print("逆序输出为：");
        for(int i = str.length() - 1; i >= 0; i--) {
            System.out.print(str.charAt(i));//str.charAt()检索str中的字符，并打印
        }
    }
}

1234
这个数是：4位
顺序输出为：1234
逆序输出为：4321

• (4)求一个数字的二进制数有几个1?

package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 15:03
 */
public class funn {
    public static int getBinary(int value){  
        int count = 0;
        int remainder = 0;
        while (value != 0){
            remainder = value % 2;  //存储余数
            if (remainder == 1)
                count++;
                value = value / 2;
        }
        return count;  //返回count的值
    }
    public static void main(String[] args) {
        int k = getBinary(8);
        System.out.println(k);
    }
}

1

Over…