2021-11-07----韩顺平Java入门第五天-第六天

最新推荐文章于 2024-08-16 23:08:28 发布

Tingyu23157

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量281

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Tingyu23157/article/details/121190125

版权

韩顺平Java入门第五天-第六天

运算符
运算符是一种特殊的符号，用以表示数据的运算，幅值和比较等。
1) 算术运算符
2) 赋值运算符
3) 关系运算符
4) 逻辑运算符
5) 位运算符
6) 三元运算符
1.算术运算符
算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。
在这里插入图片描述

算数运算符案例：
/**
 * 演示算术运算符的使用
 */
public class ArithmeticOperator { 
//编写一个 main 方法 
    public static void main(String[] args) { 
        // /使用 
        System.out.println(10 / 4); //从数学来看是 2.5
        // java 中 2 (两个整数做除法，结果去除小数部分)
        System.out.println(10.0 / 4); //java 是 2.5 
        //（10.0是double，结果提高精度结果有小数部分）
        // 注释快捷键 ctrl + /, 再次输入 ctrl + / 取消注释 
        double d = 10 / 4;//java 中 10 / 4 = 2（整数相除）, 2=>2.0（整型=>double） 
        System.out.println(d);// 是 2.0 
        // % 取模 ,取余 
        // 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
        // -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
        // 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
        // -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
        System.out.println(10 % 3); //1 
        System.out.println(-10 % 3); // -1 
        System.out.println(10 % -3); //1 
        System.out.println(-10 % -3);//-1 
        //++的使用 
        //
        int i = 10; 
        i++;//自增 等价于 i = i + 1; => i = 11 
        ++i;//自增 等价于 i = i + 1; => i = 12 
        System.out.println("i=" + i);//12 
        /*作为表达式使用 
        前++：++i 先自增后赋值 
        后++：i++先赋值后自增 
        */ 
        int j = 8; //
        //int k = ++j; //等价 j=j+1;k=j; 
        int k = j++; // 等价 k =j;j=j+1; 
        System.out.println("k=" + k + "j=" + j);//8 9 
        } 
}

自增自减课堂练习

//练习 
public class ArithmeticOperatorExercise01 { 
//编写一个 main 方法 
    public static void main(String[] args) { 
    //int i = 1;//i->1 // 
    //i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp; // 
    //System.out.println(i); // 1 
    // int i=1; 
    // i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp; 
    // System.out.println(i); //2 
    // 测试输出
    int i1 = 10; 
    int i2 = 20; 
    int i = i1++; 
    System.out.print("i="+i);//10 
    System.out.println("i2="+i2);//20 
    i = --i2; 
    System.out.print("i="+i);//19 
    System.out.println("i2="+i2);//19 
	} 
}

//课堂练习 
public class ArithmeticOperatorExercise02 { 
    //编写一个 main 方法 
    public static void main(String[] args) { 
    //1.需求: //假如还有 59 天放假，问：合 xx 个星期零 xx 天 
    //2.思路分析 
    //(1) 使用 int 变量 days 保存 天数
    //(2) 一个星期是 7 天 星期数 weeks： days / 7 零 xx 天 leftDays days % 7 
    //(3) 输出 //
    //3.走代码 
    int days = 25911; 
    int weeks = days / 7; 
    int leftDays = days % 7; 
    System.out.println(days + "天 合" + weeks + "星期零" + leftDays + "天");

    //1 需求
    //定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为 ：5/9*(华氏温度-100),
    //请求出华氏温度对应的摄氏温度 
    //2 思路分析 
    //(1) 先定义一个 double huaShi 变量保存 华氏温度 
    //(2) 根据给出的公式，进行计算即可 5/9*(华氏温度-100) 考虑数学公式和 java 语言的特性 
    //(3) 将得到的结果保存到 double sheShi 
    //3 走代码 
    double huaShi = 1234.6; 
    double sheShi = 5.0 / 9 * (huaShi - 100); 
    System.out.println("华氏温度" + huaShi + " 对应的摄氏温度=" + sheShi); 
	} 
}

2.关系运算符
在这里插入图片描述

案例演示：
//RelationalOperator
//演示关系运算符的使用 
public class RelationalOperator { 
    //编写一个 main 方法 
    public static void main(String[] args) { 

        int a = 9; //老韩提示: 开发中，不可以使用 a, b 
        int b = 8; 
        System.out.println(a > b); //T 
        System.out.println(a >= b); //T 
        System.out.println(a <= b); //F 
        System.out.println(a < b);//F
    	System.out.println(a == b); //F 
    	System.out.println(a != b); //T 
    	boolean flag = a > b; //T 
    	System.out.println("flag=" + flag); 

	} 
}

3.逻辑运算符
分为两组学习
短路与 && ，短路或 ||，取反 !
逻辑与 &，逻辑或 |，^ 逻辑异或
在这里插入图片描述
1）说明逻辑运算规则：
1) a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false。
2) a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false 。
3) a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false。
4) a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false 。
5) !a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true 。
6) a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false。
2）&&和&基本规则和使用区别
基本规则
①短路与&& ：条件 1&&条件 2 两个条件都为 true，结果为 true,否则 false 。
②逻辑与& ：条件 1&条件 2 两个条件都为 true，结果为 true,否则 false。
使用区别
①&&短路与：如果第一个条件为False，则第二个条件不会判断，最终结果为false，效率高。
②&逻辑与：不管第一个是否为false，第二个条件都要判断，效率低。
③开发中，我们使用的基本是短路与，效率高。

/**
 * 演示逻辑运算符的使用 
 */
