Java基础知识篇03——Java运算符、选择结构、循环结构

一、运算符

1、逻辑运算

概念：

​ 用来连接布尔类型的两个值或表达式，逻辑运算两边必须是布尔类型的值或者是布尔类型表达式。通常配合循环和条件语句使用，最终结果也是布尔类型。

作用：

​ 应用于多个条件的组合判断。

& ：逻辑单与，表示并且，有假即假，没有短路功能，有位运算功能，两边都为true ，结果为true。

| ：逻辑单或，表示或者，有真即真，没有短路功能，有位运算功能，只要有一边为true，结果为true。

&& ：逻辑双与，表示并且，有假即假，有短路功能，没有位运算功能，两边都为true ，结果为true。

|| : 逻辑双或，表示或者，有真即真，有短路功能，没有位运算功能，只要有一边为true，结果为true。

^ : 逻辑异或，同假异真【了解 现实开发，基本不用】，两边不一样，结果为true ，否则为false。

! ：逻辑非，表示取反，非真即假，非假即真 (操作一个变量/值(true|false))。

2、&&、||和 &、| 的区别？

&&、|| ：有短路功能

&、| ：没有短路功能

什么是短路？

​ 短路问题：当逻辑运算左边能够确定整个表达式结果值的时候，就会发生短路，不会再计算后面的结果了，这样可以提高程序运算效率。

例如：&&当左边为false时，右边的就短路了

public class _12LogicalOperation {
    public static void main(String[] args) {
        // 验证短路，怎么验证短路？
        int a = 1;
        System.out.println(a > 2 && ++a == 2);
        System.out.println(a);// 1，说明&&后面没有运算，证明了短路。

        int b = 1;
        System.out.println(b > 2 & ++b == 2);
        System.out.println(b);// 2，说明&后面运算了，证明了没有短路。

       // 验证优先级，结果为false，表示||优先级高或者相等。true表示&&优先级高。
        System.out.println(a > 0 || true && false );// true
    }
}

二、选择结构

2.1、if语句

概念：

​ 选择结构就是让程序有选择的执行，满足条件就执行，不满足就不执行。根据判断的结果来控制程序的流程，是属于流程控制语句。其它两个流程控制语句是顺序结构（程序的执行是从左到右，从上到下）、循环结构（程序重复的干一件事）。

作用：

​ 让程序有选择的执行。例如：用户登录的时候，只有用户名和密码都输入正确才能登录成功等

2.1.1、if单条件语句

语法：

if(判断条件) {
	语句;
}
//判断条件: 布尔类型的值或者表达式
//执行语句：当条件满足时执行语句（可以是一条语句，也可以是一组语句）

eg：

public class _01If {
    public static void main(String[] args) {
        // 需求1：需要让智能机器人自动充电，充电条件电量低于10
        int power = 9;
        if (power < 10) {// if条件判断，电量power < 10        
            System.out.println("主人，我被玩没电了，请插我充电！");
        }
    }
}

2.1.2、if ...else双条件语句

语法：

if(判断条件) {
	if语句;
} else {
	else语句;
}
//判断条件: 布尔类型的值或者表达式
//执行语句：当条件满足时执行if中的语句,不满足则执行else中的语句

eg：

public class _01If {
    public static void main(String[] args) {
        // 需求2：智能机器人在充电条件电量低于10的时候，自动充电。不小于10，则提醒主人，一起玩耍！
        int power2 = 11;
        if (power2 < 10) {
            System.out.println("主人，我被玩没电了，请插我充电！");
        } else {
            System.out.println("主人，我们一起耍一下！");
        }
    }
}

2.1.3、if...else if多条件语句

语法：

if(判断条件1) {
	语句1;
} else if(判断条件2) {	
	语句2;
} else if(判断条件3) {
	语句3;
} ...
else {
 	else语句
}
//判断条件: 布尔类型的值或者表达式
//执行语句：按照从上到下顺序匹配条件，如果满足条件1，就执行语句1；如果满足条件2，就执行语句2；如果满足条件3，就执行语句3；
//注意：只会执行一个满足的条件，哪怕下面有其它的满足条件的也不会执行了。所有条件都不满足就执行else语句中代码。

eg：

