Java基础_运算符

最新推荐文章于 2023-04-26 17:25:55 发布
最新推荐文章于 2023-04-26 17:25:55 发布
阅读量585 收藏 1
点赞数
分类专栏： 后端开发_韩顺平Java系列 后端开发_Java学习 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skrloinking/article/details/126510144
版权

第四章 运算符

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

运算符：

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

​ 比如： + - * /

表达式：

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

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

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

4.1 运算符的种类

  1. 算数运算符

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

  3. 逻辑运算符

  4. 赋值运算符

  5. 三元运算符

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

4.1.1 算数运算符

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

运算符运算实现结果
+正号+99
-负号z=12; -z-12
+加6 + 915
-减9 - 63
*乘6 * 954
/除54 / 318
%取余9 / 63
++
++
自增（前）：先运算后取值
自增（后）：先取值后运算
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 == 9false
!=不等于6 != 9true
<小于6 < 9true
>大于6 > 9false
<=小于等于6 <= 9true
>=大于等于6 >= 9false
instanceof检查是不是类的对象“Xiao” instanceof Stringtrue
代码实现:

关系运算符的使用 [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&&falsefalse
||或两边布尔表达式只要有一个为真，结果为真true&&falsetrue
!非布尔表达式为真，结果为假
布尔表达式为假，结果为假		!(true)false
^（作为逻辑运算符时）异或两边布尔表达式都为真，结果为假
只有一边的表达式为真，结果为真		true^truefalse
  1. 逻辑与 &，逻辑或 |，^ 逻辑异或
运算符运算作用实现结果
&与左右两边的布尔表达式都为真，结果才为真true&&falsefalse
|或两边布尔表达式只要有一个为真，结果为真true&&falsetrue
!非布尔表达式为真，结果为假!truefalse
^（作为逻辑运算符时）异或两边布尔表达式都为真，结果为假
只有一边的表达式为真，结果为真		true^truefalse
  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，结果才为12&40
I按位或两个位有一个为1，结果为12I46
~按位求反位为0，结果为1
位为0，结果为1		~2-3
^（用作位运算符时）按位异或两个位都为0，结果为12^46
逻辑位运算符的基本使用：
//位运算 的基本使用
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 << 28
>>算数右移低位溢出,符号位不变,并用符号位补溢出的高位
其实就是 左边的值 / 2^右边的值		4 >> 21
>>>逻辑右移
无符号右移		低位溢出，高位补 0
符号位也参与移动，空位补0，被移除的舍去		1 >>> 30
逻辑位运算符的基本使用：
//位运算 移位运算符 的基本使用
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 进制(程序员的基本功)

十进制十六进制八进制二进制
0000
1111
22210
33311
444100
555101
666110
777111
88101000
99111001
10A/a121010
11B/a131011
12C/c141100
13D/d151101
14E/e161110
15F/f171111
16102010000
17112110001

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。

一个程序原
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 10 新特性与功能
sinat_26065899的博客
05-24 970
Java 10引入了许多新的特性和功能，包括局部变量类型推断、G1垃圾收集器、应用程序类数据共享、线程局部变量删除、空指针异常收集器、基于JVM的JIT编译器接口以及可读性和稳定性的增强。这些新特性和功能可以帮助Java开发人员更加高效和便利地进行编码和优化。如果您想更深入地了解Java 10的新特性和功能，可以查阅Oracle官方文档或其他相关的学习资源。同时，在实际开发中，建议先使用Java 10的新特性进行一些小规模的实验和测试，并逐步应用到实际项目中，以确保应用程序的正确性和稳定性。
Crontab 的理解
王小明的专栏
07-09 323
Crontab 的理解 先分享工具 http://cron.qqe2.com/ Crontab 各个字段分别表示啥？ 字段名 允许的值 允许的特殊字符 秒 0-5...
shell中常用的特殊符号大全，尤其是；；和双引号（限制通配符扩展的功能，其他教程没见到介绍）教程中没介绍
二进制模----细微行动改变影响世界
08-23 955
shell中常用的特殊符号大全，尤其是;;教程中没介绍
java运算符
qq_45609387的博客
10-12 110
一、算术运算符 基本四则运算符 + - * / % 规则比较简单, 值得注意的是除法: a) int / int 结果还是 int, 需要使用 double 来计算 int a = 1; int b = 2; System.out.println(a / b); // 结果为 0 b) 0 不能作为除数 int a = 1; int b = 0; System.ou...
java定时任务
个人工作学习内容总结
04-15 298
1. 添加@EnableScheduling 在启动类上声明@EnableScheduling @EnableScheduling @MapperScan("com.**.mapper") @SpringBootApplication public class ServerApplication { public static void main(String[] args) { SpringApplication.run(ServerApplication.class, args)
java 基础知识-运算符
02-14
java基础 小白必须熟练掌握的知识,基础中的基础!!!
Java基础之运算符.docx
11-21
组成表达式的Java操作符有很多种。运算符按照其要求的操作数数目来分，可以有单目运算符、双目运算符和三目运算符，它们分别对应于1个、2个、3个操作数。运算符按其功能来分，有算术运算符、赋值运算符、关系运算符...
02_Java基础_（变量、运算符）_讲义cxf
02-15
02_Java基础_（变量、运算符）_讲义cxf
java基础开发环境和数据类型_运算符
05-11
java基础开发环境和数据类型_运算符----重新认识一下javaEE，陆续更新笔记
010302_【第3章：Java基础程序设计】_运算符、表达式与语句笔记.pdf
最新发布
08-19
java课程学习资料 若有侵权，请联系本人进行移除。
Java基础学习（10）
gua_Piter的博客
04-23 412
此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成:T、E、K、V等。只有存在的元素才能删除，所以不存在就会返回一个false，反之true。:当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类。类，无论添加什么都是返回true（添加成功），因为List类。: 在遍历的过程中需要添加元素，请使用列表迭代器。:在遍历的过程中需要删除元素，请使用迭代器。:添加位置后的每个数据后移，再添加元素。类，如果有重复的就会添加不成功，返回。：我们在添加元素的时候，如果为。
ELF可执行文件格式的理解
05-25 1895
<br />yihect | 12 元月, 2011 09:13<br />ELF(Executable and Linking Format)是一种对象文件的格式，用于定义不同类型的对象文件(Object files)中都放了什么东西、以及都以什么样的格式去放这些东西。它自最早在 System V 系统上出现后，被 xNIX 世界所广泛接受，作为缺省的二进制文件格式来使用。可以说，ELF是构成众多xNIX系统的基础之一，所以作为嵌入式Linux系统乃至内核驱动程序开发人员，你最好熟悉并掌握它。<br />
c语言学习-输入一个十进制数，输出其对应的八进制数据
weixin_43545253的博客
03-08 9604
输入一个小写字母,输出其对应的大写字母 程序流程图： 代码： #include<stdio.h> void main() { Int a; printf("输入一个十进制数:\n"); scanf("%d",&a); printf("输出对应八进制数:\n"); printf("%o",a); } 结果： ...
java实验《声明不同数据类型的变量》
qq_40641046的博客
10-09 1399
java实验《声明不同数据类型的变量》 编写声明不同数据类型变量的程序文件 KY2_1.java，源代码如下。 `package czxt; public class KY2_1 { public static void main(String args[]) { byte b=0x55; short s=0x55ff; int i=1000000; long l=0xffffL; char c=‘a’; float f=0.23F; double d=0.7E-3; boolean B=true; S
C语言基础篇
永远相信美好事情都会发生的博客
08-20 1950
1.C语言概述 1.1为什么要学习C语言 1.1.1 C语言的特点 1）优点： 代码量小 执行速度快 功能强大 编程自由 2）缺点： 写代码实现周期长 可移植性较差 过于自由，经验不足易出错 对平台库依赖较多 1.1.2 C语言的简洁 C语言仅有32个关键字，9种控制语句，34种运算符，却能完成无数的功能： 1.2第一个C语言程序 1.2.1编写C语言代码:hello.c #include <stdio.h> int main() { //这是第一个C语言代码 printf
Java中开根号，你还记得吗？
热门推荐
编程火箭车（Coding Rocket）专注编程领域
04-26 1万+
开根号相信大家都不陌生，这是一种数学运算，也称为开方运算，运算符号是根号 √￣。那么在 Java 中如何实现开方运算呢？
运算符 ||、&&、?:
weixin_43974125的博客
05-20 3149
最开始写代码用到的运算符主要就是||、&&、?:这三个，今天又了解到了几个，在此总结一下。 || - 主要用在多个条件满足一个的判断情况中，如： if(条件1||条件2||条件3) { console.log("三个条件满足一个输出"). } - 还可用在对象数据取值时，避免对象为空报错，如： 值不为空，可正常取到 let a = { b: { c: 1, }, }; console.log(a.b.c) // 1 若为null、undef...
Java假期作业（Day02）
Lucky_mzc的博客
01-20 870
一.选择题 1、【C语言】能正确表示逻辑关系： “a ≥=1 0 或 a ≤ 0” 的 C 语言表达式是（ D ） A. a >= 10 or a = 10 B. a >= 10 | a <= 0 C. a >= 10 && a = 10 D. a >= 10 || a <= 0 解析：A：C语言中没有类似or这个关键字 B：或，对应的符号是两个竖线 || C：&a...
java如何开根号？
a10534126的博客
03-21 6652
展开全部 JAVA凡是涉及数学的符号前面都要加MATH。 class A{ public static void main(){ double m=4.0; double n=Math.sqrt(m); System.out.println(n); } } 扩展资料： java实现开根62616964757a686964616fe59b9ee7ad9431333366306436号的运算： public static void main(String[] args) { long start = Syste
java compare 大于等于_Java基础-比较运算符Compare Operators
06-10
Java中比较运算符包括大于(>)、小于(<)、等于(==)、不等于(!=)、大于等于(>=)和小于等于()。 要比较两个数是否大于等于，可以使用大于等于运算符(>=)。例如，若要比较变量a和b的大小关系，可以使用如下代码： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值