JAVA-基本程序设计结构（控制流程、数组）

1.控制流程

1.块作用域

1.块（即复合语句）由若干条Java语句组成，并用一对大括号括起来。

2.块确定了变量的作用域。

3.一个块可以嵌套在另一个块中。但是不能在嵌套的两个块中声明同名的变量。

2.顺序控制

顺序控制：程序从上到下逐行地进行，中间没有任何判断和跳转

Java中定义成员变量时采用合法的前向引用。（即声明在使用前）

3.分支控制

分支控制 if-else 有三种：单分支、双分支、多分支

1.单分支

基本语法：

if(条件表达式){
    执行代码块;(可以有多条语句)
}

2.多分支

基本语法：

if(条件表达式){
    代码执行块1;
}
else{
    代码执行块2;
}

3.嵌套分支

基本语法：

if(){
    if(){
       //if-else...   
  }else{
       //if-else...
  }
}

4.switch分支结构

基本语法：

switch (表达式){
            case 常量1:
                语句块1;
                break;
            case 常量2:
                语句块2;
                break;
            ……
            case 常量n:
                语句块n;
                break;
            default :
                default语句块;
        }

1.switch 关键字表示switch分支

2.表达式表示一个值。switch中表达式的返回值必须是：byte、short、char、int、String、enum

3.case 标签可以是

• 类型为 char、byte、short 或 int 的常量表达式
• 枚举常量
• 字符串字面量
• 多个字符串，用逗号分隔

case子句中的值不可以是变量

4.switch 语句从与选项值相匹配的 case 标签开始执行，直到遇到下一个break语句，或者执行到switch语句结束。如果没有匹配的case标签，则执行default子句（如果存在default子句）

   如果当前执行分支语句块没有break语句，就会顺序执行下一个分支，直到遇到break语句或执行到switch语句结束。

5.switch流程图

7.表达式数据类型，应与case后常量类型一致，或者是可以自动转化为相互比较的类型

例如输入字符(char)，而case后是int常量

8.switch语句共有四种形式：无直通表达式、直通表达式、无直通语句、直通语句

• 语句无返回值，表达式有返回值（switch表达式每个分之后必须生成一个值）
• 直通——无break或yield结束语句的情况下会执行下一语句直到switch语句结束，无直通——执行完当前分支语句后会结束switch语句
• 在有直通行为的形式中，每个case以一个冒号结束。如果case以箭头->结束，则没有直通行为。不能在一个switch语句中混合使用冒号和箭头。
• swicth表达式中的yield关键字与break类似，yield会终止执行但与break不同，yiled会生成一个值，就是表达式的值
• 要在switch表达式的一个分支中使用语句而不想有直通行为，就必须使用大括号和yield

int numLetters = switch (seasonName)
        {
            case "Spring" ->
            {
                System.out.println("Spring time!");
                yield 6;
            }
            case "Summer","Winter" -> 6;
            case "Fall" -> 4;
            default -> -1;
        };

switch (seasonName)
        {
            case "Spring" ->
            {
                System.out.println("Spring time!");
                numLetters = 6;
            }
            case "Summer", "Winter" -> numLetters = 6;
            case "Fall" -> numLetters = 4;
            default -> numLetters = -1;
                
        }

int numLetters = switch (seasonName)
        {
            case "Spring" :
                System.out.println("Spring time!");
            case "Summer","Winter" :
                yield 6;
            case "Fall" :
                yield 4;
            default :
                yield -1;
        };

switch (seasonName)
        {
            case "Spring" :
                System.out.println("Spring time!");
            case "Summer", "Winter" :
                numLetters = 6;
                break;
            case "Fall" :
                numLetters = 4;
                break;
            default :
                numLetters = -1;
        }

9.switch表达式的关键是生成一个值（或产生一个异常而失败）。不允许跳出表达式。具体来讲，不能在switch表达式中使用 return、break 或 continue语句。

4.中断流程控制的语句

1.Java 提供了一种带标签的break语句，允许跳出多重循环的嵌套。

2.标签必须放在你想要跳出的最外层循环之前，并且必须紧跟一个冒号。

 Scanner in = new Scanner(System.in);
        int n;
        read_data:
        while(...)
        {
            .......
            for(...)
            {
                System.out.println("Enter a number >=0: ");
                n = in.nextInt();
                if(n < 0)
                {
                    break read_data;
                }
            }
        }

3.如果输入有误，执行带标签的break会跳转到带标签的语句块末尾。与任何使用break语句代码一样，接下来是检测循环输出是正常退出，还是由于break提前退出