public class _01If {
    public static void main(String[] args) {
        /*
         *  需求3：智能机器人在充电条件电量低于10的时候，自动充电。
         *  power >= 10 并且< 60 提醒主人，一起看片，陶冶情操！
         *  power >= 60 并且< 80 提醒主人，实践检验一下！
         *  power >= 80 并且<= 100 提醒主人，我们来一点激烈的运动！
         */
        int power3 = 69;
        if (power3 >= 0 &&power3 < 10) {          
            System.out.println("主人，我被玩没电了，请插我充电！");
        } else if(power3 >= 10 && power3 < 60) {        
            System.out.println("主人，一起看片，陶冶情操！");
        } else if(power3 >= 60 && power3 < 80) {            
            System.out.println("主人，实践检验一下！");
        } else if(power3 >= 80 && power3 <= 100) {          
            System.out.println("主人，我们来一点激烈的运动！");
        } else {         
            System.out.println("主人，我被你玩坏了！");
        }
    }
}

注意事项：

  1. 选择结构是从上到下开始匹配，一旦匹配上一个条件后，整个条件语句就结束了，哪怕后面也能匹配上条件也不会执行了 。
  2. if 和 if else 语句，后面可以不写{},但是不建议，因为不写{} ,只能控制一行代码。
  3. if(){} else if(){}后可以不写 else，一般根据业务需求决定。

2.2、swtich语句

语法：

声明变量
switch(变量){
	case 值1:
		功能语句1
		功能语句2...
		break;
	case 值2:
		功能语句1
		功能语句2...
		break;
	case 值3:
		功能语句1
		功能语句2...
		break;				
	default:// 相当于条件语句中else，所有的case匹配不上执行default
		default语句
		break;
}

eg：

public class _02Switch {
    public static void main(String[] args) {
        // 通过switch结构优化上面案例代码
        // 声明一个int类型变量weekDay2，表示一周中的某一天。赋值4
        int weekDay2 = 4;
        switch (weekDay2) {// switch()中写变量weekDay2
            case 1: // 表示匹配weekDay的是1的情况
                System.out.println("周一： 好好学习");
                break;// break表示破坏，这里结束当前switch结构
            case 2: // 表示匹配weekDay2的是2的情况
                System.out.println("周二：看片学习");
                break;
            case 3: // 表示匹配weekDay2的是3的情况
                System.out.println("周三： 实践学习");
                break;
            case 4: // 表示匹配weekDay2的是4的情况
                System.out.println("周四： 吃药补补身体！");
                break;
            case 5: // 表示匹配weekDay2的是5的情况
                System.out.println("周五： 爬山锻炼身体！");
                break;
            case 6: // 表示匹配weekDay2的是6的情况
                System.out.println("周六： 休息，给身体放个假");
                break;
            case 7: // 表示匹配weekDay2的是7的情况
                System.out.println("周日：总结一周所得！");
                break;
            default: // 所有情况都不匹配会执行default
                System.out.println("出错了");
                break;
        }
    }
}

注意事项：

  1. 每个case之间顺序可以交换，不影响代码运行。
  2. default不一定放在末尾 在所有case失效的时候就会被执行到。
  3. case中值与 key类型必须一致。
  4. 最后一个break可以省略，但不建议。
  5. break可以省略，但会导致后续case条件判断失效，按照从上到下顺序执行，直到找到第一个break跳出switch结构，如果没有找则执行到末尾后结束switch结构。

2.3、if、switch使用场景

  1. 只有比较固定的情况下，使用switch结构，其他情况一律用if语句。
  2. switch不适应区间条件，只适用于一些条件比较固定的场景。例如：vip、星座、QQ状态、月份、礼拜、生肖、季节...

三、循环语句

//	为什么要学习循环？先来看一个需求：
// 请打印10句，我爱Java，Java让我快乐！
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");
System.out.println("我爱Java，Java让我快乐！");

很明显这样写代码，非常浪费时间，可读性也不好，所以，我们要学习循环解决这样的问题。

循环概念：

​ 循环结构是指在程序中需要重复执行某个功能的一种结构，是一种常见的控制流程。

​ 循环结构需要有一个结束条件，否则会形成死循环，导致内存溢出。

循环作用：

​ 循环结构可以复用代码。

3.1、while循环

特点：先判断，如果满足条件再循环。

基本语法：

