Java基础_运算符

第四章 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符：

就是对常量或者变量进行操作的符号。

比如： + - * /

表达式：

用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。

比如：a + b 这个整体就是表达式。

而其中+是算术运算符的一种，所以这个表达式也称之为 算术表达式

4.1 运算符的种类

  1. 算数运算符

  2. 关系运算符 [ 比较运算符 ]

  3. 逻辑运算符

  4. 赋值运算符

  5. 三元运算符

  6. 位运算符 [ 学习二进制的基础 ]

4.1.1 算数运算符

在 Java 程序中，算术运算符是对数值类型的变量进行运算的，经常会使用到。

运算符 运算 实现 结果
+ 正号 +9 9
- 负号 z=12; -z -12
+ 加 6 + 9 15
- 减 9 - 6 3
* 乘 6 * 9 54
/ 除 54 / 3 18
% 取余 9 / 6 3
++
++
 自增（前）：先运算后取值
自增（后）：先取值后运算
 x = 9; y = ++9;
x = 9; y = 9++;
 x = 9; y = 10;
x = 10; y = 9;
--
--
 自减（前）：先运算后取值
自减（后）：先取值后运算
 x = 9; y = ++9;
x = 9; y = 9++;
 x = 9; y = 8;
x = 8; y = 9;
= 字符串拼接/连接 "Xiao"+"Yuan" "XiaoYuan"

代码实现:

需求：使用所有运算符进行练习。

  1. 练习基本运算符的使用

  2. 重点了解： / 、% 、++ 、--

  3. % 取模要注意 数据的类型

  4. ++ 自增 可以作为独立的语句使用，也可以作为表达式使用

作为独立语句使用时： ++i 和 i++ 都表示 i = i + 1;

作为表达式使用时：

前++ ++i： ++i 先自增 后赋值

后++ i++： i++ 先赋值 后自增

【Arithmetic（算数）Operator（运算符）】

//算数运算符运算符进行练习
public class ArithmeticOperator{
    //编写一个main方法
    public static void main(String[] args){

        //此次练习为了便于了解，一律使用 int double String 类型的变量
        int num1 = 10; // int ---> 10
        int num2 = 90; // int ---> 90
        double num3 = 3.33; // double ---> 3.33
        double num4 = 4.44; // double ---> 4.44
        String num5 = "Xiao"; // String ---> Xiao
        String num6 = "Yuan"; // String ---> Yuan

        int test2 = + 11; // int ---> 11
        int test3 = - 22; // int ---> -22

        //正号负号
        System.out.println(test2); // 11    
        System.out.println(test3); // -22

        //加法运算 +
        double sum1 = num1 + num2; // double ---> int 10 + int 90;
        System.out.println(sum1); // double ---> 100.0

        //减法运算 -
        double sum2 = num2 - num1; // double ---> int 90 - int 10;
        System.out.println(sum1); // double ---> 80.0

        //乘法运算 *
        double sum3 = num1 * num2; // double ---> int 10 * int 90;
        System.out.println(sum3); // double ---> 900.0

        //除法运算 /
        double sum4 = num2 / num1; // double ---> int 90 / int 10;
        System.out.println(sum4); // double ---> 9.0

        //特例: 除法运算 小数
        System.out.println( 10 / 4 ); // int10 / int4 = int 2  ---》 2.5 整数丢失精度
        System.out.println( 10.0 / 4 ); // double10 / int 4 = double 2.5 ----> 自动转为精度高的计算
        double test1 = 10 / 4; // int10 / int4 = int2后 ----> 自动提升为精度高的变量
        System.out.println(test1); // double ---> 2.0

        //拼接运算 +
        System.out.println(num5 + num6); // String ---> XiaoYuan

        //分割线
        System.out.println("-----------------------------------------------------------");

        //取模运算 %  -->取余数
        // x % y = x - [(x / y) * y ]  ---> 计算全部按照其类型来计算

        // 11 % 10 = 11 - [(11/10)*10] = 11 - 1*10 = 11- 10 =1
        System.out.println( test2 % num1 ); // int11 / int10 ===> % ===> 1

        // -22 % 10 = -22 - [(-22/10)*10] = -22 - [-2*10] = -22 + 20 =-2
        System.out.println( test3 % num1 ); // int-22 / int10 ===> % ===> -2

        // 90 % -22 = 90 - [(90/-22)*-22] = 90 - [-4*-22] = 90- 88 =2
        System.out.println( num2 % test3 ); // int90 / int-22 ===> % ===> 2

        // -69 % -66 = -69 - [(-69/-66)*-66] = -69 - [1*-66] = -69 + 66 =-3
        System.out.println( -69 % -66 ); // int-69 / int-66 ===> % ===> -3

        //分割线
        System.out.println("-----------------------------------------------------------");

        // 自增运算 ++ 
        int i1 = 1; //定义一个 int 类型的变量 i1

        //可以作为独立语句使用，作为独立语句使用时：
        //前++ 和 后++ 都可以表示为 i = i + 1;
        i1++; // i1 = i1 + 1;
        System.out.println("i1自增结束，结果为:" + i1); //int ---> 2
        ++i1; // i1 = i1 + 1;
        System.out.println("i1自增结束，结果为:" + i1); //int ---> 3

        //作为表达式使用:
        int i2 = 2; // int ---> 2
        int i3 = 3; // int ---> 3

        //前++ ：++i 先自增后赋值
        int j1 = ++i2; // 先自增 i2 = i2(=2) + 1; 后赋值 j1 = i2;
        System.out.println("j1，结果为:" + j1); //int ---> 3
        System.out.println("i2自增结束，结果为:" + i2); //int ---> 3

        //后++ ：i++ 先赋值后自增
        int j2 = i3++; // 先赋值 j2 = i3(=3); 后自增 i3 = i3(=3) + 1; 
        System.out.println("j2，结果为:" + j2); //int ---> 3
        System.out.println("i3自增结束，结果为:" + i3); //int ---> 4

        //分割线
        System.out.println("-----------------------------------------------------------");

        // 自增运算 --
        int i11 = 11; //定义一个 int 类型的变量 i11

        //可以作为独立语句使用，作为独立语句使用时：
        //前-- 和 后-- 都可以表示为 i = i - 1;
        i11--; // i11 = i11 - 1;
        System.out.println("i1自减结束，结果为:" + i11); //int ---> 10
        --i11; // i11 = i11 - 1;
        System.out.println("i1自减结束，结果为:" + i11); //int ---> 9

        //作为表达式使用:
        int i12 = 12; // int ---> 12
        int i13 = 13; // int ---> 13

        //前-- ：--i 先自减后赋值
        int j12 = --i12; // 先自减 i12 = i12(=12) - 1; 后赋值 j12 = i12;
        System.out.println("j12，结果为:" + j12); //int ---> 11
        System.out.println("i12自减结束，结果为:" + i12); //int ---> 11

        //后-- ：i-- 先赋值后自减
        int j13 = i13--; // 先赋值 j13 = i3(=3); 后自减 i13 = i13(=13) - 1; 
        System.out.println("j13，结果为:" + j13); //int ---> 13
        System.out.println("i13自减结束，结果为:" + i13); //int ---> 12
    }
}

