CH03 流程控制和数组

版权声明：@Abby-YTJ https://blog.csdn.net/weixin_43564773/article/details/85736805

3.1 分支结构

Java提供两种分支控制结构：if语句和switch语句

3.1.1 if条件语句

• 单分支结构

if (条件)
{
    <语句块>
}

• 二分支结构

if (条件)
{
    <语句块1>
}
else
{
    <语句块2>
}

• 多分支结构

if (条件1)
{
    <语句块1>
}
else if(条件2)
{
    <语句块2>
}
    ...
else
{
    <语句块2>
}

3.1.2 switch分支语句

• switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种整数类型，枚举类型和java.lang.String类型，不能是boolean类型

switch (expression)
{
    case condition1:
    {
        statement(s)
        break;
    }
    case condition2:
    {
        statement(s)
        break;
    }
    ...
    case conditionN:
    {
        statement(s)
        break;
    }
    default:
    {
        statement(s)
    }
}

3.2 循环结构

• 循环结构一般包含以下四个部分
  • 初始化语句
  • 循环条件
  • 循环体
  • 迭代语句

3.2.1 while循环语句

[init_statement]
while(test_expression)
{
    statemment;
    [iteration_statement]
}

例：Retirement.java

import java.util.Scanner;
public class Retirement {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("How much money do you need to retire?");
		double goal = in.nextDouble();
		System.out.print("How much money will you contribute every year? ");
		double payment = in.nextDouble();
		System.out.print("Interest rate in %: ");
		double interestRate = in.nextDouble();
		double balance = 0;
		int years = 0;
		while(balance < goal)
		{
			balance += payment;
			double interest = balance * interestRate / 100;
			balance += interest;
			years++;
		}
		System.out.println("You can retire in " + years + " years.");
	}
}

3.2.2 do while循环语句

[init_statement]
do
{
    statement;
    [iteration_statement]
}while(test_expression);

例：Retirement2.java

import java.util.Scanner;
public class Retirement2 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("How much money do you need to retire?");
		double goal = in.nextDouble();
		System.out.print("How much money will you contribute every year? ");
		double payment = in.nextDouble();
		System.out.print("Interest rate in %: ");
		double interestRate = in.nextDouble();
		double balance = 0;
		int year = 0;
		String input;
		// update account balance while user isn't ready to retire
		do
		{
			// add this year's payment and interest
			balance += payment;
			double interest = balance * interestRate / 100;
			balance += interest;
			year++;
			System.out.printf("After year %d, your balance is %,.2f%n", year, balance);
			// ask if ready to retire and get input
			System.out.print("Ready to retire?(Y/N) ");
			input = in.next();
		}
		while(input.equals("N"));
	}
}

3.2.3 for循环

for ([init_statement];[test_expression];[iteration_statement])
{
    statement;
}

例：LotteryOdds.java

import java.util.Scanner;
public class LotteryOdds {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("How many numbers do you need to draw? ");
		int k = in.nextInt();
		System.out.print("What is the highest number you can draw? ");
		int n = in.nextInt();
		int lotteryOdds = 1;
		for (int i = 1; i <= k; i++)
			lotteryOdds = lotteryOdds * ( n - i + 1) / i;
		System.out.println("Your odds are 1 in " + lotteryOdds + ". Good luck!");
	}
}

3.3 控制循环结构

3.3.1 使用break结束循环

• break用于完全结束一个循环，跳出循环体
  例：BreakTest.java

public class BreakTest {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++)
		{
			System.out.println("i的值是" + i);
			if (i == 2)
			{
				break;
			}
		}
	}
}

运行结果：

i的值是0
i的值是1
i的值是2

• break语句不仅可以结束其所在的循环，还可以直接结束其外层循环。此时需要在break后紧跟一个标签，用于标识一个外层循环。
  例：BreakTest2.java

public class BraekTest2 {
	public static void main(String[] args) {
		//外层循环，outer作为标识符
		outer:
			for (int i = 0; i < 5; i++)
			{
				// 内层循环
				for (int j = 0; j<3; j++)
				{
					System.out.println("i的值为:" + i + " j的值为：" + j);
					if (j == 1)
					{
						// 跳出outer标签所标识的循环
						break outer;
					}
				}
			}
	}
}

运行结果：

i的值为:0 j的值为：0
i的值为:0 j的值为：1

3.3.2 使用continue忽略本次循环剩下语句

• continue忽略本次循环剩下语句，接着开始下一次循环，并不会终止循环。
  例：ContinueTest.java

public class ContinueTest {
	public static void main(String[] args) {
		for(int i = 0; i < 3; i++)
		{
			System.out.println("i的值是" + i);
			if (i == 1)
			{
				// 忽略本次循环的剩下语句
				continue;
			}
			System.out.println("continue后的输出语句");
		}
	}
}

运行结果

i的值是0
continue后的输出语句
i的值是1
i的值是2
continue后的输出语句

