跳至主要內容

程序逻辑结构

wangdx大约 7 分钟

程序逻辑结构

简介

  程序逻辑是编程语言中的重要组成部分，Java 的程序的结构有 3 种: 顺序结构、选择(分支)结构和循环结构。这 3 种不同的结构有一个共同点，就是它们都只有一个入口也只有一个出口。程序中使用了上面这些结构有什么好处呢?单一的入口与出口可以让程序易读、好维护，可以减少调试的时间。

顺序结构流程图

  本书前两章所讲的例子采用的都是顺序结构，程序自上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾

选择(分支)结构

  • 选择(分支)结构是根据判断条件的成立与否再决定要执行哪些语句的一种结构
  • 这种结构可以依据判断条件的结构来决定要执行的语句。当判断条件的值为真时则执“语 1”当判断条件的值为假时，则执行“语句 2”。不论执行哪一条语句，最后都会回到“语句 3”继续执行。

循环结构

循环结构是根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落就被称为循环主体。

if 分支结构

if 分支结构主要是针对于逻辑运算的处理结果来判断是否执行某段代码，在 Java 中可以使用 if 与 else 两个关键字实现此类结构，一共有以下 3 种组合形式

if(flag){
  ...
}

if(flag){
  ...
}else{
  ...
}

if(flag){
  ...
}else if(flag1){
  ...
}else if(flag2){

}else{

}
案例
int age=20;
if(age>=18 && age<=22){
  System.out.println("我是大学生，拥有无穷拼搏和探索精神！")
}
System.out.println("开始拼搏吧！")

double money = 20.00;
if(money >= 19.8){
  System.out.println("大胆地走到售卖处，很霸气地拿出20元，说不用找了，来分盖浇饭！")
}else{
  System.out.println("在灰暗的角落等待着被人剩下饭菜。")
}
System.out.println("好吃好喝！")


double score = 90.00;
if(score >= 90.00 && score <= 100){
  System.out.println("优等生。")
}else if(score >= 60 && score < 90){
  System.out.println("良等生。")
}else{
  System.out.println("差等生。")
}

switch 分支结构

switch 是一个开关语句，它主要根据内容进行判断。需要注意的是，switch 语句只能判断数据(int、char、枚举、String)，而不能使用布尔表达式进行判断

switch (数值|字符|枚举|String){
  case 内容1:
    ...
    [break;]
  case 内容2:
    ...
    [break;]
  default:
    ...
    [break;]
}
案例
int ch = 1;
switch (ch){
  case 2:
    System.out.println("2差等生。");
  case 1:
    System.out.println("1差等生。");
  default:
   System.out.println("default差等生。");
}

1差等生。
default差等生。

int ch = 1;
switch (ch){
  case 2:
    System.out.println("2差等生。");
    break;
  case 1:
    System.out.println("1差等生。");
    break;
  default:
   System.out.println("default差等生。");
   break;
}

1差等生。

int msg = 'yix';
switch (msg){
  case 'yootk':
    System.out.println("yootk差等生。");
    break;
  case 'yix':
    System.out.println("yix差等生。");
    break;
  default:
   System.out.println("default差等生。");
   break;
}

yix差等生。

yield 关键字

这个关键字的主要作用是进行 vield 是在 JDK13 之后正式加入到 Java 中的新的关键字，内容的局部返回，现阶段其主要的设计是结合 switch 语句来使用的。

案例
public class YieldDemo {
    public static void main(String[] args) {
        String data = "one";
        int result = switch(data){
            case "one":yield 1;
            case "two":yield 2;
            default:{
                yield -1;
            }
        };
        System.out.println(result);
    }
}

while 循环结构

while 循环是一种较为常见的循环结构，利用 while 语句可以实现循环条件的判断，当判断条件满足时则执行循环体的内容，Java 中 while 循环结构有以下两类:

while(判断条件){
  循环语句;
  修改循环结束条件;
}
do{
  循环语句;
  修改循环结束条件;
}while(判断条件)
案例

使用 while 实现 1~100 累加

int sum = 0;
int num = 1;
while(num <=100){
  sum+=num;
  num++;
}
System.out.println(sum);

5050

使用 do while 实现 1~100 累加

int sum = 0;
int num = 1;
do{
  sum+=num;
  num++;
}while(num <=100)
System.out.println(sum);

5050

for 循环结构

已经明确的知道了循环次数的时候，就可以通过 for 循环结构更加简单的进行循环处理首先来观察一下 for 循环的语法结构:

for(循环初始化条件；循环判断；循环条件变更){
  循环体；
}
案例：使用 for 实现数据累加
int sum =0 ;
for(int i=0;i<=100;i++){
  sum +=i;
}
System.out.println(sum);

5050

循环嵌套

循环结构可以在内部嵌入若千个子的循环结构，这样可以实现更加复杂的循环控制结构但是需要注意的是，这类循环结构有可能会导致程序复杂度的提升。

案例 打印乘法口诀表 打印三角形
public class CfDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

打印三角形

public class SanDemo {
    public static void main(String[] args) {
        int line = 5;
        for (int x = 0; x < line; x++) {
            for (int y = 0; y < line - x; y++) {
                System.out.print(" ");
            }
            for (int y = 0; y <= x; y++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

     *
    * *
   * * *
  * * * *
 * * * * *

方法作用概述

方法(Method，在很多语言中也被称为“function、函数”)指的是一段可以被重复调用的代码块，利用方法可以实现庞大程序的拆分，是一种代码重用的技术手段，并目更加适合于代码维护，在一个设计合理的软件项目中往往会大量的采用方法管理程序结构

方法基本定义

在程序开发中经常会遇见各种重复代码的定义，为了方便管理这些重复的代码，就可以通过方法结构保存这些重复代码，实现可重复地调用，如果要进行方法的调用则可以通过以下定义格式

public static 返回值类型 方法名称（参数类型 参数变量，。。。）{
  方法体；
  【return [返回值]】
}
案例

定义无参无返回方法

public static print(){
  System.out.println("method无参无返回");
}

定义有参有返回方法

public static print(String msg){
  System.out.println("method无参无返回");
  return mst+".com";
}

public static print(int amount){
  if(amount<=0){
    return; //后续方法不执行
  }
  System.out.println("method无参无返回");
}

方法重载

  • 方法重载是方法名称进行重用的一种技术形式，其最主要的特点为“方法名称相同，参数的类型或个数不同”，在调用时会根据传递的参数类型和个数不同执行不同；
  • 如果说现在有一个方法名称，有可能要执行数据的加法操作，例如，一个 sum() 方法也可能执行 3 个整数的相加，或者可能执行 2 个小数的相加它可能执行 2 个整数的相加，很明显，在这样的情况下，一个方法体肯定无法满足要求，需要为 sum()方法定义多个不同的方法体，所以此时就需要方法重载概念的支持。的方法体。

方法递归调用

递归调用是一种特殊的调用形式，指的是方法自己调用自己的形式，但是在进行递归操作的时候必须满足以下的几个条件。

  • 递归调用必须有结束条件。
  • 每次调用的时候都需要根据需求改变传递的参数内容
案例

public static void main(String[] args) {
    System.out.println(sum(100));
}

public static int sum(int num){
  if(num ==1){
    return 1;
  }
  return num+sum(num-1);
}

1!+2!+3!+...+90!


public static void main(String[] args) {
    System.out.println(sum(90));
}

public static double sum(int num){
  if(num ==1){
    return factorial(1);
  }
  return factorial(num)+sum(num-1);
}
public static double factorial(int num){
  if(num ==1){
    return 1;
  }
  return num*factorial(num-1);
}
上次编辑于:
MIT Licensed | Copyright © 2024-present WDX