细节说明：

  1. 对于 出号'/' , 整数除法运算和小数除法运算是有区别的：整数之间做除法时，只保留整数部分（默认int类型，精度丢失）。

  2. 对于 取模'%'，其底层运算为：x % y = x - [(x / y) * y],这就是取模的运算本质。

  3. 当 自增 作为 独立语句使用时， ++i 等价于 i++ 等价于 i + 1

  4. 当自增作为一个表达式使用时，++i 先自增 再赋值

  5. 当自增作为一个表达式使用时，i++ 先赋值 再自增

面试题:

[ArithmeticOperatorInterview.java]

1、面试题一 :

题目：

int i =1 ;

i = i++;

System.out.println(i);

求 控制台打印的结果？及其如何实现

//面试题练习
public class ArithmeticOperatorInterview{
    //编写一个main方法
    public static void main(String[] args){
        /*
         题目： 
         int i = 1;
         i = i++; 
         System.out.println(i);
         求 控制台打印的结果？及其如何实现
        */
        int i = 1; // int 类型 ---> 1
        // 规则使用临时变量 1、temp = i ; 2、i = i++; 3、i = temp;
        /*
            先赋值，后自增
            自己理解：i = 1 --> i ; i++ --> i = i + 1;  i = 1
        */
        i = i++; // int 类型 ---> 1
        System.out.println(i); // 1

    }
}
2、面试题二 :

题目：

int i =1 ;

i = ++1;

System.out.println(i);

求 控制台打印的结果？及其如何实现

//面试题练习
public class ArithmeticOperatorInterview{
    //编写一个main方法
    public static void main(String[] args){

        /*
         题目： 
         int i = 1;
         i = ++i; 
         System.out.println(i);
         求 控制台打印的结果？及其如何实现
        */
        int i = 1; // int 类型 ---> 1
        // 规则使用临时变量 1、i = i++; 2、temp = i; 3、i = temp;
        /*
            先赋值，后自增
            自己理解：i++ --> i = i + 1 --> 2; i = i++ = 2 --> i = i = 2
        */
        i = ++i; // int 类型 ---> 2
        System.out.println(i); // 2

    }
}

运算符练习：

[ArithmeticOperatorExercise01.java]

int num1 = 10;

int num2 = 20'

int sum3 = num1++;

System.out.println("sum3 自增后的结果为:" + sum3);

System.out.println("num2 结果为:" + num2);

sum3 = --num2;

System.out.println("sum3 自减后的结果为:" + sum3);

System.out.println("num2 结果为:" + num2);

//1、自增，自减 练习实现
public class ArithmeticOperatorExercise01{
    //编写一个main方法
    public static void main(String[] args){

        // int 类型 num1 ---> 10
        int num1 = 10;

        // int 类型 num2 ---> 20
        int num2 = 20;

        // int 类型 sum3 ---> 10
        int sum3 = num1++;

        System.out.println("sum3 自增后的结果为:" + sum3); // int ---> 10

        System.out.println("num2 结果为:" + num2); // int ---> 20

        // int 类型 sum3 ---> 19
        sum3 = --num2;

        System.out.println("sum3 自减后的结果为:" + sum3); // int ---> 19

        System.out.println("num2 结果为:" + num2); // int ---> 19

    }
}

[ArithmeticOperatorExercise02.java]

  1. 假如还有 59 天放假，问：合 xx 个星期零 xx 天

  2. 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。[234.5]

//2、生活应用题
public class ArithmeticOperatorExercise02{
    //编写一个main方法
    public static void main(String[] args){

        //1、假如还有 59 天放假，问：合 xx 个星期零 xx 天

        //需求分析:
        //(1) 使用int变量 nearVacation 保存距离放假总天数。
        //(2) 定义 一个星期 week 是 7 天 星期数 nearWeek : nearVacation / week 
        //    距离放假的不足星期的天数：nearDay： nearVacation % week 

        // 定义 距离放假总天数。
        int nearVacation = 59;
        // 定义 每一周 时长为七天
        int week = 7;

        //计算 距离放假的星期数
        int nearWeek = nearVacation / week;
        //计算 距离放假的不足星期的天数
        int nearDay = nearVacation % week;

        //在控制台打印 距离需求1
        System.out.println("距离放假还有"+ nearVacation + "天，合计:" 
        + nearWeek +"个星期零"+ nearDay + "天!");

        //2、定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：
        //     5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。[234.5] 

        //声明 一个 double类型的变量 fahrenheit 华氏温度 
        double fahrenheit;
        //声明 一个 double类型的变量 centigrade 摄氏温度
        double centigrade;

        fahrenheit = 234.5; //把 待求的温度 234.5 赋给 华氏温度

        centigrade = 5.0 / 9.0 * (fahrenheit - 100); //计算出对应的摄氏度

        //在控制台打印 距离需求2
        System.out.println("华氏温度:"+ fahrenheit + "\n对应的摄氏温度为："+ centigrade);
    }
}

4.1.2 关系运算符

  1. 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false

  2. 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

  3. 关系运算符也叫比较运算符

运算符 运算 实现 结果
== 相等于 6 == 9 false
!= 不等于 6 != 9 true
< 小于 6 < 9 true
> 大于 6 > 9 false
<= 小于等于 6 <= 9 true
>= 大于等于 6 >= 9 false
instanceof 检查是不是类的对象 "Xiao" instanceof String true

代码实现:

关系运算符的使用 [RelationalOperator.java]

//关系运算符进行练习
public class RelationOperator{
    //编写一个main方法
    public static void main(String[] args){

        //声明一个 变量名为 relationOne 的 int类型变量
        int relationOne = 66;
        //声明一个 变量名为 relationTwo 的 int类型变量
        int relationTwo = 99;

        //关系运算符的使用： == != < <= > >= instanceof
        System.out.println(relationOne == relationTwo); // Boolean ---> false
        System.out.println(relationOne != relationTwo); // Boolean ---> true
        System.out.println(relationOne < relationTwo); // Boolean ---> true
        System.out.println(relationOne > relationTwo); // Boolean ---> false
        System.out.println(relationOne <= relationTwo); // Boolean ---> true
        System.out.println(relationOne >= relationTwo); // Boolean ---> false
        System.out.println("Yuan" instanceof String); // Boolean ---> true
        // System.out.println(int instanceof RelationOperator); // Boolean ---> true

        boolean relation = relationOne!=relationTwo;
        System.out.println("赋给relation的Boolean类型是："+ relation);
    }
}

