精华内容
下载资源
问答
  • 【Java】java控制语句的那些事(最全知识点)
    万次阅读
    2020-05-26 13:20:08

    【Java】java控制的那些事(最全知识点)

    学习一门语言,最基础的不过控制语句,语言之间互通性最高的也是控制语句,如果你连控制语句都没搞懂,都不熟悉,那么你的编程之路注定不顺利,所以奔本篇详细介绍了控制语句的各类知识点

    流程控制语句

    流程控制语句分类:

    1. 顺序结构
    2. 选择结构
    3. 循环结构

    顺序结构

    • 顺序结构是最基本的流程
    • 顺序结构的特点: 从上往下依次进行

    选择结构

    if语句

    if语句第一种格式的基本使用

    • 选择结构:

      • 也被称为分支结构
    • 选择结构有2种:

      1. if语句
      2. switch语句
    • if语句的第一种格式: 只使用if

    // 格式
    if(关系表达式) {
    	语句体
    }
    
    // 示例
    int a = 0;
    if(a == 1) {
    	System.out.println("a等于1");
    }
    
    • 第一种格式的执行流程:
      • 首先判断关系表达式的结果是true还是false
        • 如果是true就执行语句体
        • 如果是false就不执行语句体

    if语句第二种格式的基本使用

    • if语句的第二种格式: if…else…
    • 第二种格式的执行流程:
    • 首先判断关系表达式看其结果是true还是false
      • 如果是true就执行语句体1
      • 如果是false就执行语句体2

    if语句第三种格式的基本使用

    • if语句的第三种格式: if…else if…else
    // 格式
    if(关系表达式1) {
    	语句体1
    } else if (关系表达式2) {
    	语句体2
    }...{
    
    } else {      // else {} 是可选的
    	语句体n
    }
    
    • 第三种格式的执行流程:
      • 首先判断关系表达式1, 看其结果是true还是false
        • 如果是true就执行语句体1
        • 如果是false就继续判断关系表达式2, 看其结果是true还是false
          • 如果是true就执行语句体2
          • 如果是false就继续判断关系表达式3, 看其结果是true还是false
        • 如果没有任何关系表达式为true, 就执行else中的语句体
    • 能不能省略最后的else? 可以

    switch语句的格式和执行流程

    • switch语句的格式
    switch(表达式) {
    	case1:
    		语句体1;
    		break;
    	case2:
    		语句体2;
    		break;
    	...
    	case 值n:
    		语句体n;
    		break;
    	default:
    		语句体n+1;
    		break;
    }
    
    • 说明
      • switch表达式允许的数据类型:
        • byte, short, char, int
          • 都是可隐式转换为int的类型, 因为byte, short, char可以隐式转换为int, 所以也可以使用
        • JDK5起可以是枚举类型
        • JDK7起可以是String
        • 小括号中可以是常量, 也可以是变量
      • case后面的值:
        • 用来和表达式的值进行匹配
        • 值只能是常量
        • 值的类型应该和switch小括号中值的类型一致
      • break: 中断
      • default: 当所有case都不匹配时, 执行default
    • 执行流程
      • 首先计算表达式的值
      • 然后执行符合的case
      • 如果没有符合的case, 则执行default

    循环控制语句

    • 循环语句: 在满足循环条件的情况下, 反复执行某段代码.
      • 循环体: 这段被重复执行的代码
    • 循环的停止:
      • 在合适的时候将循环判断条件修改为false, 从而结束循环. 否则循环将一直执行下去, 形成死循环
    • 循环语句的组成
      • 初始化语句: 一条语句(一条语句可以初始化多个变量), 这些语句完成一些初始化操作
      • 判断条件语句: boolean表达式, 这个表达式能决定是否执行循环体
      • 循环体语句: 要重复做的事情
      • 控制条件语句: 控制循环结束
    • 3种循环结构语句
      1. for循环
      2. while循环
      3. do…while循环

    for循环

    • 格式
    // 格式
    for(初始化语句; 判断条件语句; 控制条件语句) {
    	循环体语句;
    }
    // for循环适用于知道循环多少次的情况
    // 示例
    for (int i = 1; i <= 5; i++) {
    	System.out.println("我错了");
    	syso(i); 
    }
    
    • 执行流程
      1. 先执行初始化语句
      2. 然后执行判断条件语句
        • 如果为true, 则执行循环体语句
          • 循环体语句执行完毕后, 执行控制条件语句
          • 从步骤2重复
        • 如果为false, 则for循环结束
    • 初始化语句只能有一句吗?
      • 只能有一句
      • 但注意, 一句可以初始化多个变量: int i = 0, j = 1, k = 1;
    // 初始化多个变量来控制循环的情况
    for(int i = 0, j = 10; i < 10 && j > 5; i++, j--) {
    	System.out.println(i + ", " + j);
    }
    
    // 输出结果
    i=0, j=10
    i=1, j=9
    i=2, j=8
    i=3, j=7
    i=4, j=6
    
    • 注意: 初始化语句在循环中只执行一次

    while循环格式和基本使用

    • while循环的格式:
    // while普通格式
    while(判断条件语句) {
        循环体语句;
    }
    
    // 普通格式示例
    while(i < 100) {
        syso(i);
    }
    
    -----
    
    // while扩展版格式
    初始化语句;
    while(判断条件语句) {
        循环体语句;
        控制条件语句;
    }
    
    // 扩展版示例
    int i = 0;
    while(i < 100) {
        syso(i);
        i++;
    }
    
    • while循环的执行流程:
      • 先执行关系表达式
        • 如果关系表达式为true, 则执行循环体
          • 循环体执行完后, 继续执行关系表达式
        • 如果关系表达式为false, 则循环结束
    • while循环和for循环的相互转换:
    // while
    int i = 0;
    while(i < 100) {
        syso(i);
        i++;
    }
    
    // for
    for(int i = 0; i < 100; i++) {
        syso(i);
    }
    

    do…while循环格式及基本使用

    • 语句格式:
    // 普通格式
    do {
        循环体语句;
    } while(判断条件语句);
    
    // 扩展格式:
    初始化语句;
    do {
        循环体语句;
        控制条件语句;
    } while(判断条件语句);
    
    • 执行流程:
      1. 执行初始化语句
      2. 执行循环体语句
      3. 执行控制条件语句
      4. 执行判断条件语句, 看是true还是false
        • 如果是false, 则结束循环
        • 如果是true, 回到2继续执行循环体语句

    for, while, do…while三种循环的区别

    • 区别

      • do…while: 至少执行一次循环体
      • for, while: 必须判断条件成立, 才可以执行循环体
    • for循环的初始化语句的作用域: for的大括号内

    • 思考:

      • for的初始化表达式能否定义在for循环外? 可以, 定义在for循环前
      • for循环的()之内的三个表达式能否有多条? 可以

    控制循环语句

    • 2个控制循环语句:
      • break: 直接结束循环, 或switch语句
      • continue: 结束本次循环, 继续执行下一次

    break跳转控制语句的概述和基本使用

    • break的使用场景: 不能单独使用, 必须用于switch或循环中
    • break的作用:
      1. 在switch语句中, 用于结束case
      2. 在循环中, 用于结束所在的循环

    continue跳转控制语句

    • continue的使用场景: 循环中
    • continue的作用: 结束本次循环, 继续下一次的循环

    控制跳转语句分析


    扩展

    • switch语句的case穿透
      • 如果switch的case语句中没有break, 则会继续执行下一个case的代码, 这称为case穿透
      • case穿透有时会导致代码出现问题, 但有时我们也利用case穿透简化代码
    int a = 2;
    switch (a) {
    	case 1:
    		System.out.println("进入1");
    		break;
    	case 2:
    		System.out.println("进入2");
    	case 3:
    		System.out.println("进入3");
    		break;
    }
    
    会输出:
    进入2
    进入3
    
    • if语句不写大括号的格式
      • 当if语句不写大括号时, 只有if语句后的第一条语句算作if语句的语句体, 其余不算
    // 示例
    if (false) {
    	System.out.println("这条语句不会被执行");
    	System.out.println("这条语句不会被执行");
    } 
    
    // 去掉大括号后
    if (false) 
    	System.out.println("这条语句不会被执行");
    	System.out.println("这条语句会被执行");
    
    // 相当于
    if (false) {
    	System.out.println("这条语句不会被执行");
    }
    System.out.println("这条语句会被执行");
    
    • while语句, for语句不写大括号的格式
      • 当语句不写大括号时, 只有语句后的第一条语句算作语句的语句体, 其余不算
    // 示例
    while (false) {
    	System.out.println("这条语句不会被执行");
    	System.out.println("这条语句不会被执行");
    }
    
    // 去掉大括号后
    while (false) 
    	System.out.println("这条语句不会被执行");
    	System.out.println("这条语句会被执行, 且只执行1次");
    
    // 相当于
    while (false) {
    	System.out.println("这条语句不会被执行");
    }
    System.out.println("这条语句会被执行, 且只执行1次");
    
    
    //------------------
    
    
    // for示例
    for (int i = 0; i < 1; i++) {
    	System.out.println("这条语句不会被执行");
    	System.out.println("这条语句不会被执行");
    }
    
    // 去掉大括号后
    for (int i = 0; i < 1; i++) 
    	System.out.println("这条语句不会被执行");
    	System.out.println("这条语句会被执行, 且只执行1次");
    
    // 相当于
    for (int i = 0; i < 1; i++) {
    	System.out.println("这条语句不会被执行");
    }
    System.out.println("这条语句会被执行, 且只执行1次");
    
    • for循环哪些语句可以省略:
      • 如果变量在for循环外已经声明, 则初始化语句可以省略
      • 判断条件语句可以省略, 相当于不停止
      • 控制条件语句可以省略, 相当于不改变for循环中的变量
    // 外部声明的变量, 作用域如果包含了for循环, 也是可以在for循环中直接使用的
    int i = 0;
    for (; i < 10; i++) {
    	// ...
    }
    
    // 将for循环修改为死循环
    for (;;) {
    	// 死循环
    }
    
    for (;;);  // 连循环体都没有的死循环
    
    // while也可以死循环
    while (true) {
    	// 死循环
    }
    
    while (true);  // 没有循环体的死循环
    

    总结

    • 流程控制语句
      • 顺序结构
      • 选择结构: 用于根据不同条件执行不同的代码
        • if语句
          • 3种格式
          • else…if, else语句可以省略
        • switch语句
          • case穿透
          • switch表达式允许的数据类型:
            • byte, short, char, int
              • 都是可隐式转换为int的类型, 因为byte, short, char可以隐式转换为int, 所以也可以使用
            • JDK5起可以是枚举类型
            • JDK7起可以是String
            • 小括号中可以是常量, 也可以是变量
          • case后面的值:
            • 用来和表达式的值进行匹配
            • 值只能是常量
            • 值的类型应该和switch小括号中值的类型一致
          • break: 中断
          • default: 当所有case都不匹配时, 执行default
        • if语句适用于有范围的场景, 或者具体值的场景
        • switch语句适用于具体值场景, 不适用于范围的场景
      • 循环结构: 用于在满足循环条件的情况下, 重复执行某些代码
        • for循环
          • 适用于知道循环次数的场景
        • while循环
          • 适用于不知道循环次数的场景
          • 至少执行0次循环体
        • do…while循环
          • 适用于不知道循环次数的场景
          • 至少执行1次循环体
        • 循环控制语句: 控制循环的跳过或结束
          • break
            • 适用场景: switch语句, 循环
            • 作用: 结束switch语句或所在循环
          • continue
            • 适用场景: 循环
            • 作用: 结束本次循环, 继续下次循环

    if语句格式

    // 格式1
    if (关系表达式) {
    	语句体;   // 关系表达式为true时执行
    }
    
    // 格式2
    if (关系表达式) {
    	语句体1;   // 关系表达式为true时执行
    } else {
    	语句体2;   // 关系表达式为false时执行
    }
    
    // 格式3
    if (关系表达式1) {
    	语句体1;   // 关系表达式1为true时执行
    } else if (关系表达式2) {
    	语句体2;   // 关系表达式2为true时执行
    }
    ...
    } else {
    	语句体n;   // 以上关系表达式都为false时执行
    }
    

    switch语句的格式

    // 格式
    switch (表达式) {
    	case1:    // 当表达式的值为值1时执行
    		语句体1;
    		break;
    	case2:    // 当表达式的值为值2时执行
    		语句体2;
    		break;
    	...
    	default:    // 当表达式的值不能匹配上面的case时执行
    		语句体n;
    		break;
    } 
    

    for循环格式

    // 格式
    for (初始化语句; 判断条件语句; 控制条件语句) {
    	循环体语句;
    }
    
    // 示例
    for (int i = 1; i <= 5; i++) {
    	// 获取1~5的数值
    }
    

    while循环格式

    // 普通格式
    while (判断条件语句) {
    	循环体语句;
    }
    
    // 扩展格式
    初始化语句;
    while (判断条件语句) {
    	循环体语句;
    	控制条件语句;
    }
    
    // 示例
    int i = 1;
    while (i <= 5) {
    	syso(i);  // 打印1~5
    	i++;
    }
    

    do…while格式

    // 普通格式
    do {
    	循环体语句;
    } while (判断条件语句);
    
    
    // 扩展格式
    初始化语句;
    do {
    	循环体语句;
    	控制条件语句;
    } while (判断条件语句);
    
    // 示例
    int i = 1;
    do {
    	syso(i);
    	i++;
    } while (i <= 5);
    

    往期知识:Java运算符那些事(最全知识点)

    更多相关内容
  • java 控制语句

    2015-10-31 07:18:59
    非常详细的控制语句,不错值得一学,控制语句
  • 一、控制语句分类(3类) 选择语句 循环语句 转向语句 二、选择语句(分支语句) if语句 switch语句 1.if语句 1.1语法格式: 第一种写法: int a = 100; int b = 200; if(布尔表达式){ java语句; java...

    一、控制语句分类(3类)

    1. 选择语句
    2. 循环语句
    3. 转向语句

    二、选择语句(分支语句)

    1. if语句
    2. switch语句

    1.if语句

    1.1语法格式:

    第一种写法:
    	int a = 100;
    	int b = 200;
    	if(布尔表达式){
    		java语句;
    		java语句;
    	}
    	
    	这里的一个大括号{} 叫做一个分支。
    	该语法的执行原理是:
    		如果布尔表达式的结果是true,则执行大括
    		号中的程序,否则大括号中代码不执行。
    
    第二种写法:
    	if(布尔表达式){  // 分支1
    		java语句;     
    	}else{            // 分支2
    		java语句;
    	}
    	
    	执行原理:如果布尔表达式的结果是true,则执行分支1,分支2不执行。
    			 如果布尔表达式的结果是false,分支1不执行,执行分支2.
    			 以上的这个语句可以保证一定会有一个分支执行。
    			 else表示其它。
    
    第三种写法:
    	if(布尔表达式1){ // 分支1
    		java语句;
    	}else if(布尔表达式2){ // 分支2
    		java语句;
    	}else if(布尔表达式3){
    		java语句;
    	}else if(布尔表达式4){
    		java语句;
    	}....
    	
    	以上if语句的执行原理:
    		先判断“布尔表达式1”,如果“布尔表达式1”为true,则执行分支1,然后if语句结束了。
    		当“布尔表达式1”结果是false,那么会继续判断布尔表达式2的结果,
    		如果布尔表达式2的结果是true,则执行分支2,然后整个if就结束了。
    		
    		从上往下依次判断,主要看第一个true发生在哪个分支上。
    		第一个true对应的分支执行,只要一个分支执行,整个if结束。
    
    第四种写法:
    	if(布尔表达式1){ // 分支1
    		java语句;
    	}else if(布尔表达式2){ // 分支2
    		java语句;
    	}else if(布尔表达式3){
    		java语句;
    	}else if(布尔表达式4){
    		java语句;
    	}else{
    		java语句; // 以上条件没有一个成立的。这个else就执行了。
    	}
    

    注:

    1. 对于if语句来说,在任何情况下只能有1个分支执行,不可能 存在2个或者更多个分支执行。if语句中只要有1个分支执行了, 整个if语句就结束了。(对于1个完整的if语句来说的。)
    2. 以上4种语法机制中,凡是带有else分支的,一定可以保证会有 一个分支执行
      以上4种当中,第一种和第三种没有else分支,这样的语句可能会导致最后一个分支都不执行。
      第二种和第四种肯定会有 1个分支执行。
    3. 当分支当中“java语句;”只有1条,那么大括号{}可以省略,但为了 可读性,最好不要省略。(有的程序员在编写代码的时候,可能会故意 将大括号{}省略,你能看懂就行。)

    小知识点:

    	if(sex)
    		System.out.println("男");
    		System.out.println("HelloWorld!"); // 以上的这3行代码没有问题,合乎语法。
    	/*
    	else // 这一行编译报错,因为else缺少if
    		System.out.println("女");
    	*/
    
    	以上代码编译器会自动转换为:
    			if(sex){
    				System.out.println("男");
    			}
    			System.out.println("HelloWorld!"); 
    			else// 这一行编译报错,因为else缺少if
    				System.out.println("女");
    
            int aa=10, bb = 10;
            if (a = b){//语法错误
    		
            }
            if (1){//c/c++可以,Java不行
    
            }
            if (aa){//c/c++可以,Java不行,Java要boolean变量才行
    
            }
    

    2.switch语句

    2.1语法格式

    	switch(){
    	case1:
    		java语句;
    		java语句;...
    		break;
    	case2:
    		java语句;
    		java语句;...
    		break;
    	case3:
    		java语句;
    		java语句;...
    		break;
    	default:
    		java语句;
    	}
    

    以上是一个完整的switch语句:
    其中:break;语句不是必须的。default分支也不是必须的。

    2.2执行原理

    拿“值”与“值1”进行比较,如果相同,则执行该分支中的java语句,
    然后遇到"break;"语句,switch语句就结束了。
    如果“值”与“值1”不相等,会继续拿“值”与“值2”进行比较,如果相同,
    则执行该分支中的java语句,然后遇到break;语句,switch结束。
    注意:如果分支执行了,但是分支最后没有“break;”,此时会发生case 穿透现象
    所有的case都没有匹配成功,那么最后default分支会执行。

    2.3switch语句支持的值

    支持int类型以及String类型。

    switch语句本质上是只支持int和String,
    但是byte,short,char也可以
    使用在switch语句当中,因为byte short char可以进行自动类型转换

    switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。

    2.4 case合并、case穿透

            switch (score) {
                case 10:
                case 9:
                    ans = "优";
                    break;
                case 8:
                    ans = "良";
                    //break;
                case 7:
                    ans = "中";
                    break;
                case 6:
                    ans = "及格";
                    break;
                case 5:
                case 4:
                case 3:
                case 2:
                case 1:
                case 0:
                    ans = "不及格";
                    break;
                default:
                    ans = "输入的成绩有误";
            }
    
    • case10、case9 和 case 5、case 4、 case 3、case 2、 case 1、case 0都是属于case合并
    • 比如进入case8由于case8没有break会case穿透到case7才结束

    三、选择语句

    1. for循环
    2. while循环
    3. do…while…循环

    1.for循环

    1.1语法格式

    	for(初始化表达式; 条件表达式; 更新表达式){
    		循环体; // 循环体由java语句构成
    		java语句;
    		java语句;
    		java语句;
    		java语句;
    		....
    	}
    

    1.2执行原理

    先执行初始化表达式,并且初始化表达式只执行1次
    然后判断条件表达式的结果,如果条件表达式结果为true,则执行循环体。
    循环体结束之后,执行更新表达式。
    更新完之后,再判断条件表达式的结果,
    如果还是true,继续执行循环体。

    直到更新表达式执行结束之后,再次判断条件时,条件为false,for循环终止。
    在这里插入图片描述
    更新表达式的作用是:控制循环的次数;换句话说,更新表达式会更新
    某个变量的值,这样条件表达式的结果才有可能从true变成false,从而
    终止for循环的执行,反之,很有可能会导致死循环。

    2.while循环

    2.1语法格式

    	while(布尔表达式){
    		循环体;
    	}
    

    2.2执行原理

    判断布尔表达式的结果,如果为true就执行循环体,
    循环体结束之后,再次判断布尔表达式的结果,
    如果还是true,继续执行循环体,
    直到布尔表达式结果为false,while循环结束。

    2.3for与while互相转换

    	for(初始化表达式; 布尔表达式; 更新表达式){
    		循环体;
    	}
    	
    	初始化表达式;
    	while(布尔表达式){
    		循环体;
    		更新表达式;
    	}
    
    

    2.4 执行次数

    while循环的循环次数是:0 ~ n次

    3.do…while…循环

    3.1语法格式

    	do {
    		循环体;
    	}while(布尔表达式);
    

    注:while后有分号!!
    因为while后是()结尾不是{}结尾!!

    3.2执行原理

    先执行循环体当中的代码,执行一次循环体之后,
    判断布尔表达式的结果,如果为true,则继续执行
    循环体,如果为false循环结束。

    2.3 执行次数

    对于do…while循环来说循环体至少执行1次。循环体的执行次数是:1 ~ n

    注意与while循环次数的差别!
    对于while循环来说,循环体执行次数是:0~n次。

    四、选择语句

    1. break
    2. continue
    3. return

    1.break

    1. break;语句比较特殊,特殊在:break语句是一个单词成为一个完整的java语句。另外:continue也是这样,他俩都是一个单词成为一条语句。
    2. break;语句的执行并不会让整个方法结束,break;语句主要是用来终止离它最近的那个循环语句。

    1.1适用范围及作用

    1. 第一个位置:switch语句当中,用来终止switch语句的执行。 用在switch语句当中,防止case穿透现象,用来终止switch。

    2. 第二个位置:break;语句用在循环语句当中,用来终止循环的执行。 用在for当中 用在while当中
      用在do…while…当中。

    1.2 使用break跳出指定的循环

    第一步:你需要给循环起一个名字,例如:
    	a: for(){
    		b:for(){
    			if(条件表达式) break a;
    				code1;
    				code2;
    				code3;
    		}
    	}
    第二步:终止:break a;
    

    2.continue

    2.1适用范围及作用

    用在循环语句中!
    终止当前"本次"循环,直接进入下一次循环继续执行。

    注:一但执行到continue,continue以下代码不执行,直接执行更新表达式,进入下一次循环。

    2.2 使用continue跳过指定循环

    	a:for(;;更新表达式1){
    			b:for(;;更新表达式2){
    				if(条件表达式){
    					continue a;
    				}
    				code1;
    				code2;
    				code3;
    			}
    		}
    

    3.return

    展开全文
  • 主要介绍了Java控制语句之if、switch语句的相关资料,需要的朋友可以参考下
  • java课程培训,第三章流程控制语句课后习题答案及讲解代码。
  • Java控制语句

    千次阅读 2018-09-01 20:34:26
    控制语句 选择结构 if单选择结构 if-else双选择结构 if-else if-else多选择结构 switch多选择结构 循环结构 while循环 do-while循环 for循环 嵌套循环 break语句和continue语句 带标签的break和continue...

    目录

    1. 控制语句
    2. 选择结构
    3. if单选择结构
    4. if-else双选择结构
    5. if-else if-else多选择结构
    6. switch多选择结构
    7. 循环结构
    8. while循环
    9. do-while循环
    10. for循环
    11. 嵌套循环
    12. break语句和continue语句
    13. 带标签的break和continue
    14. 语句块
    15. 方法
    16. 方法的重载(overload)
    17. 递归结构
    18. 总结

    控制语句

           本篇文章开始我们要学习流程控制语句,流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类:顺序、选择和循环。

          “顺序结构”代表“先执行a,再执行b”的逻辑。比如,先找个女朋友,再给女朋友打电话;先订婚,再结婚;

          “选择结构”代表“如果…,则…”的逻辑。比如,如果女朋友来电,则迅速接电话;如果看到红灯,则停车;

          “循环结构”代表“如果…,则再继续…”的逻辑。比如,如果没打通女朋友电话,则再继续打一次; 如果没找到喜欢的人,则再继续找。

          前面两篇文章讲解的程序都是顺序结构,即按照书写顺序执行每一条语句,这并不是我们的重点,因此本篇文章研究的重点是“选择结构”和“循环结构”。

          很神奇的是,三种流程控制语句就能表示所有的事情!不信,你可以试试拆分你遇到的各种事情。实际上,任何软件和程序,小到一个练习,大到一个操作系统,本质上都是由“变量、选择语句、循环语句”组成。

          这三种基本逻辑结构是相互支撑的,它们共同构成了算法的基本结构,无论怎样复杂的逻辑结构,都可以通过它们来表达。上述两种结构组成的程序可以解决全部的问题,所以任何一种高级语言都具备上述两种结构。

          因此,本篇文章是大家真正跨入编程界的“门槛”,是成为“程序猿”的“门票”。


    选择结构

           在还没有知道Java选择结构的时候,我们编写的程序总是从程序入口开始,顺序执行每一条语句直到执行完最后一条语句结束,但是生活中经常需要进行条件判断,根据判断结果决定是否做一件事情,这就需要选择结构。

          选择结构用于判断给定的条件,然后根据判断的结果来控制程序的流程。

          主要的选择结构有:if选择结构和switch多选择结构:

    1.     if单选择结构

    2.    if-else双选择结构

    3.    if-else if-else多选择结构

    4.    switch结构


    if单选择结构

    语法结构:

    if(布尔表达式){
        语句块
    }

       if语句对布尔表达式进行一次判定,若判定为真,则执行{}中的语句块,否则跳过该语句块。

    if单选择结构流程图:  

    //if单选择结构
    public class Test1 {
        public static void main(String[] args) {
            //通过掷三个骰子看看今天的手气如何?
            int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数
            int j = (int)(6 * Math.random()) + 1;
            int k = (int)(6 * Math.random()) + 1;
            int count = i + j + k;
            //如果三个骰子之和大于15,则手气不错
            if(count > 15) {
                System.out.println("今天手气不错");
            }
            //如果三个骰子之和在10到15之间,则手气一般
            if(count >= 10 && count <= 15) { //错误写法:10<=count<=15
                System.out.println("今天手气很一般");
            }
            //如果三个骰子之和小于10,则手气不怎么样
            if(count < 10) {
                System.out.println("今天手气不怎么样");
            }
            System.out.println("得了" + count + "分");
        }
    }

    运行效果图:

    Math类的使用

          1.java.lang包中的Math类提供了一些用于数学计算的方法。

          2.Math.random()该方法用于产生一个0到1区间的double类型的随机数,但是不包括1。

    int i = (int) (6 * Math.random());  //产生:[0,5]之间的随机整数

    1.如果if语句不写{},则只能作用于后面的第一条语句。 

    2.强烈建议,任何时候都写上{},即使里面只有一句话!


    if-else双选择结构

    语法结构:

    ​//当布尔表达式为真时,执行语句块1,否则,执行语句块2。也就是else部分。
    if(布尔表达式){
        语句块1
    }else{
        语句块2
    }

     if-else双选择结构流程图:   

    //if-else结构
    public class Test2 {
        public static void main(String[] args) {
            //随机产生一个[0.0, 4.0)区间的半径,并根据半径求圆的面积和周长
            double r = 4 * Math.random();
            //Math.pow(r, 2)求半径r的平方
            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("周长大于面积");
            }
        }
    }

    运行效果图:

    条件运算符有时候可用于代替if-else: 

    //使用if-else
    public class Test3 {
        public static void main(String[] args) {
            int a=2; 
            int b=3;
            if (a<b) {
                System.out.println(a);
            } else {
                System.out.println(b);
            }
        }
    }

     运行效果图:

    //使用条件运算符
    public class Test4 {
        public static void main(String[] args) {
            int a=2;
            int b=3;
            System.out.println((a<b)?a:b);
        }
    }

    运行效果图: 

    在Java中有一种特殊的运算叫做三元运算,它和if-else语句类似:

    判断条件 ? 表达式1 : 表达式2

    三元运算通常用于对某个变量进行赋值,当判断条件成立时,运算结果为表达式1的值,否则结果为表达式2的值。

    ​//if - else条件判断
    int x = 0;
    int y = 1;
    int max;
    if (x > y) {
        max = x;
    } else {
        max = y;
    }
    
    //​三元运算符
    int x = 0;
    int y = 1;
    int max = x > y ? x : y;  //1

    if-else if-else多选择结构

    语法结构:

    if(布尔表达式1) {
        语句块1;
    } else if(布尔表达式2) {
        语句块2;
    }……
    else if(布尔表达式n){
        语句块n;
    } else {
        语句块n+1;
    }

           当布尔表达式1为真时,执行语句块1;否则,判断布尔表达式2,当布尔表达式2为真时,执行语句块2;否则,继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时,则执行语句块n+1,也就是else部分。

     if-else if-else多选择结构流程图:

     对多个条件进行判断,进行不同的处理。

    //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("老寿星, 古来稀!");
            }
        }
    }

    运行效果图:


    switch多选择结构

    语法结构:

    ​switch (表达式) {
        case 目标值1: 
             语句序列1;
             break;
        case 目标值2:
             语句序列2;
             break;
        … … … … …
    
        case 目标值n:
             语句序列n;
             break;
        default:
             默认语句;
             break;
    }

           switch语句会根据表达式的值从相匹配的case标签处开始执行,一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配,则进入default语句(如果存在default语句的情况)。

          根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(byte、short、char、int、enum。long类型除外)或者枚举,不能是字符串,在JDK1.7之后允许使用字符串(String)。

          大家要注意,当布尔表达式是等值判断的情况,可以使用if-else if-else多选择结构或者switch结构,如果布尔表达式区间判断的情况,则只能使用if-else if-else多选择结构。

     switch多选择结构流程图:

    //switch结构
    public class Test6 {
        public static void main(String[] args) {
            char c = 'a';
            int rand = (int) (26 * Math.random());
            char c2 = (char) (c + rand);
            System.out.print(c2 + ": ");
            switch (c2) {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                System.out.println("元音");
                break;
            case 'y':
            case 'w':
                System.out.println("半元音");
                break;
            default:
                System.out.println("辅音");
            }
        }
    }

     运行效果图:


    循环结构

    循环结构分两大类,一类是当型,一类是直到型。

    当型:

          当布尔表达式条件为true时,反复执行某语句,当布尔表达式的值为false时才停止循环,比如:while与for循环。

     直到型:

          先执行某语句, 再判断布尔表达式,如果为true,再执行某语句,如此反复,直到布尔表达式条件为false时才停止循环,比如do-while循环。


    while循环

    语法结构:

    while (布尔表达式) {
        循环体;
    }

           在循环刚开始时,会计算一次“布尔表达式”的值,若条件为真,执行循环体。而对于后来每一次额外的循环,都会在开始前重新计算一次。while语句会反复地进行条件判断,直到条件不成立,while循环结束。

          语句中应有使循环趋向于结束的语句,否则会出现无限循环–––"死"循环。

    while流程图:

    //while循环结构:求1到100之间的累加和
    public class Test7 {
        public static void main(String[] args) {
            int  i = 0;
            int  sum = 0;
            // 1+2+3+…+100=?
            while (i <= 100) {
                sum += i;  //相当于sum = sum+i;
                i++;
            }
            System.out.println("Sum= " + sum);
        }
    }

    运行效果图:


     do-while循环

    语法结构:

    do {
        循环体;
        } while(布尔表达式) ;

           do-while循环结构会先执行循环体,然后再判断布尔表达式的值,若条件为真,执行循环体,当条件为假时结束循环。do-while循环的循环体至少执行一次。

    do-while流程图:

    //do-while循环结构:1-100之间的累加和
    public class Test8 {
        public static void main(String[] args) {
            int i = 0;
            int sum = 0;
            do {
                sum += i;  // sum = sum + i
                i++;
            } while (i <= 100);  //此处的;不能省略
            System.out.println("Sum= " + sum);
        }
    }

    运行效果图:

    while与do-while的区别:

    public class Test9 {
        public static void main(String[] args) {
            //while循环:先判断再执行
            int a = 0;
            while (a < 0) {
                System.out.println(a);
                a++;
            }
            System.out.println("-----");
            //do-while循环:先执行再判断
            a = 0;
            do {
                System.out.println(a);
                a++;
            } while (a < 0);
        }
    }
    

    运行效果图:

    从运行效图中可以看出do-while总是保证循环体至少会被执行一次!


    for循环

    语法结构:

    for (初始表达式; 布尔表达式; 迭代因子) {
          循环体;
    }

           for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构,也是最常用的循环语句,一般用在循环次数已知的情况下。for循环在第一次反复之前要进行初始化,即执行初始表达式;随后,对布尔表达式进行判定,若判定结果为true,则执行循环体,否则,终止循环;最后在每一次反复的时候,进行某种形式的“步进”,即执行迭代因子。

          A. 初始化部分设置循环变量的初值

          B. 条件判断部分为任意布尔表达式

          C. 迭代因子控制循环变量的增减

          for循环在执行条件判断后,先执行的循环体部分,再执行步进。

    for循环流程图:

    //for循环  
    public class Test10 {
        public static void main(String args[]) {
            int sum = 0;
            //1.求1-100之间的累加和
            for (int i = 0; i <= 100; i++) {
                sum += i;
            }
            System.out.println("Sum= " + sum);
            //2.循环输出9-1之间的数
            for(int i=9;i>0;i--){
                System.out.print(i+"、");
            }
            System.out.println();
            //3.输出90-1之间能被3整除的数
            for(int i=90;i>0;i-=3){
                System.out.print(i+"、");
            }
            System.out.println();
        }
    }

    运行效果图:

           Java里能用到逗号运算符的地方屈指可数,其中一处就是for循环的控制表达式。在控制表达式的初始化和步进控制部分,我们可以使用一系列由逗号分隔的表达式,而且那些表达式均会独立执行。

    逗号运算符:

    public class Test11 {
        public static void main(String[] args) { 
            for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
                System.out.println("i= " + i + " j= " + j); 
            } 
        }
    }

    运行效果图:

    1. 无论在初始化还是在步进部分,语句都是顺序执行的。

    2. 尽管初始化部分可设置任意数量的定义,但都属于同一类型。

    3. 约定:只在for语句的控制表达式中写入与循环变量初始化,条件判断和迭代因子相关的表达式。

    初始化部分、条件判断部分和迭代因子可以为空语句,但必须以“;”分开:

    无限循环:

    public class Test12 {
        public static void main(String[] args) { 
            for ( ; ; ) {    // 无限循环: 相当于 while(true)
                System.out.println("北京尚学堂");
            }
        }
    }

    编译器将while(true)与for(  ;  ;  )看作同一回事,都指的是无限循环。

    在for语句的初始化部分声明的变量,其作用域为整个for循环体,不能在循环外部使用该变量:

    初始化变量的作用域:


    嵌套循环

           在一个循环语句内部再嵌套一个或多个循环,称为嵌套循环。while、do-while与for循环可以任意嵌套多层,并且它们之间也可以互相嵌套,如最常见的在for循环中嵌套for循环:

    //嵌套循环 
    public class Test14 {
        public static void main(String args[]) {
            for (int i=1; i <=5; i++) {
                for(int j=1; j<=5; j++){
                    System.out.print(i+"  ");
                }
                System.out.println();
            }
        }
    }

    运行效果图:

    使用嵌套循环实现九九乘法表:

    public class Test15 {
        public static void main(String args[]) {
            for (int i = 1; i < 10; i++) {  // i是一个乘数
                for (int j = 1; j <= i; j++) {  // j是另一个乘数
                    System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + "  ");
                }
                System.out.println();
            }
        }
    }

    运行效果图:


    break语句和continue语句

    跳转语句用于实现循环执行过程中程序流程的跳转,在Java中的跳转语句有break语句和continue语句。

    在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。

    break语句:在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时,作用是终止某个case并跳出switch结构。当它出现在循环语句中,作用是跳出循环语句,执行后面的代码。 

    public class Test16 {
        public static void main(String[] args) {
            int total = 0;  //定义计数器
            System.out.println("Begin");
            while (true) {
                total++;  //每循环一次计数器加1
                int i = (int) Math.round(100 * Math.random());
                //当i等于88时,退出循环
                if (i == 88) {
                    break;
                }
            }
            //输出循环的次数
            System.out.println("Game over, used " + total + " times.");
        }
    }

    运行效果图:

           continue 语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。

    1. continue用在while,do-while中,continue 语句立刻跳到循环首部,越过了当前循环的其余部分。

    2. continue用在for循环中,跳到for循环的迭代因子部分。

    //continue语句:把100~150之间不能被3整除的数输出,并且每行输出5个
    public class Test17 {
        public static void main(String[] args) {
            int count = 0;  //定义计数器
            for (int i = 100; i < 150; i++) {
                //如果是3的倍数,则跳过本次循环,继续进行下一次循环
                if (i % 3 == 0){
                    continue;
                }
                //否则(不是3的倍数),输出该数
                System.out.print(i + "、");
                count++;  //没输出一个数,计数器加1
                //根据计数器判断每行是否已经输出了5个数
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
    }

    运行效果图:


    带标签的break和continue

          goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字,但并未在Java语言中得到正式使用;Java没有goto语句。然而,在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子---带标签的break和continue。

          “标签”是指后面跟一个冒号的标识符,例如:“label:”。对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环,由于break和continue关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方。

          在 “goto有害”论中,最有问题的就是标签,而非goto, 随着标签在一个程序里数量的增多,产生错误的机会也越来越多。 但Java标签不会造成这方面的问题,因为它们的活动场所已被限死,不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题:通过限制语句的能力,反而能使一项语言特性更加有用。

    //带标签break和continue:控制嵌套循环跳转(打印101-150之间所有的质数)
    public class Test18 {
        public static void main(String args[]) {
            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 + "  ");
            }
        }
    }

    运行效果图:


    语句块

           语句块(有时叫做复合语句),是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码,作为一个整体,是要被一起执行的。块可以被嵌套在另一个块中,但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量,而外部不能使用语句块中定义的变量,因为语句块中定义的变量作用域只限于语句块。

    //语句块 
    public class Test19 {
        public static void main(String[] args) {
            int n;
            int a;
            {
                int k;
                int n;  //编译错误:不能重复定义变量n
            }  //变量k的作用域到此为止
        }
    }

    方法

           方法就是一段用来完成特定功能的代码片段,类似于其它语言的函数。

          方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中,函数是最基本单位,整个程序由一个个函数调用组成。面向对象中,整个程序的基本单位是类,方法是从属于类和对象的。

    方法声明格式:

    [修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表) {
        Java语句;
        … … …
        return 返回值;
     }

    方法的调用方式:

          对象名.方法名(实参列表)

          方法的详细说明:

          1. 形式参数:在方法声明时用于接收外界传入的数据,如果方法不需要接收任何参数,则参数列表为空,即()内不写任何内容。格式:(参数类型  实参1,参数类型  实参2,……)。

          2. 实参:调用方法时实际传给方法的数据。参数类型:用于限定调用方法时传入参数的数据类型。

          3. 返回值:方法在执行完毕后被return语句返还给调用它的环境的数据。

          4. 返回值类型:事先约定的返回值的数据类型,如无返回值,必须显示指定为为void,方法中return语句可以省略。                          return关键字:用于结束方法以及返回方法指定类型的值。

          5. 修饰符:方法的修饰符比较多,有对访问权限进行限定的,有静态修饰符static,还有最终修饰符final等。

    方法的声明及调用:

    public class Test20 {
        /** main方法:程序的入口 */
        public static void main(String[] args) {
            int num1 = 10;
            int num2 = 20;
            //调用求和的方法:将num1与num2的值传给add方法中的n1与n2
            // 求完和后将结果返回,用sum接收结果
            int sum = add(num1, num2);
            System.out.println("sum = " + sum);  //输出:sum = 30
            //调用打印的方法:该方法没有返回值
            print();
        }
        /** 求和的方法 */
        public static int add(int n1, int n2) {
            int sum = n1 + n2;
            return sum;  //使用return返回计算的结果
        }
        /** 打印的方法 */
        public static void print() {
            System.out.println("北京欢迎你...");
        }
    }

    运行效果图:

    //打印三个长宽不同的矩形。
    public class Example19 {
    	public static void main(String[] args) {
    		//下面的循环是使用*打印一个宽为5、高为3的矩形
    		for(int i = 0; i < 3; i++) {
    			for(int j = 0; j < 5; j++) {
    				System.out.print("*");
    			}
    			System.out.print("\n");
    		}
    		System.out.print("\n");
    		//下面的循环是使用*打印一个宽为4、高为2的矩形
    		for(int i = 0; i < 2; i++) {
    			for(int j = 0; j < 4; j++) {
    				System.out.print("*");
    			}
    			System.out.print("\n");
    		}
    		System.out.print("\n");
    		//下面的循环是使用*打印一个宽为10、高为6的矩形
    		for(int i = 0; i < 6; i++) {
    			for(int j = 0; j < 10; j++) {
    				System.out.print("*");
    			}
    			System.out.print("\n");
    		}
    		System.out.print("\n");
    	}
    }
    
    //将使用“*”打印矩形的功能定义为方法,在程序中调用三次。
    public class Example20 {
    	public static void main(String[] args) {
    		printRectangle(3, 5);  //调用printRectangle()方法实现打印矩形
    		printRectangle(2, 4);
    		printRectangle(6, 10);
    	}
    	
    	public static void printRectangle(int height, int width) {
    		//下面使用嵌套for循环实现*打印矩形
    		for(int i = 0; i < height; i++) {
    			for(int j = 0; j < width; j++) {
    				System.out.print("*");
    			}
    			System.out.print("\n");
    		}
    		System.out.print("\n");
    	}
    }
    
    public class Example21{
    	public static void main(String[] args) {
    		int area = getArea(3, 5);  //调用getArea方法
    		System.out.println(" The area is " + area);
    	}
    	//下面定义了一个矩形面积的方法,接收两个参数,其中x为高,y为宽
    	private static int getArea(int x, int y) {
    		int temp = x * y;  //试一下变量temp记住运算结果
    		return temp;  //将变量temp的值返回
    	}
    }

     

    1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。

    2. return 语句终止方法的运行并指定要返回的数据。

    3. Java中进行方法调用中传递参数时,遵循值传递的原则(传递的都是数据的副本):

    4. 基本类型传递的是该数据值的copy值。

    5. 引用类型传递的是该对象引用的copy值,但指向的是同一个对象。


    方法的重载(overload)

           方法的重载是指一个类中可以定义多个方法名相同,但参数类型或个数不同的方法。 调用时,会根据不同的参数自动匹配对应的方法。

    重载的方法,实际是完全不同的方法,只是名称相同而已!

    构成方法重载的条件:

    1.不同的含义:形参类型、形参个数、形参顺序不同

    2.只有返回值不同不构成方法的重载

    int a(String str){} 与 void a(String str){}  //不构成方法重载

    3.只有形参的名称不同,不构成方法的重载

    int a(String str){} 与 int a(String s){}  //不构成方法重载

     

    方法重载:

    public class Test21 {
        public static void main(String[] args) {
            System.out.println(add(3, 5));  // 8
            System.out.println(add(3, 5, 10));  // 18
            System.out.println(add(3.0, 5));  // 8.0
            System.out.println(add(3, 5.0));  // 8.0
            // 我们已经见过的方法的重载
            System.out.println();  // 0个参数
            System.out.println(1);  // 参数是1个int
            System.out.println(3.0);  // 参数是1个double
        }
        /** 求和的方法 */
        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) {
            double sum = n1 + n2;         
            return sum;
        }  
    }
    
    
    

    递归结构

           递归是一种常见的解决问题的方法,即把问题逐渐简单化。递归的基本思想就是“自己调用自己”,一个使用递归技术的方法将会直接或者间接的调用自己。

          利用递归可以用简单的程序来解决一些复杂的问题。比如:斐波那契数列的计算、汉诺塔、快排等问题。

          递归结构包括两个部分:

          1.定义递归头。解答:什么时候不调用自身方法。如果没有头,将陷入死循环,也就是递归的结束条件。

          2.递归体。解答:什么时候需要调用自身方法。

    //递归:计算n!  
    public class Test22 {
        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);  //耗时:32ms
        }
        /** 求阶乘的方法*/
        static long  factorial(int n){
            if(n==1){  //递归头
                return 1;
            }else{  //递归体
                return n*factorial(n-1);//n! = n * (n-1)!
            }
        }
    }

    运行效果图:

    递归原理分析图:

    public class Example24{
    	public static void main(String[] args) {
    		int sum = getSum(4);  //调用递归方法,获得1~4的和
    		System.out.println("sum = " + sum);
    	}
    	//使用递归实现求1~n的和
    	private static int getSum(int n) {
    		if (n == 1) {
    			//满足条件,递归结束
    			return 1;
    		}
    		int temp = getSum(n - 1);
    		return temp + n;
    	}
    }
    

     运行效果图:

    递归原理分析图:

    递归的缺陷:

           简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈,内存耗用多,在递归调用层次多时速度要比循环慢的多,所以在使用递归时要慎重。

    比如上面的递归耗时558ms。但是用普通循环的话快得多。

    //使用循环求n! 
    public class Test23 {
        public static void main(String[] args) {
            long d3 = System.currentTimeMillis();
            int a = 10;
            int result = 1;
            while (a > 1) {
                result *= a * (a - 1);
                a -= 2;
            }
            long d4 = System.currentTimeMillis();
            System.out.println(result);
            System.out.printf("普通循环费时:%s%n", d4 - d3);
        }
    }

    运行效果图:

           任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题,并且易于理解和调试,并且不强调效率问题时,可以采用递归;

          在要求高性能的情况下尽量避免使用递归,递归调用既花时间又耗内存。


    总结

           1.从结构化程序设计角度出发,程序有三种结构:顺序结构、选择结构和循环结构。

      2.选择结构

         (1)if单选择结构 if-else双选择结构 if-else if-else多选择结构。

         (2)switch多选择结构。

      3.多选择结构与switch的关系:当布尔表达式是等值判断的情况,可使用多重选择结构或switch结构,如果布尔表达式区间判断的情况,则只能使用多重选择结构。

         (1)循环结构

         (2)当型:while与for

         (3)直到型:do-while

      4.while与do-while的区别,在布尔表达式的值为false时while的循环体一次也不执行,而do-while至少执行一次。

      5.break可以在switch与循环结构中使用,而continue只能在循环结构中使用。

      6.方法就是一段用来完成特定功能的代码片段,类似于其它语言的函数。

      7.方法的重载是指一个类中可以定义多个方法名相同,但参数不同的方法。 调用时,会根据不同的参数自动匹配对应的方法。

      8.任何能用递归解决的问题也能使用迭代解决。在要求高性能的情况下尽量避免使用递归,递归调用既花时间又耗内存。

    转载自http://www.sxt.cn/Java_jQuery_in_action/openketang-Summery.html 

    展开全文
  • 下面小编就为大家带来一篇基于java中的流程控制语句总结(必看篇)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java编程语言控制语句.docx
  • 详细内容java的三种基本控制语句分别是:顺序结构、选择结构、循环结构。下面本篇文章就来带大家了解一下,希望对你们有所帮助。顺序结构顺序结构是程序最简单最基本的流程控制,只要按照解决问题的顺序写出相应的...

    详细内容

    java的三种基本控制语句分别是:顺序结构、选择结构、循环结构。下面本篇文章就来带大家了解一下,希望对你们有所帮助。

    16904792407cd6640356bfeec96f497e.png

    顺序结构

    顺序结构是程序最简单最基本的流程控制,只要按照解决问题的顺序写出相应的语句,然后按照代码的先后顺序,依次执行;程序中大多数的代码都是这样执行的。

    执行顺序是自上而下,依次执行。package Test3;

    public class OrderDemo {

    public static void main(String[] args) {

    System.out.println(1);

    System.out.println(2);

    System.out.println(3);

    }

    }

    顺序输出:1 2 3

    选择结构

    选择结构用于判断给定的条件,根据判断的结果判断某些条件,根据判断的结果来控制程序的流程。使用选择结构语句时,要用条件表达式来描述条件。

    Java有两种条件语句:

    ● if 语句

    ● switch 语句

    if 语句

    一个 if语句包含一个布尔表达式和一条或多条语句。如果布尔表达式的值为true,则执行 if 语句中的代码块,否则执行 if 语句块后面的代码。

    语法if (布尔表达式) {

    // 如果布尔表达式为true将执行的语句

    }

    if 语句后面可以跟 else 语句,当 if 语句的布尔表达式值为 false 时, else 语句块就会被执行。语法:if(布尔表达式){

    //如果布尔表达式的值为true

    }else{

    //如果布尔表达式的值为false

    }

    示例:public class Test {

    public static void main(String args[]){ int x = 30;

    if( x < 20 ){

    System.out.print("这是 if 语句");

    }else{

    System.out.print("这是 else 语句");

    }

    }

    }

    输出:这是 else 语句

    switch 语句

    switch 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。

    语法switch(expression){

    case value :

    //语句

    break; //可选

    case value :

    //语句

    break; //可选

    //你可以有任意数量的case语句

    default : //可选

    //语句

    }

    switch 语句有如下规则:

    ● switch 语句中的变量类型可以是:byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串类型了,同时 case 标签必须为字符串常量或字面量。

    ● switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。

    ● case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。

    ● 当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。

    ● 当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。

    ● switch 语句可以包含一个 default 分支,该分支必须是 switch 语句的最后一个分支。 default在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

    示例:public class Test {

    public static void main(String args[]){ //char grade = args[0].charAt(0);

    char grade = 'C';

    switch(grade)

    { case 'A' :

    System.out.println("优秀");

    break; case 'B' : case 'C' :

    System.out.println("良好"); break; case 'D' :

    System.out.println("及格"); case 'F' :

    System.out.println("你需要再努力努力"); break; default :

    System.out.println("未知等级");

    }

    System.out.println("你的等级是 " + grade);

    }

    }

    输出:良好

    你的等级是 C

    循环结构

    顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,就需要使用循环结构。

    循环结构可以减少源程序重复书写的工作量,用来描述重复执行某段算法的问题,这是程序设计中最能发挥计算机特长的程序结构 。循环结构可以看成是一个条件判断语句和一个向回转向语句的组合。

    编程语言一般都有三种主要的循环结构:

    ● while 循环

    ● do...while 循环

    ● for 循环

    while 循环

    while是最基本的循环,它的结构为:while( 布尔表达式 ) {

    // 循环内容

    }

    只要布尔表达式为true,循环就会一直执行下去。

    示例:int x = 10;while( x < 15 ) {

    System.out.println("value of x : " + x );

    x++;

    }

    输出:value of x : 10

    value of x : 11

    value of x : 12

    value of x : 13

    value of x : 14

    do...while 循环

    对于 while语句而言,如果不满足条件,则不能进行循环。但有时候我们需要即使不满足条件,也至少执行一次。do...while 循环和 while 循环相似,不同的是,do...while循环至少会执行一次。do {

    //代码语句

    }while(布尔表达式);

    注意:布尔表达式在循环体的后面,所以语句块在监测布尔表达式之前已经执行了。如果布尔表达式的值为true,则语句块一直执行,直到布尔表达式的值为false。

    示例:int x = 10;

    do{

    System.out.println("value of x : " + x );

    x++;

    }while( x < 15 );

    输出:value of x : 10

    value of x : 11

    value of x : 12

    value of x : 13

    value of x : 14

    for 循环

    for 循环执行的次数是在执行前就确定的。语法格式如下:for(初始化; 布尔表达式 ; 更新) {

    // 代码语句

    }

    关于 for 循环有以下几点说明:

    ● 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。

    ● 然后,检测布尔表达式的值。如果为true,循环体被执行;如果为false,循环终止,开始执行循环体后面的语句。

    ● 执行一次循环后,更新循环控制变量。

    ● 再次监测布尔表达式。循环执行上面的过程。

    示例:for(int x = 10; x < 15; x = x+1) {

    System.out.println("value of x : " + x );

    }

    输出:value of x : 10

    value of x : 11

    value of x : 12

    value of x : 13

    value of x : 14

    展开全文
  • java流程控制语句

    2021-01-21 17:08:49
     分支语句实现程序流程控制功能,根据一定的条件有选择的执行或跳过特定语句  分支语句分为2类:单分支语句和多选语句。  if语句,if-else语句,if-else if语句,switch语句。  if语句格式:  if(表达式) ...
  • 详解JAVA流程控制语句

    2020-08-30 20:28:50
    主要介绍了Java中的流程控制语句,循环等语句是Java编程中流程控制的基础,需要的朋友可以参考下
  • 实验二 Java基本数据类型与控制语句 目的 掌握char型数据和int型数据之间的相互转换同时了解unicode字符表 掌握使用ifelse if多分支语句 使用ifelse分支和while循环语句解决问题 内容 1输出希腊字母表 实验要求 编写...
  • Java流程控制语句

    2021-02-17 10:24:23
    java程序中控制语句分为三大块: 一、 if…else语句 该语句又可以划分为四个模块: 1.if语句 这是最简单的if语句。假如当某个程序执行有很多答案,在众多答案中有自己需要的,也有不需要的,那么我们可以通过if语句...
  • 主要介绍了JAVA流程控制语句的的相关资料,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • java控制语句(2)while break continue

    千次阅读 2019-04-12 18:00:53
    关于while循环 int i = 0; while(i<10){ i++; System.out.println(i);//1-10 } do while int i = 0; do { i++; System.out.println(i); }while(i<...语句: ...可以用在switch语句...
  • 主要介绍了Java常用流程控制语句实现原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java控制语句

    2013-10-01 08:28:48
    Java程序通过控制语句来执行程序流,完成一定的任务。程序流是由若干个语句组成的,语句可以是单一的一条语句,如c=a+b,也可以是用大括号{}括起来的一个复合语句。Java中的控制语句有以下几类:  ◇ 分支语句:if-...
  • 主要介绍了java执行SQL语句实现查询的通用方法详解,具有一定借鉴价值,需要的朋友可以参考下。
  • 1.下列语句序列执行后,m 的值是 int a=10, b=3, m=5; if( a==b ) m+=a; else m=++a*m; A) 15 B) 50 C) 55 D) 5
  • java中的流程控制语句

    2022-04-09 20:59:58
    java中的流程控制语句
  • Java 三种流程控制语句

    千次阅读 2019-06-25 11:10:10
    如果代码里没有流程控制,程序从上到下按照书写的格式依次执行。 public static void main(String[] args) { int result = 1; result = result++; System.out.println("result=" + result); //1 ...
  • Java流程控制语句.pptx

    2021-09-27 10:45:33
    Java流程控制语句.pptx
  • 详详解解JAVA流流程程控控制制语语句句 这篇文章主要介绍了Java中的流程控制语句,循环等语句是Java编程中流程控制的基础,需要的朋友可以参考下 第第一一节 JAVA条条件件语句句之之if语句句 1.单 的if语句语法 if ...
  • 在介绍Java的流程控制语句之前,我们先了解一下键盘录入 键盘录入 首先我们要知道为什么要使用键盘录入数据?因为使用键盘录入数据可以让程序的数据更符合开发的数据,让程序更灵活 那么如何实现键盘录入呢?...
  • Java中的控制语句

    千次阅读 2017-11-30 19:42:11
    Java中的控制语句 一. Java中的控制语句一般用if 和switch控制语句     If语句中一般分为 单分支 :if… 双分支:if…else… 多分支:if…elseif…elseif…else   1、If语句的结构 If(表达式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 421,203
精华内容 168,481
关键字:

java控制语句

java 订阅
友情链接: shudu.zip