为了做出springboot前后端分离的科研项目管理系统努力学习6

顺序结构

java的基本结构就是顺序结构。

是最简单最基本的算法结构。

语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的。

package com.study.struct;

public class ShunXuDemo {
    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单选

package com.study.struct;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        //equals：判断字符串是否相等  对于字符串equals比==更安全
        //以后遇到匹配字符串的时候就用equals
        if (s.equals("Hello")){
            System.out.println(s);
        }

        System.out.println("End!");
        scanner.close();
    }
}

• if双选

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

package com.study.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("请输入学生成绩：");
        float i=scanner.nextFloat();

        if (i>=60){
            System.out.println("成绩合格！");
        }else {
            System.out.println("成绩不合格！");
        }

        scanner.close();
    }
}

• if多选

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

package com.study.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60就是不及格
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入学生成绩：");
        float i = scanner.nextFloat();

        if (i >= 90 && i <= 100) {
            System.out.println("成绩优秀！");
        } else if (i >= 60 && i < 90) {
            System.out.println("成绩合格！");
        } else if (i >= 0 && i < 60) {
            System.out.println("成绩不合格！");
        } else {
            System.out.println("输入成绩不合法！");
        }

        scanner.close();
    }
}

注意：在写分支的时候应尽可能的将每种情况考虑进来。 

• 嵌套的if结构

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

• switch多选择结构

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch case 语句有如下规则：

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

• switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。

• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。

• 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

• switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

package com.study.struct;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "aaaaaaa";

        //JDK新特性：可以匹配字符串String类型的数据
        switch (name) {
            case "Liangjuhan":
                System.out.println("Liangjuhan");
                break;
            case "lili":
                System.out.println("lili");
                break;
            case "han":
                System.out.println("han");
                break;
            default:
                System.out.println("弄啥嘞！");
        }
    }
}

找到反编译文件：

 从文件夹中将class文件拷贝进项目目录下在idea中打开

 就可以看到反编译文件了

 

---

循环结构

• while循环

只要布尔表达式为TRUE，循环就会一直执行下去。

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

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

我们正常情况下应该尽量避免死循环（程序要有出口）。

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

package com.study.struct;

public class WhileDemo01 {
    public static void main(String[] args) {

        //输出1~100
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
        }
    }
}

 

package com.study.struct;

public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+...+100=?
        int i = 0;
        int sum = 0;

        while (i < 100) {
            i++;
            sum = sum + i;
            System.out.println(i);
        }
        System.out.println("sum=" + sum);
    }
}

 

 

• do...while循环

do while是先执行后判断，总是保证循环体会被至少执行一次。

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

 

package com.study.struct;

public class WhileDemo04 {
    public static void main(String[] args) {
        //do...while    程序体至少被执行一次
        int i = 0;

        while (i < 0) {
            System.out.println(i);
            i++;
        }

        do {
            System.out.println(i);
            i++;
        } while (i < 0);

    }
}

 

  

• for循环！！重要

for循环可以使结构更简单。

快捷键

100.for+回车        直接生成下面的

for (int i = 0; i < 100; i++) {
    
}

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

package com.study.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) {
                evensum = evensum + i;
            }
            if (i % 2 != 0)
                oddsum += i;
        }
        System.out.println("奇数和为：" + oddsum);
        System.out.println("偶数和为：" + evensum);
    }
}

 

package com.study.struct;

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

        for (int i = 1,arr=0; i <= 1000; i++) {

            if (i%5==0){
                System.out.print(i+" ");
                arr++;
                if (arr%3==0)
                    System.out.print("\n");
            }

        }
    }
}

 

package com.study.struct;

public class ForDemo04 {
    public static void main(String[] args) {
        //打印九九乘法表
        for (int i = 1; i <= 9; i++) {
            for (int j = i; j <= 9; j++) {
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

 

 

• 在java5引入了增强for循环，主要用于遍历数组和集合对象

for(声明语句 : 表达式)
{
   //代码句子
}

package com.study.struct;

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

        //遍历数组的元素
        for (int i = 0; i < 5; i++) {
            System.out.print(number[i]+"\t");
        }

        System.out.println("\n=====================");

        //遍历数组的元素
        //主要用来遍历数组和集合
        for (int x:number){ //将number的值赋给x  与上面是一样的功能：简化版for循环
            System.out.print(x+"\t");
        }
    }
}

 

---

 break&continue

break强制退出循环！

package com.study.struct;

public class BreakDemo {
    public static void main(String[] args) {
        int i=0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30)
                break;
        }
        System.out.println("break终止循环！");
    }
}

 continue终止某次循环，跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断。

package com.study.struct;

public class ContinueDemo {
    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+" ");
        }
    }
}

 

---

goto关键字

java没有goto,但是可以在break和continue加上标签，跳转标记。

标签是指后面跟一个冒号的标识符，例如：label：

对于java来说唯一用到标签的地方是在循环之前！

在循环之前设置标签的唯一理由是：希望在循环中嵌套另一个循环，由于break和continue关键字通常只能中断当前循环，但若随标签使用，就会中断到存在标签的地方。

 了解就好！不建议使用！

package com.study.struct;

public class LabelDemo {
    public static void main(String[] args) {
        //打印101-150之间所有的质数

        //质数：大于一的自然数中，除了1和它本身外不再有其他因数的自然数

        int count = 0;

        //定义标签outer
        outer:
        for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0)     //判断是否有其他因数
                    continue outer; //通过continue返回到标签的位置
            }
            System.out.print(i+" ");
        }
    }
}