Java语言程序（二）

流程控制

流程控制结构主要可分为三种：顺序结构、分支结构(选择结构)和循环结构(重复结构)。流程控制语句可分为三类：选择、循环和跳转。

顺序结构

以程序的第一行语句为入口点，自上而下执行到程序最后一行语句。

分支结构（选择结构）

使用"条件判断"表达式的运算结果来决定程序的流程，如果条件为真，执行为真的流程分支，如果不为真，就执行否定的流程分支。

if语句

表现形式1：如果布尔表达式为true，就运行代码块1，否则运行后面代码。

if(布尔表达式){
	代码块1
}

if-else语句

表现形式1：如果布尔表达式为true，就运行代码块1，否则运行代码块2。

if(布尔表达式){
	代码块1
}else{
	代码块2
}

表现形式2：程序依次判断布尔表达式，如果为true时，执行相应代码块，忽略下面的流程判断，否则执行下面的布尔表达式，如果所有布尔表达式都为false，则执行else下的代码块(else可写可不写)。

if(布尔表达式1){
	代码块1
} else if(布尔表达式2){
	代码块2
} else if(布尔表达式3){
	代码块3
} … …
else if(布尔表达式n){
	代码块n
} else{
	代码块
}

switch-case语句

switch表达式的值与case的常量依次比较，如果相等，就执行相应case后的代码块，如果没有与switch表达式的值相等的常量，就执行default后的代码块。（表达式可为byte、short、char和int，case的值必须与switch表达式类型一致且不能重复）

switch(表达式){
    case 选择值1 :
       代码块
       break; //可选
    case 选择值2 :
       代码块
       break; //可选
    ......//你可以有任意数量的case语句
    default : //可选
       代码块
}

循环结构

一种循环控制，根据所设定的条件重复执行某一段语句，直到条件为否，才结束循环。

for语句

先执行初始化的代码，只执行一次，然后判断是否满足循环条件，循环条件是boolean类型，如果为true，就执行循环体中代码，最后执行迭代部分。再次判断循环条件，直到条件为false时，结束循环。for循环语句是可嵌套的。(理论上：初始化、循环条件、迭代部分都可不写，这时该循环为无限循环，即死循环)

for(初始化; 循环条件; 迭代部分){
	循环内容;
}

foreach语句

JDK1.5后提出的。方便数组输出。

foreach(数据类型 变量名 : 数组){
	循环内容;
}

while语句

循环条件必须为布尔类型。先判断条件是否为真，如果为真，就执行循环体中的代码，为假时，就跳过循环。

while(循环条件){
	循环内容;
}

do-while语句

与while语句相似，区别：do-while语句是先执行循环体内的代码块，然后判断条件是否为真。如果循环条件的值为 true，则代码块一直执行，直到循环条件的值为 false。

do{
	代码块;
} while(循环条件);

跳转语句

• break语句：可强制中断循环，即跳出当前循环。当程序执行到break语句时，即会离开循环，继续执行下一个语句。如果break语句出现在嵌套循环中的内层循环，就会跳出当前层的循环，执行外层循环。

break;

• continue语句：可强制程序跳转到循环的起始处，即中断一次循环。当程序执行到continue语句时，会停止运行剩余的循环体，回到循环开始处继续执行。

continue;

• return语句：可终止程序当前所在方法回到调用方法的程序语句。return语句作为函数调用的返回语句，使用return语句时，可将方法中变量值或表达式运算的结果值返回给调用的程序语句。

数组

数组：相同类型变量的集合
数组分为一维数组、多维数组

栈内存和堆内存

• 栈内存：方法中定义的一些基本数据类型和对象的引用变量存在于栈内存中。当在代码块中定义变量时，Java会在栈内存中为其分配内存空间，当超出变量的作用域后，Java会自动释放为该内存分配的内存空间。
• 堆内存：由new运算符创建的数组或者对象存在于堆中。在堆中分配的内存，由Java虚拟机(JVM)的垃圾回收器自动管理。

Java有一个特殊引用型常量null，如果将一个引用变量赋值为null，则表示该引用变量不指向(引用)任何对象。

一维数组

定义数组的语法格式：

//一维数组：
<元素类型> <变量名>[];或<元素类型>[] <变量名>;
举例：int[] a;  或int a[];

静态初始化

手动指定数组元素，系统会根据元素个数，计算出数组的长度
输出时需指定下标println(a[0])，常用于需明确要操作的具体数据。

完整格式1
数据类型 [] 变量名 = new 数据类型[] {元素1,元素2,元素3… };
简化格式2
数据类型 变量名[] = {元素1,元素2,元素3… };
int a[]={1,3,4,6,8};
print(a[0])//1

动态初始化

手动指定长度，由系统给出默认的初始化值
常用于只知道元素个数，不知道具体值
整数类型：默认初始化值为0；
小数类型或者浮点数类型：默认初始化值为0.0；
字符类型：默认初始化值‘/u0000’空格；
布尔类型：默认初始化值为false;
引用数据类型：默认初始化值null;