1.初始化条件（根据条件判断是否要写）
while(2.循环条件判断){
	3.循环体（重复干的事）
	4.循环控制（根据条件判断是否要写）
}

循环条件判断：布尔类型的值或者表达式。

循环体：当循环条件为true时执行循环体，当为false时终止循环，不执行循环体。

执行流程：

​ 第1次：1. 初始化条件语句 => 2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

​ 第2次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

​ 第3次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

​ ...

​ 最后1次： 2.条件判断语句

eg：

// 请打印10句，我爱Java，Java让我快乐！
// 声明一个int类型变量count表示次数，赋值1
int count = 1;// 1. 初始化条件
while (count <= 10) {// count <= 10是 2.循环条件判断
	System.out.println("我爱Java，Java让我快乐！ : " + count);// 3.循环体 【重复干的事】
	count++;// 次数count+1 4.循环控制语句
}

3.2、do-while循环

特点：先执行一次循环体，然后再判断，如果满足条件再循环，只会预执行一次。

一般用在扫雷、获取连接数据库、远程控制、坦克大战、打飞机游戏等场景。

基本语法:

1.初始化条件（根据条件判断是否要写）
do {
   3.循环体（重复干的事）
4.循环控制（根据条件判断是否要写）
} while (2.条件判断);// 注意分号

循环条件判断：布尔类型的值或者表达式。

循环体：当循环条件为true时执行循环体，当为false时终止循环，不执行循环体。

执行流程：

第1次：1. 初始化条件语句 => 3. 循环体 => 4. 循环控制语句

第2次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

第3次：2.条件判断语句 => 3. 循环体 => 4. 循环控制语句

...

最后1次： 2.条件判断语句

eg：

public class _05While {
    public static void main(String[] args) {
    // 请打印10句，我爱Java，Java让我快乐！
    // 声明一个int类型变量count2表示次数，赋值1
        int count2 = 1;// 1. 初始化条件
        do {
            // 打印：我爱Java，Java让我快乐！
            System.out.println("我爱Java，Java让我快乐！ : " + count2);// 3.循环体 【重复干的事】
            count2++;// 次数count+1 4.循环控制语句
        } while (count2 <= 10);// ()后的分号必须写。
    }
}

3.3、for循环

基本语法：

for(1.初始化条件语句;	2.条件判断语句;	 4.循环控制语句) {
	3. 循环体
}

执行流程：

​ 第1次：1. 初始化条件语句 => 2.条件判断语句 => 3. 循环体 => 4. 循环控制语句
第2次：2. 条件判断语句 => 3. 循环体 => 4. 循环控制语句
第3次：2. 条件判断语句 => 3. 循环体 => 4. 循环控制语句
...
最后1次： 2.条件判断语句

代码案例：

public class _05While {
    public static void main(String[] args) {
    // 请打印10句，我爱Java，Java让我快乐！
    // for循环就是将while循环中部分条件移动到()中
    for (int i = 1; i <= 10; i++) {
            // 打印：我爱Java，Java让我快乐！
            System.out.println("我爱Java，Java让我快乐！ : " + i);// 3.循环体 【重复干的事】
        }
    }
}

执行流程分析图：

1

3.4、嵌套循环：

  1. 顾名思义，嵌套循环指的是循环中嵌套一个循环【其实就是外层循环的循环体是另外一个循环而已】，但最好嵌套不要超过3层，否则效率太低。
  2. 双层循环总结的规律：（当成是轮子，可以直接使用）
  3. 外层循环执行一次，内层循环执行所有次
  4. 外层循环负责行数，内层负责每一行中列数
  5. 循环可以是while、 do while、 for循环任意一种，下面以for循环举例
