Chapter04 运算符（Operator）

Chapter04 运算符

目录

• Chapter04 运算符
  • 4.1 算数运算符
  • 4.2 关系运算符
  • 4.3 逻辑运算符
  • 4.4 赋值运算符
  • 4.5 三元运算符
  • 4.6 运算符的优先级
  • 4.7 标识符的命名规则和规范
  • 4.8 Scanner扫描器
  • 4.9 进制
  • 4.10 位运算符
  • 4.11 本章作业

4.1 算数运算符

public class ArithmeticOperator {
    public static void main(String[] args) {
        // / 使用
        System.out.println(10 /4);//从数学角度来看是2.5，在java中是 2，属于int类型
        System.out.println(10.0 / 4);//2.5，此时的10.0属于double类型
        double d = 10 /4;
        System.out.println(d);//2.0 此时的10 / 4 得到的结果为int类型的2，
                              // 但是因为是double类型的，所以结果为2.0

        // % 取模，取余
        //在java中 % 的本质 公式：a % b = a - a / b * b
        //-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;
        System.out.println("k=" + k + "j=" + j);
        int h = j++;//等同 h=j; j=j+1;
        System.out.println("h=" + h + "j=" + j);
    }
}

public class ArithmeticOperatorExercise01 {
    public static void main(String[] args) {
        int i = 1;
        i = i++;//使用了临时变量：（1）temp=i; （2）i=i+1;（3）i=temp;
        System.out.println(i);//1

        int i1 = 1;
        i1 = ++i1;
        System.out.println(i1);//2

        int i3 = 10;
        int i4 = 20;
        int i5 = i3++;
        System.out.println("i5=" + i5);//10
        System.out.println("i4=" + i4);//20
        i5 = --i4;
        System.out.println("i5=" + i5);//19
        System.out.println("i4=" + i4);//19
    }
}


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

        //需求：
        //定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为
        // 5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度 [234.5]
        double hs = 234.5;
        double ss = 5.0 / 9 * (hs - 100);
        System.out.println("华氏温度是：" + hs + "\n" + "摄氏温度是：" + ss);

    }
}

4.2 关系运算符

• 介绍：

  • 关系运算符的结果都是boolean型，也就是要么是true,要么是false
  • 关系表达式经常用在if结构的条件中或循环结构的条件中

• 细节

  • 关系运算符的结果都是Boolean型，也就是要么是true，要么是false
  • 关系运算符组成的表达式，我们称为关系表达式。 a > b
  • 比较运算符 "= =" 不能误写成 "="

4.3 逻辑运算符

• 短路与 && ， 短路或 ||，取反 !
• 逻辑与 &，逻辑或 |，^ 逻辑异或

• 说明逻辑运算规则：

  • a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false
  • a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false
  • a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
  • a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false
  • !a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true
  • a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

• 短路与 && 和 逻辑与 &

public class LogicOperator01 {
    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");
        }

        //区别
        //对于&&短路与而言，如果第一个条件为 false ,后面的条件不再判断
        //对于&逻辑与而言，如果第一个条件为 false ,后面的条件仍然会判断
        int a = 5;
        int b = 6;
        //对于 && 短路与而言，如果第一个判断为false，后面将不会判断
        if(a < 3 && ++b >5){
            System.out.println("测试");
        }
        System.out.println("a=" + a + "b=" + b);//a=5 b=6
        
        //对于 & 逻辑与而言，如果第一个判断为false，后面仍然会判断
        if(a < 3 & ++b >5){
            System.out.println("测试2");
        }
        System.out.println("a=" + a + "b=" + b);/a=5 b=7
    }
}

• 短路或 || 和 逻辑或 |

public class LogicOperator02 {
    public static void main(String[] args) {
        // || 演示
        int age = 50;
        if(age > 20 || age <30){
            System.out.println("ok100");//ok100
        }
        // | 演示
        if(age > 20 | age <90){
            System.out.println("ok200");//ok200
        }
        //区别
        //(1)||短路或：如果第一个条件为 true，
        //则第二个条件不会判断，最终结果为 true，效率高
        //(2)| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率
        int a = 4;
        int b = 9;
        if( a > 1 || ++b > 4) { // 可以换成 | 测试
            System.out.println("ok300");
        }
        System.out.println("a=" + a + "b=" + b);//a=4 b=9

        // | 测试
        if( a > 1 | ++b > 4) {
            System.out.println("ok300");
        }
        System.out.println("a=" + a + "b=" + b);//a=4 b=10
 
    }
}

练习
        boolean x = true;
        boolean y = false;
        short z = 46;
        if((z++ == 46) && (y = true)){
            z++;
        }
        if((x = false) || (++z == 49)){
            z++;
        }
        System.out.println("z=" + z);//50

• 取反 ！ 和 ^

public class InverseOperator {
    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

4.4 赋值运算符

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

特点：

1）运算顺序从右往左 int num = a + b + c;

2）赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值

int num = 20; int num2= 78 * 34 - 10; int num3 = a;

3）复合赋值运算符等价于下面的效果 比如：a+=3;等价于 a=a+3; 其他类推

4） 复合赋值运算符会进行类型转换。 byte b = 2；b+=3； b++；

public class AssignOperator {
    public static void main(String[] args) {
        int a = 4;
        a += 10;//a = a + 10 =14
        System.out.println(a);//14

        //复合赋值运算符会进行类型转换。
        byte b = 3;
        b += 2; // 等价 b = (byte)(b + 2);
        b++; // 等价 b = (byte)(b+1)
    }
}

4.5 三元运算符

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

public class TernaryOperator {
    public static void main(String[] args) {
        int a =10;
        int b =99;
        int result = a > b ? a++ : b--;
        System.out.println(result);//99
    }
}

funtion checkSomething (a ,b){
    a == b ? return an

• 细节：
  • 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换/或者强制转换)
  • 三元运算符可以转成if -- else 语句

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

练习
    public class TernaryOperatorExcise {
    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;
        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);
    }
}