细节说明：

  1. 关系运算符的结果都是 boolean类型，是 true 或者 false。

  2. 关系运算符组成的表达式，被称为：关系表达式 a == b;

  3. 比较运算符 '==' 不能写为 '='； 一个是相等 一个是赋值。

4.1.3 逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。

  1. 短路与 && ， 短路或 ||，取反 !
运算符 运算 作用 实现 结果
&& 与 左右两边的布尔表达式都为真，结果才为真 true&&false false
|| 或 两边布尔表达式只要有一个为真，结果为真 true&&false true
! 非 布尔表达式为真，结果为假
布尔表达式为假，结果为假		 !(true) false
^（作为逻辑运算符时） 异或 两边布尔表达式都为真，结果为假
只有一边的表达式为真，结果为真		 true^true false
  1. 逻辑与 &，逻辑或 |，^ 逻辑异或
运算符 运算 作用 实现 结果
& 与 左右两边的布尔表达式都为真，结果才为真 true&&false false
| 或 两边布尔表达式只要有一个为真，结果为真 true&&false true
! 非 布尔表达式为真，结果为假 !true false
^（作为逻辑运算符时） 异或 两边布尔表达式都为真，结果为假
只有一边的表达式为真，结果为真		 true^true false
  1. 说明逻辑运算规则：

  • a&b : & 叫逻辑与：规则：当 a 和 b 同时为 true ,则结果为 true, 否则为 false

    true & true --> true true & false --> false 左边不为真，输出false

  • a&&b : && 叫短路与：规则：当 a 和 b 同时为 true ,则结果为 true,否则为 false

    true & true --> true true & false --> false全部不为真，输出false

  • a|b : | 叫逻辑或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false

    true & true --> false true & false --> true

  • a||b : || 叫短路或，规则：当 a 和 b ，有一个为 true ,则结果为 true,否则为 false

  • !a : 叫取反，或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是，结果为 true

  • a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

逻辑与 & 短路与 &&

基本规则:
名称 语法 特点
短路与&& 条件 1 && 条件 2 两个条件都为 true，结果为 true,否则 false
逻辑与& 条件 1 & 条件 2 两个条件都为 true，结果为 true,否则 false
使用区别:

  1. & 逻辑与：不管第一个条件是否为 false，第二个条件都会判断。

  2. && 短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false。

  3. 在正常项目开发中， 我们会优选选择 短路与&&，开发效率相对较高。

代码实现：
 // 逻辑运算符的使用案例
public class LogicOperator01{
    //编写一个main方法
    public static void main(String[] args){

        //声明一个 boyAge 的int变量
        int boyAge = 21; // int ---> 21
        //声明一个 girlAge 的int变量
        int girlAge = 22; // int ---> 22

        // 逻辑运算符 --  & 逻辑与 和 && 短路与
        // 1、if语句 逻辑与&
        if( boyAge < 22 & girlAge > 20 ){
            //在控制台打印 if语句无误
            System.out.println("if语句成立，输出逻辑与&相关信息--true！");
        } // 语句为 true

        // 2、if语句 逻辑与&&
        if( boyAge < 22 && girlAge > 20 ){
            //在控制台打印 if语句无误
            System.out.println("if语句成立，输出逻辑与&&相关信息--true！");
        } // 语句为 true

        // 3、if语句 逻辑与&  错误判断
        if( girlAge < 16 & boyAge > 18 ){
            //在控制台打印 if语句无误
            System.out.println("if语句成立，输出逻辑与&相关信息--false！");
        } // 语句为 false

        // 4、if语句 逻辑与&&  错误判断
        if( boyAge < 22 && girlAge > 20 ){
            //在控制台打印 if语句无误
            System.out.println("if语句成立，输出逻辑与&&相关信息--false！");
        } // 语句为 false

        //分隔符
        System.out.println("---------------------------------");

        // 逻辑 & 不管第一个条件是否为 false，第二个条件都会判断。
        if( boyAge < 20 & ++girlAge > 20 ){
            //在控制台打印 --- 条件全部执行
            System.out.println("if语句条件全部执行，输出逻辑与&相关信息--false！");
        } // 语句为 false
        System.out.println("boyAge的数值为："+ boyAge + "。girlAge的数值为:" + girlAge);

        // && 短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false。
        if( --girlAge < 20 && ++boyAge > 20 ){
            //在控制台打印 --- 条件全部执行
            System.out.println("if语句条件全部执行，输出逻辑与&&相关信息--false！");
        } // 语句为 false
        System.out.println("boyAge的数值为："+ boyAge + "。girlAge的数值为:" + girlAge);

        //分隔符
        System.out.println("---------------------------------");

        //测试--前面为true，后面是否执行 短路与&&
        if( --boyAge < 25 && --girlAge > 25 )
        {
            //在控制台打印 --- 前半句为true，后半句为 false  --- 》 false
            System.out.println("前半句为true，后半句为 false  --- 》 false");
        }
        System.out.println("boyAge的数值为："+ boyAge + "。girlAge的数值为:" + girlAge);
    }
}

逻辑或 | , 短路或 ||

基本规则：
名称 语法 特点
逻辑或 | 条件 1|条件 2 只要有一个条件成立，结果为 true,否则为 false
短路或 | 条件 1|
使用区别：

  1. | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断。

  2. ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true。

  3. 在正常项目开发中， 我们会优选选择 短路或 ||，开发效率相对较高。

代码实现：
// 逻辑运算符的使用案例
public class LogicOperator02{
    //编写一个main方法
    public static void main(String[] args){

        //声明一个 appleNum 的int变量
        int appleNum = 66; // int ---> 21
        //声明一个 eggNum 的int变量
        int eggNum = 99; // int ---> 22

        // 逻辑运算符 --  | 逻辑或 和 || 短路或
        // 逻辑或 | 只要有一个条件成立，结果为 true,否则为 false
        if( appleNum < 100 | eggNum > 100){
            System.out.println("1条件成立，输出结果为：True");
        }

        // 逻辑或 || 只要有一个条件成立，结果为 true,否则为false
        if( appleNum < 100 || eggNum > 100){
            System.out.println("2条件成立，输出结果为：True");
        } else {
        System.out.println("条件不成立，输出结果为：False");
        }

        // | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断。
        if( ++appleNum > 110 | ++eggNum > 110){
            System.out.println("3条件成立，输出结果为：True");
        }
        System.out.println("ApllleNum的数量为："+ appleNum + ",EggNum的数量为："+ eggNum);

        // ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true。
        if( --appleNum > 110 || --eggNum > 110){
            System.out.println("4条件成立，输出结果为：True");
        }
        System.out.println("ApllleNum的数量为："+ appleNum + ",EggNum的数量为："+ eggNum);
    }
}