• continue后也可以紧跟一个标签，用于直接跳过标签所标识循环的当次循环的剩下语句，重新开始下一次循环
  例: ContinueTest2.java

public class ContinueTest2 {
	public static void main(String[] args) {
		// 外层循环
		outer:
			for (int i = 0; i < 5; i++)
			{
				// 内层循环
				for(int j = 0; j < 3; j++)
				{
					System.out.println("i的值为：" + i + " j的值为：" + j);
					if (j == 1)
					{
						// 忽略outer标签所指定的循环中本次循环所剩下语句
						continue outer;
					}
				}
			}
	}
}

运行结果：

i的值为：0 j的值为：0
i的值为：0 j的值为：1
i的值为：1 j的值为：0
i的值为：1 j的值为：1
i的值为：2 j的值为：0
i的值为：2 j的值为：1
i的值为：3 j的值为：0
i的值为：3 j的值为：1
i的值为：4 j的值为：0
i的值为：4 j的值为：1

3.3.3 使用return结束一个方法

• 当一个方法执行到return语句时，这个方法将被结束
• 与continue和break不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
  例：ReturnTest.java

public class ReturnTest {
	public static void main(String[] args) {
		for(int i = 0; i < 3; i++)
		{
			System.out.println("i的值是" + i);
			if (i == 1)
			{
				return;
			}
			System.out.println("return后的输出语句");
		}
	}
}

运行结果：

i的值是0
return后的输出语句
i的值是1

3.4 数组类型

3.4.1 理解数组

• Java的数组要求所有的数组元素具有相同的数据类型。
• 数组的长度不可改变
• Java的数组既可以存储基本类型的数据，也可以存储引用类型的数据（数组本身是一种引用类型）

3.4.2 定义数组

type[] arrayName;

3.4.3 数组的初始化

• Java语言中数组必须先初始化，才可以使用。初始化指的是为数组的数组怨妇分配内存空间，并为每个数组元素赋初值。
• 数组的初始化有如下两种形式：
  • 静态初始化
  • 动态初始化

静态初始化

arrayName = new type[] {element1, element2, element3, element4...};

• 数组定义和初始化可以同时完成

type[] arrayName = {element1, element2, element3,...};

动态初始化

• 只指定数组的长度，由系统为每个数组元素指定初始值。

arrayName = new type[length];

• 数组定义和初始化同时完成

type[] arrayName = new type[length];

3.4.4 foreach循环

• foreach循环可以遍历数组和集合，无须根据索引来访问数组元素和集合元素

for ( type variableName : array | collection)
{
    statement// variableName自动迭代访问每个元素...
}

例：ForEachTest.java

public class ForEachTest {
	public static void main(String[] args) {
		String[] books = {"Core Java I","Core Java II","Python"};
		// 使用foreach循环来遍历数组元素
		// 其中book元素将会自动迭代每个数组元素
		for (String book : books)
		{
			System.out.println(book);
		}
	}
}

运行结果

Core Java I
Core Java II
Python

• 注意：使用foreach循环迭代数组元素时，并不能改变数组元素的值，因此不要对foreach的循环变量进行赋值。

3.5 深入数组

3.5.1 基本类型数组的初始化

• 对于基本类型数组，初始化时，先为该数组分配内存空间，然后直接将数组元素的值存入对应数组元素中。
  例：PrimitiveArrayTest.java

public class PrimitiveArrayTest {
	public static void main(String[] args) {
		// 定义一个int[]类型的数组变量
		int[] iArr;
		// 动态初始化数组，数组长度为5
		iArr = new int[5];
		// 采用循环方式为每个数组元素赋值
		for (int i = 0; i < iArr.length; i++)
		{
			iArr[i] = i + 10;
			System.out.print(iArr[i] + " ");
		}
	}
}

3.5.2 引用类型数组的初始化

• 引用类型数组的元素是引用，指向另一块内存，这块内存中存储了有效数据。
  例：ReferenceArrayTest.java

public class Person {
	public int age;
	public double height;
	// 定义一个info方法
	public void info()
	{
		System.out.println("我的年龄是：" + age
				+ ", 我的身高是：" + height);
	}
}
public class ReferenceArrayTest {
	public static void main(String[] args) {
		// 定义一个students数组变量，其类型是Person[]
		Person[] students;
		// 执行动态初始化
		students = new Person[2];
		// 创建一个Person实例，并把这个Person实例赋给Yuan变量
		Person yuan = new Person();
		// 为Yuan所引用的Person对象的age、height赋值
		yuan.age = 19;
		yuan.height = 183;
		// 创建一个Person实例，并把这个Person实例赋给Ma变量
		Person ma = new Person();
		// 为Ma素所引用的Person对象的age、height赋值
		ma.age = 55;
		ma.height = 162;
		// 将yuan变量的值赋给第一个数组元素
		students[0] = yuan;
		// 将ma变量的值赋给第二个数组元素
		students[1] = ma;
		yuan.info();
        // yuan和students[0]指向同一个内存区
	}
}