数据类型[] 数组名=new 数据类型[数组长度]
int a[]=new int[3];//动态初始化，定义数组长度（有几个元素）
a[0]=123456;//定义数组元素0
a[1]=23456;//定义数组元素1
a[2]=3456;//定义数组元素2
a[3]=456;//定义数组元素3，错误 ，超出数组规定的元素个数
print(a[1])//23456

二维数组

多维数组可以理解为由若干个低维数组所组成的数组。
定义数组的语法格式：

//二维数组：
<元素变量类型> <变量名>[][]; 或<元素变量类型>[][] <变量名>
例如：int a[][];或 int[][] a;

静态初始化

完整格式1
数据类型[][] 变量名 = new 数据类型[] {元素1,元素2,元素3… };
简化格式2
数据类型 变量名[][] = {元素1,元素2,元素3… };
int a[][]={{1,2,3},{,4,5,6},{7,8,9}};
print(a[0][2])//print(变量名[数组下标][数组内元素下标])==3

动态初始化

int[][] a=new  int[3][];//数据类型[][] 变量名 = new 数据类型[数组个数][];
a[0]=new int[]{1,2,3};//定义数组0中元素
a[1]=new int[]{4,5,6};//定义数组2中元素
a[1][2]=16;//单独指定某一位置为具体字符
print(a[0][2])//print(变量名[数组下标][数组内元素下标])==3

数组代码示例

示例一：k依次从数组a中取值

public class shuzu1 {
    public static void main(String[] args){
        int[] a = {3,5,67,98,56};
        for (int k : a){
            System.out.println(k);
        }
    }
}

示例二：两种定义格式定义a、b；依次输入数组a和b的值使用制表符进行分割；

public class shuzu2 {
    public static void main(String[] args){
        int a[] = {1,2,3,45,109,111};
        int[] b={4,5,6,34,90};
        for (int i =0;i< a.length;i++)
            System.out.print("a["+i+"]="+a[i]+"\t");
        System.out.println();
        for (int i=0;i< b.length;i++)
            System.out.print("b["+i+"]="+b[i]+"\t");
    }
}

示例三：二维数组，

public class shuzu3 {
    public static void main(String[] args){
        int[][] a=new  int[3][];//定义数组个数3，在下面代码限制为3行
        a[0]=new int[2];//定义第一行的数组个数限制为2，即第一行有两列
        a[1]=new int[4];
        a[2]=new int[3];
        a[1][2]=16;//1的位置表示行的位置，2的位置表示列的位置
        a[0][1]=25;//如上注释:表示的是第一行第二列为25
        //a[0][2]=19;第一行第三列超出限制，报错
        for (int i=0;i<a.length;i++){//使用双循环结果输出数组
            for (int j=0;j<a[i].length;j++)
                System.out.print(a[i][j]+"\t");
            System.out.println();
        }
    }
}

示例四：
在Java里面，可以用复制语句“A=B”给基本类型的数据传递值，但是如果A，B是两个同类型的数组，复制就相当于将一个数组变量的引用传递给另一个数组；
如果一个数组发生改变，那么引用同一数组的变量也要发生改变。
在Java，如果想实现数组的复制，常用的可以有两种方法：
（1）使用for循环，将数组的每个元素复制或者复制指定元素，效率相对较差。
（2)使用System.arraycopy(src,srcPos,dest,destPos,length)方法，会提高程序执行效率，特别是大数组情况下。

例如：使用arraycopy如何进行数组的复制。java.lang.System类的静态方法arraycopy()提供了数组元素复制功能，
将一个数组的连续多个元素的值批量复制到另一个数组中。
arraycopy()方法函数原型：
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
说明：
src：源数组；
srcPos：源数组要复制的起始位置；
dest：目的数组；
destPos：目的数组要放置的起始外置；
length：复制的长度。

public class shuzu4 {
    public static void main(String[] args) {
        int source[] = {1,2,3,4,5,6};
        int dest[] = {10,9,8,7,6,5,4,3,2,1};
        System.arraycopy(source,0,dest,0,3);
        //用source数组从下标0开始的值覆盖dest数组下标从0开始的3个值
        for(int i=0;i<dest.length;i++){
            System.out.print(dest[i]+",");
        }
    }
}

示例五：

/*温度转换
华氏温度到摄氏温度对照表的实现，华氏度（Fahrenheit）和摄氏度（Centigrade）都是用来计量温度的单位，华氏度=摄氏度×9÷5+32，
华氏温标规定在一个大气压下水的冰点为32度，沸点为212。
 */
public class wendu {
    public static void main(String[] args){
        System.out.println();
        System.out.print("\t\t\t");
        System.out.println("摄氏、华氏温度对照表");
        System.out.print("---------------------------------------------------------------------");
        System.out.println("-------------------------------");
        for (int i=0;i<5;i++){
            System.out.print("摄氏"+"           "+"华氏"+"\t");
        }
        System.out.println();
        for (int i=1;i<=40;i++){
            double 摄氏=i;
            double 华氏=摄氏;
            System.out.print(摄氏+"          "+华氏+"\t");
            if(i%5==0)//换行
            {
            System.out.println();
            }
        }
    }
}