逻辑非 ! , 逻辑异或 ^

基本规则：
名称 语法 特点
逻辑非 ! （取反） !条件 如果条件本身成立，结果为 false，否则为 true
逻辑异或 ^ 条件 1 ^ 条件 2 当 条件1 和 条件2 不同时，
则结果为 true, 否则为 false
代码实现：
// 逻辑运算符的使用案例
public class LogicOperator03{
    //编写一个main方法
    public static void main(String[] args){

        int num1 = 66;
        int num2 = 99;

        //！是 逻辑非 取值反  ===》 ！true = false 
        System.out.println(num1 < num2); // boolean ---> true
        System.out.println(!(num1 < num2)); // boolean ---> false
        System.out.println(num1 > num2); // boolean ---> false
        System.out.println((num1 > num2) == !(num1 < num2)); // boolean ---> true

        //分隔符
        System.out.println("---------------------------------");

        // ^ 是 逻辑异或 ,当 条件1 和 条件2 不同时，结果为true，否则为 false
        boolean sum3 = (num1 > 1) ^ (num2 > 2);
        System.out.println("sum3的结果为："+ sum3); // boolean ---> false
        System.out.println((num1 < num2) ^ (num1 > num2)); // boolean ---> true
        System.out.println((num1 < 100) ^ (num2 < 100)); // boolean ---> false

    }
}

逻辑运算符 代码练习：

练习一、

//逻辑运算符 代码练习：
public class LoginOperatorExercise01{
    //编写一个main方法
    public static void main(String[] args){

        //定义两个 int 变量
        int num1 = 9;
        int num2 = 9;

        //第一题 --> 10 10
        if( num1++ == 10 & ++num2 == 10 ){
            num1 = 99;
        }
        System.out.println("1、num1的值为："+ num1 + "，num2的值为：" + num2);

        //定义两个 int 变量
        int num3 = 9;
        int num4 = 9;

        //第二题 --> 10 9
        if( num3++ == 10 && ++num4 == 10 ){
            num3 = 99;
        }
        System.out.println("1、num3的值为："+ num3 + "，num4的值为：" + num4);

        //定义两个 int 变量
        int num5 = 9;
        int num6 = 9;

        //第三题 -->  99 10
        if( num5++ == 9 | ++num6 == 9 ){
            num5 = 99;
        }
        System.out.println("1、num5的值为："+ num5 + "，num6的值为：" + num6);

        //定义两个 int 变量
        int num7 = 9;
        int num8 = 9;

        //第四题 --> 99 9
        if( num7++ == 9 || ++num8 == 9){
            num7 = 99;
        }
        System.out.println("1、num7的值为："+ num7 + "，num8的值为：" + num8);

    }
}

练习二、

//逻辑运算符 代码练习：
public class LoginOperatorExercise02{
    //编写一个main方法
    public static void main(String[] args){

        //定义两个 boolean 类型的变量
        boolean x = true;
        boolean y = false;
        //定义一个 short 类型的变量
        short z = 96;

        //首先判断 ： true && y = true ==> true  z = 97; y = true;
        if(( z++ == 96 ) && ( y = true)){
            z++; // z = 98
            // if判断：false || true ==> true x = false; z = 99;
            if(( x = false ) || ( ++z == 99 )){
                z++; // z= 100
            }
        }
        System.out.println("输出z的最终值为:"+ z );

    }
}

4.1.4 赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

赋值运算符的分类

  1. 基本赋值运算符 [ = ]

int number = 99 double number = 99.99 = 等号赋值

  1. 复合赋值运算符

[ +=、-=、*=、/=、%= 以及其他 = ]

a += b; ======> a = a + b;

a -= b; ======> a = a - b;

a *= b; ======> a = a * b;

a /= b; ======> a = a / b;

a %= b; ======> a = a % b;

  1. 复合赋值运算符基本使用 [ AssignOperator.java ]

  2. 基本赋值运算符 [ int num1 = 10 ]

  3. 复合赋值运算符 [ num1 += 10 ]

//赋值运算符的基本使用
public class AssignOperator{
    //编写一个main方法
    public static void main(String[] args){
        //基本赋值运算符的使用
        int num1 = 10; // 10
        num1 = 33; //将常量33 赋给变量num1

        //复合赋值运算符的使用
        int num2 = 66; // 66
        num2 += num1; // num2 = num2 + num1; 66 + 33 = 99;
        System.out.println("复合运算后的值为:"+ num2);

    }
}

赋值运算符的特点

  1. 运算顺序：从右往左 int number = num1 + num2 + num3; 先运算再赋给number

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

int number = 33; int number = 33 * 3 * 4 /4; int number = number;

  1. 复合赋值运算符的本质是 变量 复合运算符 常量 ===> 变量 = 变量 运算符 常量

  2. 复合赋值运算符会进行类型转换

byte be1 = 9; be1 += 1 ===> be1 = be1 + 1; be1++; ===> be1 = be1 + 1;

其中后两个涉及到了强制转换，因为 变量+常量 自动提升为 int类型

代码实现:
//赋值运算符的基本使用
public class AssignOperator{
    //编写一个main方法
    public static void main(String[] args){
        //基本赋值运算符的使用
        int num1 = 10; // 10
        num1 = 33; //将常量33 赋给变量num1

        //复合赋值运算符的使用
        int num2 = 66; // 66
        num2 += num1; // num2 = num2 + num1; 66 + 33 = 99;
        System.out.println("复合运算后的值为:"+ num2);

        //运算顺序：从右往左
        //赋值运算符的 左边 只能是变量，右边 可以是变量、表达式、常量值
        int sum = num1 + num2 * 2; // 将 运算后的值赋给 变量sum
        System.out.println("sum的值为:"+ sum); // 231

        //复合赋值运算符会进行类型转换
        byte be1 = 9; // 9
        byte be2 = 6; // 6
        System.out.println("be1的值为:"+ be1);
        System.out.println("be2的值为:"+ be2);

        be1 += 1; // be1 = (byte)(be1 + 1);
        // be2 = be2 + 2; // 从int转换到byte可能会有损失
        System.out.println("+=be1的值为:"+ be1);
        //System.out.println("be2的值为:"+ be2); 

        be1++; // be1 = (byte)(be1 + 1);
        System.out.println("be1++的值为:"+ be1);


    }
}

