1.控制语句介绍
控制语句：是用来控制程序中各语句执行顺序的语句。
- 顺序结构
- 选择结构
- 循环结构
2.选择结构
- if单选择结构
- if-else if-else多选择结构
- switch结构
double d = Math.random(); //返回[0, 1)之间的随机数
System.out.println(d);
System.out.println((int)(6*Math.random()+1)); //返回1~6之间的随机整数
int i = (int)(6*Math.random()) + 1;
int j = (int)(6*Math.random()) + 1;
int k = (int)(6*Math.random()) + 1;
int count = i + j + k;
if(count > 15){
System.out.println("今天手气不错");
}
if(count >= 10 && count <= 15){
System.out.println("今天手气很一般");
}
if(count < 10){
System.out.println("今天手气不怎么样");
}
System.out.println("得了" + count + "分");
3.if-else双选择结构
double r = 4*Math.random();
double area = Math.PI*Math.pow(r, 2);
double circle = 2 * Math.PI * r;
System.out.println("半径为："+r);
System.out.println("面积为："+area);
System.out.println("周长为："+circle);
if(area >= circle){
System.out.println("面积大于等于周长");
}else{
System.out.println("周长大于面积");
}
4.if-else if-else多选择结构
public class Test5 {
public static void main(String[] args) {
int age = (int) (100 * Math.random());
System.out.print("年龄是" + age + "， 属于");
if (age < 15) {
System.out.println("儿童， 喜欢玩！");
} else if (age < 25) {
System.out.println("青年， 要学习！");
} else if (age < 45) {
System.out.println("中年， 要工作！");
} else if (age < 65) {
System.out.println("中老年， 要补钙！");
} else if (age < 85) {
System.out.println("老年， 多运动！");
} else {
System.out.println("老寿星， 古来稀！");
}
}
}
5.switch多选择结构
- 用来判断多值时很简洁，也可以用if-else代替；
- 从开始执行，一直到break或switch末尾结束；
- case标签可以是整数（long类型除外）、枚举类型和字符串。
int mouth = (int)(1+12*Math.random());
System.out.println("月份："+mouth);
switch(mouth){
case 1:
System.out.prinln("一月份！过新年了！");
break;
case 2:
System.out.println("二月份！开春了！);
break;
default:
System.out.prinln(”我是其他月份！);
break;
}
6.循环结构（while循环）
- while：先判断，后执行
- do...while：先执行，后判断（用的少）
//计算1+2+3+...+100，累加求和，5050
//暴力算法！
int i = 1;
int sum = 0;
while(i <= 100){
sum = sum + i;
i++;
}
System.out.println(sum);
7.for循环
int sum = 0;
//1.执行初始化语句i=1；2.判断i<=100；3.执行循环体；4.步进迭代：i++；5.回到第二步继续判断。
for(int i = 1; i <=100; i++){
sum = sum + i;
}
System.out.println(sum);
注：（1）多个初始化语句、判断语句或迭代语句时，使用逗号将多个语句隔开。
（2）for(;;)相当于while(true)。
（3）for循环中的初始化变量的作用域仅限循环体内部。
8.嵌套循环
循环体内部嵌套一个或多个循环。
for(int i = 1; i <= 5; i++){
for(int j = 1; j <= 5; j++){
System.out.print(i + "\t");
}
System.out.println();
}
for(int n = 1; n <= 9; n++){
for(int m = 1; m <= n; m++){
System.out.print(m+"*"+n+"="+(m*n)+"\t");
}
System.out.println();
}
int sum01 = 0;
int sum02 = 0;
for(int i = 1; i <= 100; i++){
if(i%2==0){
sum02 += i;
}
else{
sum01 += i;
}
}
System.out.println("奇数和："+sum01);
System.out.println("偶数和："+sum01);
int t = 0;
for(int i = 1; i <= 1000; i++){
if(i % 5 == 0){
System.out.print(i + “\t”);
t++;
}
if(t == 5){
System.out.prinln();
t = 0;
}
}
9.break和continue语句
- break：强制退出循环，不执行循环中剩余的语句；
- continue：终止某一次循环过程，接着进行下一次循环的判定。
10.带标签的break和continue（不常用）
- goto关键字很早就在程序设计语言中出现。尽管goto仍然是java的保留字，但并未在Java语言中得到正式使用；Java没有goto语句。
- 标签是指后面带一个冒号的标识符，例如：“label:”。Java中唯一用到标签的地方是在循环语句之前，目的是希望在其中嵌套另一个循环。由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
//打印101-150之间所有的质数
outer: for(int i = 101; i < 150; i++){
for(int j = 2; j < i / 2; j++){
if(i % j == 0){
continue outer;
}
}
System.out.print(i + " ");
}
11.语句块和方法
- 语句块中定义的变量作用域仅限于语句块。
- 方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。
public class TestMethod {
public static void main(String[] args) {
//通过对象调用普通方法
TestMethod tm = new TestMethod();
tm.printInf();
int c = tm.add(30, 40, 50)+1000;
System.out.println(c);
}
void printInf() {
System.out.println("Hello!");
}
int add(int a, int b, int c) {
int sum = a+b+c;
System.out.println(sum);
return sum; //reture两个作用：1.结束方法的运行；2.返回值
}
}
注意：
（1）实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配；
（2）return语句终止方法的运行并指定要返回的数据；
（3）Java中进行方法调用传递参数时，遵循值传递的原则（传递的是数据的副本）；
（4）基本类型传递的是该数据值的copy值，引用类型传递的是该对象引用的copy值，但指向的是同一个对象。
12.方法的重载
- 重载的方法，实际是完全不同的方法，只是名称相同而已。
- 构成方法重载的条件：
（1）形参类型、形参数目、形参顺序不同都可以构成重载；
（2）参数名称不同，不构成重载；
（3）只有返回值不同不构成方法的重载。
public class TestOverload {
public static void main(String[] args) {
System.out.println(add(3, 5));
System.out.println(add(3, 5, 10));
System.out.println(add(3.0, 5));
System.out.println(add(3, 5.0));
}
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;
}
//方法名相同，参数个数不同，构成重载
public static int add(int n1, int n2, int n3) {
int sum = n1 + n2 + n3;
return sum;
}
//方法名相同，参数类型不同，构成重载
public static double add(double n1, int n2) {
double sum = n1 + n2;
return sum;
}
//方法名相同，参数顺序不同，构成重载
public static double add(int n1, double n2) {
double sum = n1 + n2;
return sum;
}
/**
//编译错误，只有返回值不同，不构成方法的重载
public static double add(int n1, int n2) {
double sum = n1 + n2;
return sum;
}
//编译错误，只有参数名称不同，不构成方法的重载
public static int add(int n2, int n1) {
int sum = n1 + n2;
return sum;
}
**/
}
13.递归
- 递归的基本思想就是“自己调自己”。
- 递归结构包括两个部分：
（1）定义递归头：即什么时候不调用自身方法，如果没有头，将陷入死循环，也就是递归的结束条件；
（2）递归体：即什么时候需要调用自身方法。 - 递归的缺点：虽然递归程序简单，单递归调用会占用大量的系统堆栈，内存耗用多，比循环慢得多，因此使用递归时要慎重。
- 任何能用递归解决的问题也能用循环解决，当递归可以更自然地反映问题，且易于理解，同时又不强调效率问题时，可以采用递归；在任何高性能的情况下尽量避免使用递归，因为递归既花时间又耗内存。
public class TestRecursion02 {
public static void main(String[] args) {
long d1 = System.currentTimeMillis();
System.out.printf("%d阶乘的结果：%s\n", 10, factorial(10));
long d2 = System.currentTimeMillis();
System.out.printf("递归费时：%s\n", d2-d1); //29ms
factorialLoop(10);
}
/**求阶乘的方法*/
static long factorial(int n) {
if(n==1) {
return 1;
}else {
return n*factorial(n-1);
}
}
static long factorialLoop(int a) {
long d3 = System.currentTimeMillis();
long result = 1;
while(a>1) {
result *= a;
a--;
}
long d4 = System.currentTimeMillis();
System.out.printf("%d阶乘的结果：%s\n", 10, result);
System.out.printf("循环费时：%s\n", d4-d3); //0ms
return result;
}
}
网友评论