Java基础回顾(3)

本小结主要包括以下知识点：
1.三种控制结构的应用以及break,continue,return三种语句的作用  
2.一维数组和二维数组的声明创建初始化及使用 
3.变长数组的使用

   一.三种控制结构的应用以及break,continue,return三种语句的作用  

Java 中是如何控制程序的执行顺序和方向的呢？事实上在Java执行的过程中，虚拟机通过Java程序中的三种流程控制语句来决定程序代码执行的顺序列，这些流程控制语句表现在Java三种不同的程序控制结构：顺序结构，选择结构和循环结构语句。通过这几种结构的语句，Java实现了程序流程的控制。

   顺序结构

就是程序从上到下一行一行执行的结构，中间没有判断和跳转，直到程序结束。

选择结构

程序具备多个分支，通过条件判断决定程序选择那一条分支执行，选择结构包括if语句和 switch语句。

if.语句：

也有人把if语句列为判断语句。

通过if...else if...else决定程序流程。

如果if中的条件满足则执行其中语句，if未满足则继续判断else if，如果满足则执行，不满足继续判断下一个else if，如果所有都不满足，则执行else。

例如：int n = 3;

if(n>5)

System.out.println("a");

else if(n>4)

System.out.println("b");

else if(n>3)

System.out.println("c");

else

System.out.println("d");

if else 结构 简写格式： 变量 = (条件表达式)?表达式1：表达式2；也就是即三元运算符：

例如： int a = 9,b;

b = (a>1)?100:200;

三元运算符语法：表达式 ? 结果1 : 结果2 

 如果表达式结尾为true取结果1，为false则取结果2。

 注意三元运算符也是有短路的效果，根据表达式的结果，只运行冒号一边的，另外一边的不参与运行。

用三元运算符代替if else语句的

好处：可以简化if else代码。

弊端：因为是一个运算符，所以运算完必须要有一个结果。

选择结构的第二种语句：

    switch语句：

通过switch...case...default语句控制程序流程。

根据switch后括号中的值判断运行哪一个case，这个值可以是byte、short、ch;ar、int。

default语句是可选的，如果所有case都不满足，则会执行default，即默认语句。一旦匹配到一个case，程序就会从这个case向下执行，执行完一个case之后不会跳过其他的case，如需跳过请使用break中止语句。

   int x = 4;

switch(x)

{

case 1:

System.out.println(x+"春季");

break;

case 2:

System.out.println(x+"夏季");

break;

case 3:

System.out.println(x+"秋季");

break;

case 4:

System.out.println(x+"冬季");

break;

default:

System.out.println("nono");

                                  }

  

if和switch语句很像。具体什么场景下，应用哪个语句呢？如果判断的具体数值不多，而是符合byte short int char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

循环结构

假如程序中有一段代码，我们需要对这同一段代码反复执行多次，我们可以使用循环结构的语句进行循环控制。什么时候使用循环结构？当要对某些语句执行很多次时，就使用循环结构。

    循环控制语句有三种：while 、do...while 、for。这三种语句配合continue、break、return语句达到控制代码循环的过程。

while先判断while中的表达式结果是否为true，true则执行循环体，执行结束之后再次判断，如果表达式结果为false则跳出循环。

while语句格式：

定义初始化表达式；

while(条件表达式)

{

循环体(执行语句);

}

例：

        i nt x = 1;

while(x<3)

{

System.out.println("x="+x);

x++;

}

do...while先执行一次循环体，然后判断while中的表达式，如果是true继续执行，如果是false则跳出循环。

do...while语句格式：

     定义初始化表达式；

          do

{

循环体(执行语句); }

while (条件表达式);

例：

        int x = 1;

do

{

System.out.println("do : x="+x);

x++;

}

while (x<3);

while:先判断条件，只有条件满足才执行循环体。do while: 先执行循环体，在判断条件，条件满足，再继续执行循环体。也就是说do while：无论条件是否满足，循环体至少执行一次。

for循环的括号中有三条语句，都是可选项。

for循环语句的格式：

for(  初始化表达式；循环条件表达式；循环后的操作表达式)

{

执行语句；

}

语句1初始化表达式：这条语句会在整个循环开始之前执行，且仅运行一次，不参与循环。

语句2循环条件表达式：必须是一个返回boolean值的表达式，如果写了这个语句那么每次循环开始之前会判断，true则执行循环，false则不执行。没写则直接执行。

语句3循环后的操作表达式：这条语句在每次循环体运行结束之后执行。

例：for(int x = 0; x<3 ; x++)

{

System.out.println("x="+x);

}

   continue、break、return语句。

continue：只能作用于循环结构，特点：结束本次循环，继续下一次循环。

break：结束循环

return：结束方法，将值返回给方法调用者。

二. 一维数组和二维数组的声明创建初始化及使用

★ 一维数组 
1． 一维数组的定义 