4.1.5 三元运算符

基本语法: 条件表达式 ? 表达式 1: 表达式 2;

运算规则：

  1. 对条件表达式进行运算判断，为 true 或 false;

  2. 如果条件表达式为 true，运算后的结果是表达式 1；

  3. 如果条件表达式为 false，运算后的结果是表达式 2；

基本使用：

【TernartOperator.java】

//三元运算符的基本使用
public class TernaryOperator{
    //编写一个main方法
    public static void main(String[] args){
        //定义两个int类型的变量 方便比较
        int small = 33; // 33
        int big = 66; // 66

        /*
            1. small > big 为false;
            2. 然后执行条件2 big++;
            3. 后++ 先赋值后增加 故 result1 = 66;
            4. 返回的结果为: 66;

         */
        int result1 = small > big ? small++ : big++;
        int result2 = small < big ? small-- : big--;

        System.out.println("条件表达式判断为 false 时候的值为" + result1); //66
        System.out.println("条件表达式判断为 true 时候的值为" + result2); //33

    }
}

细节说明:

  1. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)

  2. 三元运算符 可以转成 if--else 语句

//三元运算符
int result = big > small > big++ : small--;
//if -- else 语句
if(big > small){
    result = big ++;
} else {
    result = small --;
}
细节代码实现：
//三元运算符的使用细节
public class TernaryOperatorDetail{
    //编写一个main方法
    public static void main(String[] args){
        //表达式 1 和表达式 2 要为可以赋给接收变量的类型
        //(也可以自动转换和强制转换)
        int num1 = 33;
        int num2 = 66;
        double num3 = 99.99;
        double num4 = 3.14;

        //直接赋给 sum int类型 
        int sum1 = num1 > num2 ? 99 : 88;

        // int sum = num1 > num2 ? num3 : num4; 
        //从double转换到int可能会有损失 故需要强制类型转换
        int sum = num1 > num2 ? (int)num3 : (int)num4;

        // 从 int ==》 double 可以完成自动转换
        double sum0 = num3 > num4 ? num1 : num2 + 1;

        System.out.println("相同 类型的值为" + sum1); // 88
        System.out.println("int 类型的值为" + sum); // 3
        System.out.println("double 类型的值为" + sum0); // 33.0

    }
}

代码实现：

实现三个数取最大值 【 TernaryOperatorDetail.java 】

//三元运算符的代码练习
public class TernaryOperatorExercise{
    //编写一个main方法
    public static void main(String[] args){

        //实现三个数取最大值

        int num1 = 33;
        int num2 = 66;
        int num3 = 99;

        //通过三元运算符实现 比较
        //先通过两个值的比较 num1 和 num2 得到最大值 保存到 max1 里
        //然后比较 max1 和 第三个值 得到最大值 最后 得到最大值 max2

        int max1 = num1 > num2 ?  num1 : num2; //比较 num1 和 num2
        int max2 = max1 > num3 ? max1 : num3; //比较 max1 和 num3

        System.out.println("三个数中的最大值为:"+ max2); // 最大值为:99

        //通过三元运算符实现 一条语句
        //程序优化上 不建议使用这条语句 因为 程序重复执行
        int max = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;
    }
}

4.1.6 位运算符

位运算符有七个，分为两类：
  • 逻辑位运算符：位与（&）、位或（|）、位异或（^）、非位（~）
  • 移位运算符：左移（<<）、右移（>>）、无符号右移（>>>）