public class LogicOperator01 { 
    //编写一个 main 方法 
    public static void main(String[] args) { 
	    //&&短路与 和 & 案例演示 
	    int age = 50; 
	    if(age > 20 && age < 90) {
	        System.out.println("ok100"); 
	    }//&逻辑与使用 
	    if(age > 20 & age < 90) { 
	     	System.out.println("ok200"); 
	    }
	    //区别 
	    int a = 4; 
	    int b = 9; 
	    //对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断 
	    if(a < 1 && ++b < 50) { 
	        System.out.println("ok300"); 
	        }
	    System.out.println("a=" + a + " b=" + b);// 4 9 
	    //对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断 
	    if(a < 1 & ++b < 50) { 
	        System.out.println("ok300"); 
	        }
	    System.out.println("a=" + a + " b=" + b);// 4 10 
	} 
}

3）||和|基本规则和使用区别
基本规则
①短路或|| ：条件 1||条件 2 两个条件中只要有一个成立，结果为 true,否则为 false。
②逻辑或| ：条件 1|条件 2 只要有一个条件成立，结果为 true,否则为 false。
使用区别
①||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高。
② | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低。
③ 开发中，我们基本使用 ||。
4）取反和异或基本规则和使用
①! 非（取反）: !条件 如果条件本身成立，结果为 false，否则为 true。
②a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false。

//!和^案例演示 
public class InverseOperator { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		//! 操作是取反 T->F , F -> T 
		System.out.println(60 > 20); //T 
		System.out.println(!(60 > 20)); //F 
		//a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false 
		
		boolean b = (10 > 1) ^ ( 3 > 5); 
		System.out.println("b=" + b);//T 

		boolean c = (10 > 1) ^ ( 6 > 5); 
		System.out.println("c=" + c);//F 
	} 
}

3.赋值运算符
赋值运算符就是将某个运算后的值，赋给指定的变量。
基本赋值运算符 = int a = 10;
复合赋值运算符 += ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理
a += b; [等价 a = a + b; ]
a -= b; [等价 a = a - b; ]

1）赋值运算符特点
① 运算顺序从右往左 int num = a + b + c;
② 赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值 int num = 20; int num2= 78 * 34 - 10; int num3 = a;
③ 复合赋值运算符等价于下面的效果比如：a+=3;等价于 a=a+3; 其他类推
④ 复合赋值运算符会进行类型转换。 byte b = 2; b+=3; b++;

//演示赋值运算符的使用 
public class AssignOperator {
	//编写一个 main 方法 
	public static void main(String[] args) {
		int n1 = 10; 
		n1 += 4;// n1 = n1 + 4; 
		System.out.println(n1); // 14 
		n1 /= 3;// n1 = n1 / 3;//4 
		System.out.println(n1); // 4 
		//复合赋值运算符会进行类型转换 
		byte b = 3; 
		b += 2; // 等价 b = (byte)(b + 2);强制类型转换 
		b++; // b = (byte)(b+1); 
	} 
}

4.三元运算符
1)基本语法 条件表达式 ? 表达式 1: 表达式 2;
2)运算规则：
①如果条件表达式为 true，运算后的结果是表达式 1；
②如果条件表达式为 false，运算后的结果是表达式 2；
口诀: [一灯大师：一真大师]

//三元运算符使用 
public class TernaryOperator { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		int a = 10; 
		int b = 99; 
		// 解读 
		// 1. a > b 为 false
		// 2. 返回 b--, 先返回 b 的值,然后在 b-1  
		// 3. 返回的结果是 99 
		int result = a > b ? a++ : b--; 
		System.out.println("result=" + result); //99
		System.out.println("a=" + a); //10
		System.out.println("b=" + b); //98
	} 
}

3)使用细节
①表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
② 三元运算符可以转成 if–else 语句

//三元运算符细节 
public class TernaryOperatorDetail { 
	//编写一个 main 方法 
	public static void main(String[] args) { 
		//表达式 1 和表达式 2 要为可以赋给接收变量的类型 
		//(或可以自动转换/或者强制转换) 
		int a = 3; 
		int b = 8; 
		//int c = a > b ? 1.1 : 3.4;//不可以
		int c = a > b ? (int)1.1 : (int)3.4;//可以的 
		double d = a > b ? a : b + 3;//可以的，满足 int -> double 
	} 
}

课堂练习：实现三个数的最大值

public class TernaryOperatorExercise { 
//编写一个 main 方法 
	public static void main(String[] args) {
		//案例：实现三个数的最大值 
		int n1 = 553; 
		int n2 = 33; 
		int n3 = 123; 
		//思路 
		//1. 先得到 n1 和 n2 中最大数 , 保存到 max1 
		//2. 然后再 求出 max1 和 n3 中的最大数，保存到 max2 
		int max1 = n1 > n2 ? n1 : n2; //n1和n2比较
		int max2 = max1 > n3 ? max1 : n3; 
		System.out.println("最大数=" + max2); 
		//使用一条语句实现, 推荐使用上面方法 
		//老师提示: 后面我们可以使用更好方法,比如排序 
		// int max = (n1 > n2 ? n1 : n2) > n3 ? 
		// (n1 > n2 ? n1 : n2) : n3;
		// System.out.println("最大数=" + max);
		
	} 
}

5.运算符优先级
1) 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
2) 只有单目运算符、赋值运算符是从右向左运算的。
3) 一览表, 不要背，使用多了，就熟悉了.
在这里插入图片描述
------文章为自学笔记，学习的课程是B站上的韩顺平30天学JAVA，文章标题的天数是自己学习的天数-----