　　type arrayName[ ]； 
　　类型(type)可以为Java中任意的数据类型，包括简单类型和复合类型。 
　　例如： 
　　　int intArray[ ]； 
　　　Date dateArray[]; 


　　2．一维数组的初始化 

　　◇ 静态初始化 
　　　　int intArray[]={1,2,3,4}; 
　　　　String stringArray[]={"abc", "How", "you"}; 

　　◇ 动态初始化 
　　　 1）简单类型的数组 
　　　　int intArray[]; 
　　　　intArray = new int[5]; 

　　　2）复合类型的数组 
　　　　String stringArray[ ]; 
　　　　String stringArray = new String[3];/*为数组中每个元素开辟引用 
　　　　　　　　　　　　　　　　　　　　　 空间(32位) */ 
　　　　stringArray[0]= new String("How");//为第一个数组元素开辟空间 
　　　　stringArray[1]= new String("are");//为第二个数组元素开辟空间 
　　　　stringArray[2]= new String("you");// 为第三个数组元素开辟空间 

　　3．一维数组元素的引用 

　　数组元素的引用方式为： 
　　　　　arrayName[index] 

　　index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。 

★多维数组 

　　Java语言中，多维数组被看作数组的数组。 

　　1．二维数组的定义 

　　type arrayName[ ][ ]； 
　　type [ ][ ]arrayName; 

　　2．二维数组的初始化 

　　◇ 静态初始化 
　　int intArray[ ][ ]={{1,2},{2,3},{3,4,5}}; 

　　Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。 

　　◇ 动态初始化 
　　1) 直接为每一维分配空间，格式如下： 
　　arrayName = new type[arrayLength1][arrayLength2]; 
　　int a[ ][ ] = new int[2][3]； 

　　2) 从最高维开始，分别为每一维分配空间： 
　　arrayName = new type[arrayLength1][ ]; 
　　arrayName[0] = new type[arrayLength20]; 
　　arrayName[1] = new type[arrayLength21]; 
　　… 
　　arrayName[arrayLength1-1] = new type[arrayLength2n]; 

　　3) 例： 
　　二维简单数据类型数组的动态初始化如下, 
　　int a[ ][ ] = new int[2][ ]； 
　　a[0] = new int[3]; 
　　a[1] = new int[5]; 

　　对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。 
　　而且，必须为每个数组元素单独分配空间。 

　　例如： 
　　String s[ ][ ] = new String[2][ ]; 
　　s[0]= new String[2];//为最高维分配引用空间 
　　s[1]= new String[2]; //为最高维分配引用空间 
　　s[0][0]= new String("Good");// 为每个数组元素单独分配空间 
　　s[0][1]= new String("Luck");// 为每个数组元素单独分配空间 
　　s[1][0]= new String("to");// 为每个数组元素单独分配空间 
　　s[1][1]= new String("You");// 为每个数组元素单独分配空间 

　　3．二维数组元素的引用 
　　 
　　对二维数组中的每个元素，引用方式为：arrayName[index1][index2] 
　　例如： num[1][0]; 

　　4．二维数组举例： 

　　【例2．2】两个矩阵相乘 
　　public class MatrixMultiply{ 
　　　public static void main(String args[]){ 
　　　int i,j,k; 
　　　int a[][]=new int [2][3]; //动态初始化一个二维数组 
　　　int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化 
　　　　　　　　　　　　　　　　　　　　　　　　　　 一个二维数组 
　　　int c[][]=new int[2][4]; //动态初始化一个二维数组 
　　　for (i=0;i<2;i++) 
　　　　　for (j=0; j<3 ;j++) 
　　　　　　a[i][j]=(i+1)*(j+2); 
　　　for (i=0;i<2;i++){ 
　　　　　for (j=0;j<4;j++){ 
　　　　　　c[i][j]=0; 
　　　for(k=0;k<3;k++) 
　　　　　c[i][j]+=a[i][k]*b[k][j]; 
　　　　　　} 
　　　　　} 
　　　System.out.println("*******Matrix C********");//打印Matrix C标记 
　　　for(i=0;i<2;i++){ 
　　　　　for (j=0;j<4;j++) 
　　　　　　System.out.println(c[i][j]+" "); 
　　　　　System.out.println(); 
　　　　　　} 
　　　　　} 
　　　}


 三.变长数组的使用

 Java代码  

1. public class ArrayTest {  
2.     public static void newBehaviour(int... args) {  
3.         System.out.println("数据长度为:" + args.length);  
4.     }  
5.   
6.     public static void main(String[] args) {  
7.         // 可不传参数  
8.         newBehaviour();  
9.           
10.         int[] a = {1,2,3,4};  
11.         newBehaviour(a);  
12.           
13.         // 参数为null时有异常  
14.         newBehaviour(null);  
15.     }  
16. }  

输出结果: 

Java代码  

1. 数据长度为:0  
2. 数据长度为:4  
3. Exception in thread "main" java.lang.NullPointerException