位运算符表-逻辑位运算符
位运算符 名称 作用 举例 结果
& 按位与 两个位都为1，结果才为1 2&4 0
I 按位或 两个位有一个为1，结果为1 2I4 6
~ 按位求反 位为0，结果为1
位为0，结果为1		 ~2 -3
^（用作位运算符时） 按位异或 两个位都为0，结果为1 2^4 6
逻辑位运算符的基本使用：
//位运算 的基本使用
public class BitOperator{ 
    //编写一个main方法
    public static void main(String[] args){

        // 按位与 & 的基本使用
        // 数值自动判定为 int类型
        /* 1.先得到2的原码 --> 00000000 00000000 00000000 00000010
         * 然后得到2的补码 --> 00000000 00000000 00000000 00000010
         * 2.先得到3的原码 --> 00000000 00000000 00000000 00000011
         * 然后得到3的补码 --> 00000000 00000000 00000000 00000011
         * 4.执行 按位与 判断
         *    2的补码 00000000 00000000 00000000 00000010
         *    3的补码 00000000 00000000 00000000 00000011
         *  ----------------------------------------------------------------
         *    按位与后的补码 00000000 00000000 00000000 00000010
         *  运算后的原码 00000000 00000000 00000000 00000010
         *  故结果为: 2 
         */
        System.out.println(2&3); // int --> 2

        // 按位取反 ~ 的基本使用
        // 数值自动判定为 int类型
        /* 1.先得到2的原码 --> 10000000 00000000 00000000 00000010
         * 然后的到2的反码 --> 11111111 11111111 11111111 11111101
         * 然后得到2的补码 --> 11111111 11111111 11111111 11111110
         * 2.执行运算 按位取反
         * 取反后的补码 结果 --> 00000000 00000000 00000000 00000001
         * 取反后的原码为 --> 00000000 00000000 00000000 00000001
         * 3.先得到3的原码 --> 00000000 00000000 00000000 00000011
         * 然后得到3的补码 --> 00000000 00000000 00000000 00000011
         * 4.执行运算 按位取反
         *    取反后的补码 11111111 11111111 11111111 11111011
         *    取反后的原码 100000000 00000000 00000000 00000100
         *  ----------------------------------------------------------------
         * ~-2 ---> 1   ~3 ---> -4
         */
        System.out.println(~-2); // 1
        System.out.println(~3); //-4

        // 按位或的基本使用
        // 数值自动判定为 int类型
        /* 1.先得到2的原码 --> 00000000 00000000 00000000 00000010
         * 然后得到2的补码 --> 00000000 00000000 00000000 00000010
         * 2.先得到3的原码 --> 00000000 00000000 00000000 00000011
         * 然后得到3的补码 --> 00000000 00000000 00000000 00000011
         * 4.执行运算 按位或 
         *    2的补码 00000000 00000000 00000000 00000010
         *    3的补码 00000000 00000000 00000000 00000011
         *  ----------------------------------------------------------------
         *    按位或后的补码 00000000 00000000 00000000 00000011
         *  运算后的原码 00000000 00000000 00000000 00000011
         *  故结果为: 3
         */
        System.out.println(2|3);

        // 按位异或的基本使用
        // 数值自动判定为 int类型
        /* 1.先得到2的原码 --> 00000000 00000000 00000000 00000010
         * 然后得到2的补码 --> 00000000 00000000 00000000 00000010
         * 2.先得到3的原码 --> 00000000 00000000 00000000 00000011
         * 然后得到3的补码 --> 00000000 00000000 00000000 00000011
         * 4.执行运算 按位或 
         *    2的补码 00000000 00000000 00000000 00000010
         *    3的补码 00000000 00000000 00000000 00000011
         *  ----------------------------------------------------------------
         *    按位或后的补码 00000000 00000000 00000000 0000001
         *  运算后的原码 00000000 00000000 00000000 00000001
         *  故结果为: 1
         */
        System.out.println(2^3);
    }
}
位运算符表-移位运算符
位运算符 名称 作用 举例 结果
<< 算数左移 符号位不变,低位补 0
其实就是 左边的值 * 2^右边的值		 2 << 2 8
>> 算数右移 低位溢出,符号位不变,并用符号位补溢出的高位
其实就是 左边的值 / 2^右边的值		 4 >> 2 1
>>> 逻辑右移
无符号右移		 低位溢出，高位补 0
符号位也参与移动，空位补0，被移除的舍去		 1 >>> 3 0
逻辑位运算符的基本使用：
//位运算 移位运算符 的基本使用
public class BitOperator01{ 
    //编写一个main方法
    public static void main(String[] args){

        /*
         * 1. int 22的原码为: 00000000 00000000 00000000 00010110;
         * 2. 22 的 补码为: 00000000 00000000 00000000 00010110;
         * 3. 符号位不变 ， 向左移两个位数 ，低位补0
         * 4. << 后的补码为：00000000 00000000 00000000 01011000;
         *      << 后的原码为：00000000 00000000 00000000 01011000;
         * 5. 本质为：22 * 2 * 2 ==> 22 * 2^2 = 88
         */
        int num1 = 22 << 2 ;
        /*
         * 1. int 88的原码为: 00000000 00000000 00000000 01011000;
         * 2. 88 的 补码为: 00000000 00000000 00000000 01011000;
         * 3. 符号位不变 ， 向右移两个位数 ，符号位补溢出位置
         * 4. >> 后的补码为：00000000 00000000 00000000 00010110;
         *      >> 后的原码为：00000000 00000000 00000000 00010110;
         * 5. 本质为：88 / 2 / 2 ==> 88 / 2^2 = 22
         */
        int num2 = 88 >> 2 ;
        /*
         * 1. int 88的原码为: 00000000 00000000 00000000 01011000;
         * 2. 88 的 补码为: 00000000 00000000 00000000 01011000;
         * 3. 符号位也参与移动，空位补0，被移除的舍去
         * 4. >>> 后的补码为：00000000 00000000 00000000 00010110;
         *      >>> 后的原码为：00000000 00000000 00000000 00010110;
         * 5. 本质为：88 / 2 / 2 ==> 88 / 2^2 = 22
         */
        int num3 = 88 >>> 2;

        System.out.println(num1); // 88
        System.out.println(num2); // 22
        System.out.println(num3); // 22

    }
}
位运算符表的基本使用:
//位运算的思考猜测
public class  BitOperator02{ 
    //编写一个main方法
    public static void main(String[] args){

        int n1 = 1 >> 2; //算术右移

        int n2 = -1 >> 2; //算术右移

        int n3 = 1 >> 2; //算术左移

        int n4 = -1 >> 2; //算术左移

        int n5 = -1 >>> 2; //逻辑右移

        //以上移位运算符的结果为：
        System.out.println("n1="+ n1); //0
        System.out.println("n2="+ n2); //-1
        System.out.println("n3="+ n3); //0
        System.out.println("n4="+ n4); //-1
        System.out.println("n5="+ n5); //1073741823


        //以下逻辑位运算符为
        System.out.println(~2);//按位取反 -3
        System.out.println(~-5);//按位取反 4
        System.out.println(2&3);//按位与 2
        System.out.println(13&7);//按位与 5
        System.out.println(2|3);//按位或 3
        System.out.println(5|4);//按位或 5
        System.out.println(-3^3);//按位异或 -2

    }
}

4.1.7 运算符优先级

  1. 运算符又不同的优先级，所谓的优先级就是表达式运算中的运算顺序。

  2. 运算符中从右往左运算的是：单目运算符、赋值运算符。

  3. 表格中的上一行运算符优先于下一行运算符。

. （） {} ; ,
Right ——> Left ++ -- ~ !(data type)
Left ——> Right * / %
Left ——> Right + -
Left ——> Right << >> >>> 位移
Left ——> Right < > <= >= instanceof
Left ——> Right == !=
Left ——> Right &
Left ——> Right ^
Left ——> Right
Left ——> Right &&
Left ——> Right
Left ——> Right ? :
Right ——> Left = *= /= %=
+= -= <<= >>=
>>>= &= ^= |=

4.1.7 运算符综合练习

  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; shorts = b+2; //错误int -> short

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

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

标识符的概念

  1. Java 对各种变量、方法和类等命名时使用的字符序列称为标识符

  2. 简称-凡是可以自己定义名称的地方都叫标识符 int number = 100; number为标识符。

标识符的命名规则

  1. 只能由26个字母大小写，数字0-9，_或$组成（不能有空格）

  2. 不能由数字开头

  3. 严格区分大小写

  4. 不能使用关键字和保留字，但是能包含关键字和保留字

代码练习:

//命名规范的练习
public class VariableJudgment{ 
    //编写一个main方法
    public static void main(String[] args){

        int yuan; // 可以 由26个字母大小写，数字0-9，_或$组成
        int yuan01; // 可以 由26个字母大小写，数字0-9，_或$组成
        int 0yuan; // 不可以 不能以数字开头
        int x-y; // 不可以 不能有 - 符号
        int x y; // 不可一 变量名不能有空格
        int x$y; // 可以 由26个字母大小写，数字0-9，_或$组成
        int class; //不可以 不能用关键字
        int int; //不可以 不能用关键字
        int double; //不可以 不能用关键字
        int public; //不可以 不能用关键字
        int static; //不可以 不能用关键字
        int goto; //不可以 不能用保留字
        int xiao_yuan; // 可以 由26个字母大小写，数字0-9，_或$组成

    }
}
标识符命名规[基础版]
  1. 包名：

多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm

  1. 类名、接口名：

多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
比如： TankShotGame

  1. 变量名、方法名：

多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰，简称 驼峰法] 比如： tankShotGame

  1. 常量名：