public class _10ForFor {
    public static void main(String[] args) {
        /*
         * 请打印如下图案：5 * 5 的星星
         * 	*****
         * 	*****
         * 	*****
         * 	*****
         * 	*****
         */
        //	for (int i = 1; i <= 5; i++) {
        //		System.out.println("*****");
        //	}
        /*
        // 每次只能打印一个*
        // 第1行： *****
        for (int i = 1; i <= 5; i++) {
            // 打印一行中 的每一个 星星
            System.out.print("*");
        }
        // 换行
        System.out.println();

        // 第2行： *****
        for (int i = 1; i <= 5; i++) {
            // 打印一行中 的每一个 星星
            System.out.print("*");
        }
        // 换行
        System.out.println();

        // 第3行： *****
        for (int i = 1; i <= 5; i++) {
            // 打印一行中 的每一个 星星
            System.out.print("*");
        }
        // 换行
        System.out.println();

        // 第4行： *****
        for (int i = 1; i <= 5; i++) {
            // 打印一行中 的每一个 星星
            System.out.print("*");
        }
        // 换行
        System.out.println();

        // 第5行： *****
        for (int i = 1; i <= 5; i++) {
            // 打印一行中 的每一个 星星
            System.out.print("*");
        }
        // 换行
        System.out.println();
        用循环继续优化代码
        */
        // 外层循环控制总行数
        for (int j = 1; j <= 5; j++) {
            // 内存for循环控制列数，负责 每一行中 列的输出： *****
            for (int i = 1; i <= 7; i++) {
                // 打印一行中 的每一个 星星
                System.out.print("*");
            }
            // 换行
            System.out.println();
        }

        /*
         *	利用好总结出来的规律
         *		外层循环执行一次，内层循环执行所有次
                外层循环负责行数，内层负责每一行中列数		
             * 		 	行i	 列j	
             **		    1	  1
             ***		2	  2
             ****		3	  3
             *****		4	  4
             ******	    5	  5
         */
        for (int i = 1; i < 6; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }		
    }
}

3.5、循环控制语句

概念：

​ 对整个循环流程进行控制，可提前终止或跳出循环

3.5.1、break

作用：表示结束当前层循环（锚点自己扩展）

2

3.5.2、continue

作用：表示跳过当前次循环，继续下一次循环

3

3.5.3、return

作用：表示结束的当前方法

4

eg：

public class _09ForControl {
    public static void main(String[] args) {
        // 1. 请打印1-200所有6的倍数中前7个
        int count = 0;
        for (int i = 1; i <= 200; i++) {
            if (i % 6 == 0) {
                System.out.println(i);
                count++;
                if (count == 7) {
                    break;// 表示结束当前层循环
                }
            }
        }
        System.out.println("===============================");

        // continue使用跳过当前i=5这一次的打印，继续后面的打印
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                continue;
            }
            System.out.println(i);
        }
        System.out.println("循环外部的代码");

        // 2. 求1—100之间不能被3整除的数之和大于(或等于)100的第一个数字 continue/break
        int sum = 0;// 声明一个int类型变量sum，赋值0，保存和
        for (int i = 1; i <= 100; i++) {
            if (i % 3 != 0) {
                System.out.println(i);
                sum += i;
                if (sum >= 100) {
                    System.out.println("最后：" + i);
                    break;
                }
            }
        }
        System.out.println("和：" + sum);

        int sum2 = 0;
        for (int i = 1; i <= 100; i++) {
            // 判断当前i是否是3的倍数，如果是，则跳过这一次循环
            if (i % 3 == 0) {
                continue;
            }
            // 打印不是3的倍数的数字i
            System.out.println(i);
            // 累加到sum2中
            sum2 += i;
            if (sum2 >= 100) {// 判断sum2>=100的时候结束循环
                // 打印当前结束的时候i的值
                System.out.println("最后：" + i);
                break;
            }
        }
        System.out.println("和：" + sum2);
    }
}

3.6、foreach

概念：增强for循环就是类似for循环的结构，专业称呼为foreach

作用： 只是用来简化遍历数组和集合的过程；

缺点： 没有索引，凡是涉及有索引相关操作还是用普通for循环;

语法：

for(元素类型 e : 数组/集合){
	e是变量，随便命名。就是每次获取到的元素
}
for (int e : arr) {// arr是数组名， int 是元素类型  e变量是每一个元素
	System.out.println("元素 ：" + e);
}

怎么选择用普通for循环还是增强for循环？

如果要操作某一个具体的元素的时候，用普通for循环，因为操作元素需要通过下标。

如果只是遍历的话，用增强for循环 foreach

本文作者：白夜的白

本文链接：https://www.cnblogs.com/baiye123/p/18078096

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   白夜的白  阅读(76)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
AI IDE Trae
💬
评论
📌
收藏
💗
关注
👍
推荐
🚀
回顶
➖
收起
  1. 1 404 not found REOL
404 not found - REOL
00:00 / 00:00
An audio error has occurred.