java 控制语句、数组、方法

一、控制语句

1、if 语句

if语句是指如果满足某种条件，就进行某种处理。

流程图：

2、 if…else语句

语法格式：

if (判断条件){
执行语句1
……
}else{
执行语句2
……
}

流程图：

3、 if…else if…else语句

语法格式：

if (判断条件1) {
    执行语句1
} else if (判断条件2) {
    执行语句2
}
...
else if (判断条件n) {
    执行语句n
} else {
    执行语句n+1
}

流程图：

4、 循环语句while

语法结构：

while(循环条件){
执行语句
………
}

当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。

如果循环条件直接赋值true,则会变成死循环：

while(true){
执行语句
………
}

 5、循环语句 for

for（初始化表达式; 循环条件; 操作表达式）{
    执行语句
    ………
}

接下来分别用①表示初始化表达式、②表示循环条件、③表示操作表达式、④表示循环体，通过序号来具体分析for循环的执行流程。

for（① ; ② ; ③）{
    ④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环

死循环格式：for(;;){}

6、 循环语句do…while

语法结构：

do {
执行语句
………
} while(循环条件);

流程图：

先运行执行语句，当循环条件为true时，执行语句循环执行，直到循环条件为false时，整个循环过程才会结束。

7、 选择结构switch

switch 条件语句也是一种很常用的选择语句，它和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。

语法结构：

switch (表达式){
    case 目标值1:
        执行语句1
        break;//停止循环，如果没有break还会继续向下执行
    case 目标值2:
        执行语句2
        break;
    ．．．．．．
    case 目标值n:
        执行语句n
        break;
    default:     //如果之前的目标值都没有匹配，执行语句n+1
        执行语句n+1
        break;
}

在上面的格式中，switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的语句，如果没找到任何匹配的值，就会执行default后的语句。

注意:在switch语句中的表达式只能是byte、short、char、int类型的值，如果传入其它类型的值，程序会报错.

在JDK7.0中也引入了新特性，switch语句可以接收一个String类型的值。

8、 循环嵌套

while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环

for(初始化表达式; 循环条件; 操作表达式) {
    ………
    for(初始化表达式; 循环条件; 操作表达式) {
        执行语句
        ………
    }
    ………
}

9、跳转语句（break、continue）

break语句

它出现在循环语句中，作用是跳出循环语句，执行后面的代码。

当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。

public class BreakDemo02 {
    public static void main(String[] args) {
        int i, j; // 定义两个循环变量
        aaa: for (i = 1; i <= 9; i++) { // 外层循环
            for (j = 1; j <= i; j++) { // 内层循环
                if (i > 4) { // 判断i的值是否大于4
                    break aaa; // 跳出外层循环
                }
                System.out.print("*"); // 打印*
            }
            System.out.print("\n"); // 换行
        }
    }
}

continue语句

continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。

//练习对1~100之内的奇数求和
public class ContinueDemo {
    public static void main(String[] args) {
        int sum = 0; // 定义变量sum，用于记住和
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) { // i是一个偶数，不累加
                continue; // 结束本次循环
            }
            sum += i; // 实现sum和i的累加
        }
        System.out.println("sum = " + sum);
    }
}

二、引用数据类型

引用数据类型的使用步骤：

数据类型  变量名  =  new 数据类型();

每种引用数据类型都有其功能，我们可以调用该类型实例的功能。

变量名.方法名();

1、Scanner类

Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，获取到录入的数据。

Scanner使用步骤：

导包：import java.util.Scanner;

创建对象实例：Scanner sc = new Scanner(System.in);

调用方法：

int  i = sc.nextInt(); //用来接收控制台录入的数字

String s = sc.next(); //用来接收控制台录入的字符串

 2、Random类

这个Random类，用来产生随机数，它可以产生多种数据类型的随机数，

public int nextInt(int maxValue)    //产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
public double nextDouble()  //产生[0,1)范围的随机小数，包含0.0，不包含1.0

Random 使用步骤：:

import导包：所属包java.util.Random

创建实例格式：Random 变量名 = new Random();

例：

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        // 创建Random类的实例
        Random r = new Random();
        // 得到0-100范围内的随机整数，将产生的随机整数赋值给i变量
        int i = r.nextInt(100);
        //得到0.0-1.0范围内的随机小数，将产生的随机小数赋值给d变量
        double d = r.nextDouble();
        System.out.println(i);
        System.out.println(d);
    }
}

 三、数组