所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
比如 ：定义一个所得税率 TAX_RATE.

  1. 后面我们学习到 类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.

代码示例:

//命名规范的示例
public class NamingRules{
    //编写一个main方法
    public static void main(String[] args){

        //不能包含空格
        // int a B = 999; // ××××××

        //不能由数字开头
        // int 01Test = 100; // ××××××

        //不能使用关键字和保留字，但是能包含关键字和保留字
        // int class = 10 ; // ××××××
        int class01 = 10 ; // √√√√√√

        //严格区分大小写
        int n = 1; // √√√√√√
        int N = 2; // √√√√√√
        System.out.println(n == N); // false 不相等
        System.out.println(n + N + " = 1 + 2"); // false 不相等

        // abc 和 aBc 是两个不同的变量
        int abc = 33;
        int aBc = 66;
        System.out.println(abc == aBc); // false 不相等
        System.out.println(abc + aBc + " = 33 + 66");

4.3 关键字

48个关键字：

abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

4.4 保留字

Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字。

2个保留字（现在没用以后可能用到作为关键字）：goto、const。

byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

3个特殊直接量：true、false、null。

4.5 键盘输入语句

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个扫描器(对象), 就是Scanner

实现步骤:

  1. 导入该类的所在包, java.util.*

  2. 创建该类对象（声明变量）

  3. 调用里面的功能

代码实现:

要求：可以从控制台接收用户信息，【姓名，年龄，薪水】

//键盘输入的练习

import java.util.Scanner; //导入 java.util 下的 Scanner 类

public class Input{ 
    //编写一个main方法
    public static void main(String[] args){
        //要求：可以从控制台接收用户信息，【姓名，年龄，薪水】
        //需求实现：
        //1. 导入 java.util 下的 Scanner 类
        //2. 创建 Scanner 对象 实例 --> scanner 就是 Scanner 类的对象
        //3. 调用 Scanner 里面的方法 获取用户输入的信息

        //创建 扫描器 实例
        Scanner scanner = new Scanner(System.in);

        //接受用户输入信息
        System.out.println("请输入用户的姓名:");
        //当程序执行到 next 方法时，会等待用户输入
        String userName = scanner.next();

        //接受用户输入信息
        System.out.println("请输入用户的年龄:");
        //当程序执行到 next 方法时，会等待用户输入
        int userAge = scanner.nextInt();

        //接受用户输入信息
        System.out.println("请输入用户的薪水:");
        //当程序执行到 next 方法时，会等待用户输入
        double userSalary = scanner.nextDouble();

        System.out.println("--------以下为用户的基本信息--------");
        System.out.println("用户姓名:" + userName
            + "\t用户年龄:" + userAge
            + "\t用户收入:" + userSalary
        );

    }
}

4.6 进制(程序员的基本功)

十进制 十六进制 八进制 二进制
0 0 0 0
1 1 1 1
2 2 2 10
3 3 3 11
4 4 4 100
5 5 5 101
6 6 6 110
7 7 7 111
8 8 10 1000
9 9 11 1001
10 A/a 12 1010
11 B/a 13 1011
12 C/c 14 1100
13 D/d 15 1101
14 E/e 16 1110
15 F/f 17 1111
16 10 20 10000
17 11 21 10001

4.6.1 进制介绍

对于整数，有四种表示方式：
二进制：0,1 ，满 2 进 1. 以 0b 或 0B 开头。

---------- 二进制是Binary，简写为B
十进制：0-9，满 10 进 1.

---------- 十进制是Decimal，简写为D

八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。

---------- 八进制是Octal，简写为O
十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

---------- 十六进制为Hexadecimal，简写为H

代码实现：

BinaryTest.java

//四种进制的格式信息
public class BinaryTest{ 
    //编写一个main方法
    public static void main(String[] args){

        //用二进制表示
        int base2 = 0B1111; // int --->15

        //用八进制表示
        int base8 = 01121; // int --->

        //用十进制表示
        int base10 = 1121; // int --->

        //用十六进制表示
        int base16 = 0X1121; // int --->

        System.out.println("二进制为:"+ base2); //15
        System.out.println("八进制为:"+ base8);    //593
        System.out.println("十进制为:"+ base10); //1121
        System.out.println("十六进制为:"+ base16); //4385

        System.out.println(0X1121B); //70171

    }
}

4.6.2 进制的转换(基本功)

  • 进制转十进制

    二进制转十进制；

    八进制转十进制；

    十六进制转十进制；

  • 十进制转进制

    十进制转二进制；

    十进制转八进制；

    十进制转十六进制；

  • 二进制转进制

    二进制转八进制；

    二进制转十六进制；

  • 进制转二进制

    八进制转二进制；

    十六进制转二进制；

一、进制转十进制

以 1100 为例，分别以二进制，八进制，十六进制转换为 十进制

1. 二进制转十进制

转换方法:

从最低位(右边)开始，将每个位上的数提取出来，乘以2的(位数- 1)次方，然后求和。

二进制 0b1100 --> 十进制：

1 * 2³(2的(位数4 -1)次方) + 1 * 2²(2的(位数3 -1)次方) + 0 * 2 + 0 *1 = 12

2. 八进制转十进制

转换方法:

从最低位(右边)开始，将每个位上的数提取出来，乘以8的(位数- 1)次方，然后求和。

八进制 01100 --> 十进制：

1 * 8³ + 1 * 8² + 0 * 8 + 0 * 1 = 512 + 64 = 576

3. 十六进制转十进制

转换方法:

从最低位(右边)开始，将每个位上的数提取出来，乘以16的(位数- 1)次方，然后求和。

十六进制 0X1100 --> 十进制：

1 * 16³ + 1 * 16² + 0 * 16 + 0 * 1 = 16 * 16 * 16 + 16 * 16 = 4352

4. 转换练习

0b110001100 转成 十进制

--> 1 * 2^8 + 1 * 2^7 + 1 * 2^3 + 1 * 2^2 = 256+ 128+ 8 + 4 = 396
02456 转成 十进制

--> 2 * 8^3 + 4 * 8^2 + 5 * 8 + 6 * 1 = 1024 + 256 + 40 + 6 = 1326
0xA45 转成 十进制

--> A * 16^2 + 4 * 16 + 5 * 1 = 2560 + 64 + 5 = 2629

二、十进制转进制

十进制以 99、9999 为例，以十进制 分别转换为 二进制，八进制，十六进制

1. 十进制转二进制；

转换方法:

十进制数除以2，余数为权位上的数，得到商继续除以2，直到商为0终止，然后反向取余数。

十进制 99 --> 二进制: （ 0b01100011 ）

99 / 2 --1 = 49 / 2 -- 1 = 24 / 2 -- 0 = 12 / 2 -- 0 = 6 / 2 -- 0 = 3 / 2 -- 1 = ---- 1

2. 十进制转八进制；

转换方法:

十进制数除以8，余数为权位上的数，得到商继续除以8，直到商为0终止，然后反向取余数。

十进制 9999 --> 八进制: （ 023417 ）

9999 / 8 -- 7 = 1249 / 8 -- 1 = 0156 / 8 -- 4 = 019 / 8 -- 3 = ----2

3. 十进制转十六进制；

转换方法:

十进制数除以16，余数为权位上的数，得到商继续除以16，直到商为0终止，然后反向取余数。

十进制 9999 --> 十六进制: （ 0X270F ）

9999 / 16 -- 15 = 624 / 16 -- 0 = 39 / 16 -- 7 = ----2

4. 转换练习

123 转成 二进制 => 0b01111011

123 / 2 -- 1 = 61 / 2 -- 1 = 30 / 2 -- 0 = 15 / 2 -- 1 = 7 / 2 -- 1 = 3 / 2 -- 1 = 1

678 转成八进制 => 01246

678 / 8 -- 6 = 84 / 8 -- 4 = 10 / 8 -- 2 = 1

8912 转成十六进制 => 0x22D0

8912 / 16 -- 0 = 557 / 16 -- 13 = 34 / 16 -- 2 = 2

三、二进制转进制

二进制以 10110110 为例， 以二进制 分别转换为八进制，十六进制

1. 二进制转八进制；

转换方法:

从低位开始，将二进制数每三位一组，转成对应的八进制数即可。

二进制 10110110 --> 八进制:

110 --> 6 、110 --> 6 、010 --> 2 ----> 0266

2. 二进制转十六进制；

转换方法:

从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。

二进制 10110110 --> 十六进制:

0110 --> 6 、 1011 --> 11 ----> 0XB6

3. 转换练习

0b11100101 转成 八进制
--> 011 --> 3 100 --> 4 101 --> 5 --> 345

0b1110010110 转成 十六进制

--> 0011 --> 3 1001 --> 9 0110 --> 6 --> 396

四、进制转二进制

八进制，十六进制 以 765 、0x42b为例，分别转换二进制

1. 八进制转二进制

转换方法:

将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。（注意事项，三位二进制转成八进制是从右到左开始转换，不足时补0）。

八进制 765--> 二进制：（0b000111110101）

7 / 2 -- 1 = 3 / 2 -- 1 = 1 ----> 111

6 / 2 -- 0 = 3 / 2 -- 1 = 1 ----> 110

5 / 2 -- 1 = 2 / 2 -- 0 = 1 ----> 101

2. 十六进制转二进制

转换方法:

将十六进制数每 1 位，转成对应的一个 4 位的二进制数即可。（注意事项，四位二进制转成十六进制是从右到左开始转换，不足时补0）。

八进制 0x42b --> 二进制：

4 / 2 -- 0 = 2 / 2 -- 0 = 1 ----> 0100

2 / 2 -- 0 = 1 ----> 0010

11 / 2 -- 1 = 5 / 2 -- 1 = 2 / 2 -- 0 = 1 ----> 1011

3. 转换练习

01230 转成 二进制 --> 0b0010 1001 100
001 010 011 000

0xAB29 转成二进制 --> 0b1010 1011 0010 1001

A --> 1010 B --> 1011 0010 1001

五、原码、反码、补码(重点 难点)

  1. 对于有符号的而言:二进制的最高位是符号位: 0表示正数，1表示负数

  2. 正数的原码，反码，补码都相同

  3. 负数的反码=原码取反（原码符号位不变，其他取反）

  4. 负数的补码=原码取反 + 1

  5. 0的反码、补码都是0

  6. Java 没有无符号数 ==》 Java 都是有符号的数

  7. 在计算机运算的时候，都是以补码的方式来运算的。

  8. 当我们看运算结果的时候，要以原码来看

原码、反码和补码

1、机器数与真值

机器数：在计算机中数据和符号全部数字化，最高位为符号位，且用0表示正、1表示负，那么把包括符号在内的一个二进制数我们称为机器数，机器数： 有原码、反码和补码三种表示方法。

比如，十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。

那么，这里的 00000011 和 10000011 就是机器数。

真值：用“+”、“—”号表示的二进制数。

机器数因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。

例：0000 0001的真值 = +000 0001 = +1，

1000 0001的真值 =   - 000 0001 =  -1

2、原码、反码和补码的概念

原码：

是最简单的机器数表示法。其数符位用0表示正，1表示负，其余各位表示真值本身。

即用第一位表示符号， 其余位表示值，比如如果是8位二进制：

  1的原码是00000001，

-1的原码是10000001。

反码：

正数的反码同原码， 负数的反码为除符号位外，其它各位按位取反。

正数的反码是其本身， 负数的反码是在其原码的基础上，符号位不变，其余各个位取反

  1的反码是00000001，

   -1的反码是11111110。

补码：

正数的补码同原码，负数的补码为反码加1。

负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1

  1的补码是00000001，

-1的补码是11111110。

本文由博客一文多发平台 OpenWrite 发布！

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 214,658评论 6赞 496
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,482评论 3赞 389
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 160,213评论 0赞 350
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,395评论 1赞 288
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,487评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,523评论 1赞 293
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,525评论 3赞 414
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,300评论 0赞 270
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,753评论 1赞 307
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,048评论 2赞 330
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,223评论 1赞 343
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,905评论 5赞 338
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,541评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,168评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,417评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,094评论 2赞 365
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,088评论 2赞 352

推荐阅读更多精彩内容

  • java基础之运算符
    1. 算术运算符 概念 "+" 加法运算符 "-" 减法运算符 "*" 乘法运算符 "/" 除法运...
    地三千阅读 256评论 0赞 0
  • Java基础之运算符
    一、概述 java运算符主要分为六大类：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和条件运算符。 二...
    Clf_忆笙阅读 240评论 0赞 0
  • Java基础之运算符
    六、运算符 6.1 概述： 6.2 分类： 6.2.1 算术运算符 加(+)减(-)乘(*)除(/)取余(%)前自...
    sexyhair阅读 271评论 2赞 0
  • Java基础（运算符）
    一、赋值运算符 基本语法数据类型 变量名 = 数值/变量; 二、算术运算符 基本算数运算符+、- 、* 、/ 、%...
    le_u阅读 170评论 0赞 0
  • Java基础------运算符
    算术运算符 符号：+，-，*，/，%，++，— — 意义：+：正号，加法，字符串连接符。/：整数相除，结果只能是整...
    姜水伟杰阅读 372评论 1赞 0