4.continue语句与break语句一样，他将中断正常的控制流程。continue语句将控制转移到最内层外围循环的首部。若在for循环中使用continue语句，会跳转到for循环"更新"的部分。

5.带标签的continue语句将跳转到有匹配标签的循环的首部

5.循环控制

1.for循环控制

 基本语法：

for (循环变量初始化;循环条件;循环变量迭代)
        {
            循环操作(语句);
        }

1.for循环是返回一个布尔值的表达式

2.for循环(;循环判断条件;)中的初始化和变量迭代可以写到其他地方，但是两边分号不能省略

3.循环初始值可以有多条语句，但要求类型一样，并且中间用逗号隔开。

   循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

2.while循环控制

 基本语法：

while(循环条件){
            循环体(语句);
            循环变量迭代;
        }

1.循环条件是返回一个布尔值的表达式

2.while循环时先判断在执行语句

3.do..while循环控制

基本语法：

do{
            循环体(语句);
            循环变量迭代;
        }while(循环条件);

1.do while是关键字

2.先执行，在判断，所以至少会执行一次

3.最后有一个分号，不要忘记

4.多重循环

1.将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for、while、do...while均可以作为外层循环和内层循环。

2.嵌套循环就是把内层循环当成外层循环的循环体。当内层循环条件为false时，跳出内层循环，才可结束当次外层循环，开始下一次循环。

3.设外层循环次数为m，内层循环次数为n，该循环总共需要执行m*n次

2.数组

1.数组介绍

1.数组是一种数据结构，用来存储同一类型值的集合。通过一个整形索引（index，或称下标）可以访问数组中的每一个值。

  数组也是一种数据类型，是引用类型。

  数组引用—— 数组名[下标/索引]。  数组的下标（索引）是从0开始的

 2.在声明变量时，需要指出数组类型（元素后面紧跟[]）和数组变量名。

int[] a 或 int a[]

    在创建数组时应使用——new操作符

    数组长度不要求是常量，但是一旦创建数组，就不能再改变它的长度

3.数组初始化

• 动态初始化
  

  数据类型 数组名[] = new 数据类型[大小]
  int[] a = new int[10];

• 静态初始化
  

  数据类型 数组名[] = {元素值,元素值};
  静态初始化不需要使用new操作符，也不用指定长度
  最后一个值后允许有逗号，方便后续的添加

  还可以声明 匿名数组

  数组名 = new int[] {元素值,元素值,};
  这个表达式会分配一个新数组并填入大括号中提供的值。它会统计初始值的个数，并相应地设置数组大小。可以使用这种语法重新初始化一个数组而无须创建新变量

• 在Java中，允许有长度为0的数组。长度为0的数组与null并不相同

4.数组中的值可以是任何数据类型，包括基本类型和引用类型，但不能混用

5.数组创建后，如果没有进行赋值，有默认值 int 0, byte 0, short 0, long 0, float 0.0, double 0.0, char \u0000, boolean false, String null

6.数组下标必须在指定范围内使用，否则会报错：下标越界异常

7. 数组属于引用类型，数组型数据是对象。

2.数组赋值

1.基本数据类型赋值，这个值就是具体的数据，而且相互不影响

   赋值方式为值拷贝，不会相互影响

int n1 = 2; int n2 =n1;

2.数组在默认情况下是引用传递，赋的值是地址

int[] arr1 = {1,2,3};
int[] arr2 = arr1;

3.值传递/值拷贝和引用传递

3.多维数组

1.动态初始化

语法： 类型[][] 数组名 = new 类型[(该维-1)一维数组大小][元素大小]

除最后一维数组存放元素外，其他维度存放的均为地址

语法2：

1.先声明：类型 数组名[][];

再定义（开辟空间）：数组名 = new 类型[大小][大小]

最后赋值

语法3：自定义数组（列数不同）

先声明，在分别给各个一维数组定义大小

例如：杨辉三角形

int[][] arr = new int[20][];
        for(int i = 0; i < arr.length; i++ )
        {
            arr[i] = new int[i+1];
            for(int j = 0; j < arr[i].length; j++ )
            {
                if(j == 0 || j == arr[i].length-1)
                {
                    arr[i][j] = 1;
                }
                else {
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }
        for(int i = 0; i < arr.length ; i++ )
        {
            for(int j = 0; j < arr[i].length; j++ )
            {
                System.out.print(arr[i][j]);
                if(j!=arr[i].length-1)
                {
                    System.out.print(" ");
                }
                else
                {
                    System.out.println();
                }
            }
        }

2.静态初始化

定义：类型 数组名[][] = {{值1,值2,...},{值1，值2},{值1}};