1、定义格式：

数据类型[ ] 数组名 = new  数据类型 [元素个数或数组长度];

数组的静态初始化有两种方式：

1、类型[] 数组名 = new 类型[]{元素，元素，……};
2、类型[] 数组名 = {元素，元素，元素，……};     

2、数组遍历

在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
        // 使用for循环遍历数组的元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]); // 通过索引访问元素1,2,3,4,5
        }
    }
}

3、 数组的常见问题

数组最值

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
        // 下面通过一个for循环遍历数组中的元素
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) { // 比较 arr[x]的值是否大于max
                max = arr[x]; // 条件成立，将arr[x]的值赋给max
            }
        }
        System.out.println("max=" + max); // 打印最大值
    }
}

数组异常

1>数组越界异常

每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错

 1public class ArrayDemo06 {
 2    public static void main(String[] args) {
 3        int[] arr = new int[4]; // 定义一个长度为4的数组
 4        System.out.println("arr[0]=" + arr[4]); // 通过角标4访问数组元素
 5    }
 6}

运行结果：

现这个异常的原因是数组的长度为4，其索引范围为0~3，而上述代码中的第4行代码使用索引4来访问元素时超出了数组的索引范围。

2>空指针异常

在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常

 1public class ArrayDemo07 {
 2    public static void main(String[] args) {
 3        int[] arr = new int[3]; // 定义一个长度为3的数组
 4        arr[0] = 5; // 为数组的第一个元素赋值
 5        System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 6        arr = null; // 将变量arr置为null
 7        System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 8    }
 9}

运行结果：

通过上图所示的运行结果可以看出，上述代码中第4、5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，当第7行代码再次访问数组时就出现了空指针异常NullPointerException。

 4、二维数组

二维数组的定义方式：

/*第一种方法*/
int[][] arr = new int[3][4];//相当于定义了一个3*4的二维数组,3个长度是4的一维数组
/*第二种方法*/
int[][] arr = new int[3][];//和第一种类似，只是数组中每个元素的长度不确定
/*第三种方法*/
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};//直接赋值

二维数组元素遍历：两个for循环内嵌

数组元素累加和：利用遍历相加

例：接下来通过一个案例来熟悉二维数组的使用。

例如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。如下所示

l 第一小组销售额为{11, 12}万元

l 第二小组销售额为{21, 22, 23}万元

l 第三小组销售额为{31, 32, 33, 34}万元。

 1public class ArrayDemo10 {
 2    public static void main(String[] args) {
 3        int[][] arr = new int[3][]; // 定义一个长度为3的二维数组
 4        arr[0] = new int[] { 11, 12 }; // 为数组的元素赋值
 5        arr[1] = new int[] { 21, 22, 23 };
 6        arr[2] = new int[] { 31, 32, 33, 34 };
 7
 8        int sum = 0; // 定义变量记录总销售额
 9        for (int i = 0; i < arr.length; i++) { // 遍历数组元素
 10            int groupSum = 0; // 定义变量记录小组销售总额
 11            for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额
 12                groupSum = groupSum + arr[i][j];
 13            }
 14            sum = sum + groupSum; // 累加小组销售额
 15            System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元");
 16        }
 17        System.out.println("总销售额为: " + sum + " 万元");
 18    }
 19}

运行结果：

例2：游戏操作如下：

l 后台预先生成一个1-100之间的随机数，用户键盘录入猜数字

l 如果猜对了，打印“恭喜您，答对了”

l 如果猜错了

猜大了：打印“sorry，您猜大了!”

猜小了：打印“sorry，您猜小了!”

l 直到数字猜到为止

import java.util.Random;//导入包Random
import java.util.Scanner;//导入包Scanne
class Demo04
{
    public static void main(String[] args)
    {
        Random r = new Random();
        int a=r.nextInt(99);//随机产生0-99的数
        int b=a+1;//随机产生0-99的数
        System.out.println("请输入您猜测的数：");
        Scanner sc = new Scanner(System.in);
        int x=sc.nextInt();//输入猜测的数    x
        while(true){
            if(x>b){
                    System.out.println("sorry，您猜大了!");
            }else if(x<b){
                    System.out.println("sorry，您猜小了!");
            }else{
                System.out.println("恭喜您，答对了");
                break;
            }
             x=sc.nextInt();

        }