4.6 运算符的优先级

总结：运算符的优先级

• （） {} 等
• 单目运算 ++ --
• 算术运算符
• 位移运算符
• 比较运算符
• 逻辑运算符
• 三元运算符
• 赋值运算符

4.7 标识符的命名规则和规范

• 标识符概念

  • Java 对各种变量、方法和类等命名时使用的字符序列称为标识符
    • 凡是自己可以起名字的地方都叫标识符int num1 = 90;

• 标识符的命名规则(必须遵守)
  1.由26个英文字母大小写,0-9,或$组成

  2.数字不可以开头。int 3ab = 1;//错误
  3.不可以使用关键字和保留字，但能包含关键字和保留字。

  4.Java中严格区分大小写，长度无限制。int totalNum = 10; int n= 90;
  5.标识符不能包含空格。int a b = 90;//错误

• 标识符的规范

  • 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
  • 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰] 比如： TankShotGame
  • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小 驼峰， 简称 驼峰法] 比如： tankShotGame
  • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ 比如 ：定义一个所得税率 TAX_RATE
  • 后面我们学习到 类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.

4.8 Scanner扫描器

import java.util.Scanner;
public class Input {
    public static void main(String[] args) {
        //演示接受用户的输
        // 步骤
        // Scanner 类 表示 简单文本扫描器，在 java.util 包
        // 1. 引入/导入 Scanner 类所在的包
        // 2. 创建 Scanner 对象 , new 创建一个对象,体会

        // myScanner 就是 Scanner 类的对象
        Scanner myScanner = new Scanner(System.in);

        //3. 接收用户输入了， 使用 相关的方法
        System.out.println("请输入名字");
        String name = myScanner.next();

        //当程序执行到 next 方法时，会等待用户输入~~~ String name = myScanner.next(); //接收用户输入字符串
        System.out.println("请输入年龄");
        int age = myScanner.nextInt(); //接收用户输入 int
        System.out.println("请输入薪水");
        double sal = myScanner.nextDouble(); //接收用户输入 double
        System.out.println("人的信息如下:");
        System.out.println("名字=" + name + "年龄=" + age + "薪水=" + sal);
    }
}
结果：
请输入名字
lxd
请输入年龄
21
请输入薪水
0
人的信息如下:
名字=lxd年龄=21薪水=0.0

4.9 进制

public static void maiin(String []args){
int a=1>>2; // 1 向右位移 2 位
int b=-1>>2;//算术右移
int c=1<<2;//算术左移
int d=-1<<2;//
int e=3>>>2;//无符号右移
//a,b,c,d,e 结果是多少 
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
System.out.println("e="+e);
}

~2=? // 按位取反
2&3=?// 2 按位与 3
2|3=? ~-5=?
13&7=?
5|4=?
-3^3=?//^ 按位异

• 原码，反码，补码（重点）

  1. 二进制的最高位是符号位:0表示正数,1表示负数(老韩口诀:0->01->-)
  2. 正数的原码,反码,补码都一样（三码合一)
  3. 负数的反码=它的原码符号位不变，其它位取反(0->1,1->0)
  4. 负数的补码=它的反码+1，负数的反码=负数的补码- 1
  5. 0的反码,补码都是0
  6. java没有无符号数,换言之,java中的数都是有符号的
  7. 在计算机运算的时候,都是以补码的方式来运算的.
  8. 当我们看运算结果的时候,要看他的原码(重点)

4.10 位运算符

• java 中有 7 个位运算(&、|、 ^ 、~、>>、<<和 >>>）
• 按位与&：两位全为1，结果为1，否则为0
  按位或|：两位有一个为1，结果为1，否则为0
  按位异或^:两位一个为0，一个为1，结果为1，否则为0
  按位取反~:0->1 ,1->0

public class BitOperator02 {
    public static void main(String[] args) {
        int a = 1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
        int c = 1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4
        System.out.println(a);//0
        System.out.println(c);//4
        System.out.println(4 << 3);//4*2*2*2=32
        System.out.println(15 >> 2);//15/2/2=3
    }
}

4.11 本章作业

1.计算下列表达式的结果
10/3 = 3 ; 10/5 = 2; 10%2 =0 ;
-10.5%3= ?;//a%b当a是小数时，公式=a- (int)a / b *b
-10.5%3 =-10.5 - (-10)/3 *3= -10.5 +9=-1.5注意:有小数运算，得到结果是近似值

2.试说出下面代码的结果
int i=66;
System.out.println(++i+i);/执行i=i+ 1=>i= 67 =>134

3.在Java中，以下赋值语句正确的是(C D).
A) int num1=(int)"18";//错误应该Integer.parselnt("18");
B) int num2=18.0;/错误double -> int
C) double num3=3d;//ok
D) double num4=8;//ok int -> double
E) int i=48; char ch =i+1;//错误int ->char
F) byte b = 19; short s = b+2;1/错误int ->short

4.试写出将String转换成double类型的语句,以及将char类型转换成String的语句,举例说明即可，写简单代码
String str = "18.8";//注意字符串要可以被转成 double
double d1 = Double.parseDouble(str);
char c1 ='韩";
String str2 =c1 +"";