Mr笔记

Appearance

S01-02 JavaSE-基础-变量 ​

[TOC]

关键字 keyword@ ​

关键字（keyword）：是被 Java 语言赋予特定含义的保留字，用于定义程序结构、数据类型、流程控制等核心逻辑。这些关键字不能作为变量名、方法名、类名或标识符，且大小写敏感（所有关键字均为小写）。

  • HelloWorld 案例中，出现的关键字有 public 、class 、 static 、 void 等，这些单词已经被 Java 定义好了。

关键字使用规则：

  1. 大小写敏感：所有关键字均为小写（如 class 正确，Class 错误，Class 是类名）。
  2. 不能作为标识符：关键字不能用作变量名、方法名、类名、包名等（如 int int = 10; 错误）。
  3. 部分关键字有多重含义：
    • default：既可以是 switch 的默认分支，也可以是接口的默认方法修饰符。
    • final：可修饰类、方法、变量，含义不同但核心是 “不可变”。
  4. 保留字不可用：const 和 goto 虽未被 Java 使用，但属于保留字，不能作为标识符。

关键字比较多，不需要死记硬背，学到哪里记到哪里即可。

官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

image-20260113181313383

说明：

  1. 关键字一共50 个，其中const和goto是保留字(reserved word)。
  2. true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。
image-20220310234557454image-20220801143635356

标识符 identifier ​

标识符（identifier）：是用来给 Java 程序中的变量、方法、类、接口、包等元素命名的符号。简单来说，标识符就是你在写代码时为各种 “东西” 起的名字。

示例：

java
public class HelloWorld { // HelloWorld 是类名标识符
    public static void main(String[] args) { // main 是方法名标识符，args 是变量名标识符
        String message = "Hello"; // message 是变量名标识符
    }
}

标识符的命名规则（必须遵守的硬性规定，否则编译不通过）：

  1. 由合法字符组成：

    标识符可以由 字母（a-z, A-Z）、数字（0-9）、下划线（_） 和 美元符号（$） 组成。

    注意：不能以数字开头。

    注意：不能包含空格。

  2. 大小写敏感 (Case-Sensitive)：

    Java 是大小写敏感的语言。这意味着 age、Age 和 AGE 是三个完全不同的标识符。

  3. 不能使用关键字和保留字：

    标识符不能是 Java 中预定义的关键字（如 class, public, int, if）或保留字（如 goto, const）。这些词已经被 Java 语言本身占用了。

  4. 长度没有限制：

    从语法上讲，Java 标识符的长度没有上限。

    最佳实践：但为了代码的可读性和可维护性，标识符应该简洁明了，通常建议在 1-20 个字符之间。

练习：miles、Test、a++、 --a、4#R、$4、 #44、apps、class、public、int、x、y、radius

标识符的命名规范（建议遵守的软性要求，否则工作时容易被鄙视）:

  1. 包名：

    全小写字母，使用点（.）分隔，通常采用反向域名的形式，以保证唯一性。：xxxyyyzzz。

    例如：java.lang、com.atguigu.bean

  2. 类名、接口名：

    采用PascalCase（帕斯卡命名法，大驼峰），多单词组成时，所有单词的首字母大写：XxxYyyZzz

    例如：HelloWorld，String，System 等

  3. 变量名、方法名：

    采用camelCase（驼峰命名法，小驼峰），多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

    例如：age,name,bookName,main,binarySearch,getName

  4. 常量名：

    所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

    例如：MAX_VALUE, PI, DEFAULT_CAPACITY

注意 1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

注意 2：java 采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用汉字。

更多细节详见《代码整洁之道.pdf》《阿里巴巴 Java 开发手册-1.7.1-黄山版》

变量 ​

image-20220513235020527

一花一世界，如果把一个程序看做一个世界或一个社会的话，那么变量就是程序世界的花花草草、万事万物。即，变量是程序中不可或缺的组成单位，最基本的存储单元。

image-20220513235828042

初识变量 ​

变量：是 Java 程序中存储数据的基本单元，你可以把它想象成一个有名字的容器，这个容器里可以存放不同类型的数据，并且数据的值可以在程序运行过程中被修改。也可以在同一类型范围内不断变化。

变量的定义与构成：

一个完整的变量定义包含三个核心要素：数据类型、变量名和值。

java
// 数据类型   变量名  =   值;
   int       age    =   25;
   String    name   =   "张三";

  1. 数据类型 (Data Type)：

    • 决定了变量可以存储什么样的数据（例如整数、小数、文本等）。
    • 决定了变量在内存中占用的空间大小。
    • Java 是一种强类型语言，变量在声明时必须明确指定其数据类型，并且赋值时的数据类型必须与声明的类型匹配（或可以自动转换）。

  2. 变量名 (Variable Name)：

    • 是变量的唯一标识，用于在程序中引用这个变量。
    • 命名必须遵循 Java 的标识符命名规则：
      • 可以由字母、数字、下划线 _ 和美元符号 $ 组成。
      • 不能以数字开头。
      • 不能是 Java 关键字（如 int, class, public 等）。
      • 大小写敏感（age 和 Age 是两个不同的变量）。
    • 命名规范（建议）：
      • 采用 驼峰命名法 (camelCase)：第一个单词首字母小写，后续单词首字母大写，如 userName, totalPrice。
      • 见名知意：变量名应能清晰地表达其用途，避免使用 a, b, c 等无意义的名称。

  3. 值 (Value)：

    • 是变量存储的具体数据。

    • 在声明变量时可以立即赋值（初始化），也可以先声明后赋值。

      java
      // 方式1：声明时初始化
int score = 95;

// 方式1：先声明，后赋值
String address;
address = "北京市"; // 赋值语句

变量的作用域：仅限于定义它的方法或代码块{}内部。出了这个范围，变量就会被销毁，无法访问。同一个作用域内，不能定义重名的变量。

变量的数据类型 ​

Java 中变量的数据类型分为两大类：

  • 基本数据类型（8 个）：包括 整数类型、浮点数类型、字符类型、布尔类型。

  • 引用数据类型（6 个）：包括数组、 类、接口、枚举、注解、记录。

image-20251124153327841

变量的使用 ​

步骤 1：变量的声明 ​

变量声明的语法格式：

java
数据类型 变量名;
java
//例如：
//存储一个整数类型的年龄
int age;

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; // 表示a,b,c三个变量都是int类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

步骤 2：变量的赋值 ​

给变量赋值，就是把“值”存到该变量代表的内存空间中。

变量赋值的语法格式：

java
变量名 = 值;
  • 给变量赋值，变量名必须在=左边，值必须在=右边
  • 给变量赋的值类型必须与变量声明的类型一致或兼容

关于值的说明 1：可以使用合适类型的常量值给已经声明的变量赋值

java
age = 18;
weight = 109;
gender = '女';

关于值的说明 2：可以使用其他变量或者表达式给变量赋值

java
int m = 1;
int n = m;

int x = 1;
int y = 2;
int z = 2 * x + y;

关于值的说明 3：变量可以反复赋值

java
//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

说明：

  • 变量的第一次赋值称为初始化；
  • 变量的再赋值称为修改变量的值；

关于值的说明 4：也可以将变量的声明和赋值一并执行

java
boolean isBeauty = true;
String name = "迪丽热巴";

内存结构如图：

image-20220514152216148

基本数据类型@ ​

变量的数据类型决定了在内存中开辟多大空间。

变量的数据类型也决定了该变量可以存什么值。

整数类型：byte、short、int、long ​

  • Java 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 java 程序的可移植性。
image-20220311001553945

  • 定义 long 类型的变量，赋值时需要以"l"或"L"作为后缀。

  • Java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long。

  • Java 的整型常量默认为 int 型。

image-20220520111756274

补充：计算机存储单位 ​

字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于 8 bit。

位（bit）：是数据存储的最小单位。二进制数系统中，每个 0 或 1 就是一个位，叫做 bit（比特），其中 8 bit 就称为一个字节(Byte)。

转换关系：

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

浮点类型：float、double ​

  • 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
image-20220311001749699
  • 浮点型常量有两种表示形式：
    • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
    • 科学计数法形式。如：5.12e2 512E2 100E-2
  • float：单精度，尾数可以精确到 7 位有效数字。很多情况下，精度很难满足需求。
  • double：双精度，精度是 float 的两倍。通常采用此类型。
  • 定义 float 类型的变量，赋值时需要以"f"或"F"作为后缀。
  • Java 的浮点型常量默认为double型。

关于浮点型精度的说明 ​

  • 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示 0.1、0.01、0.001 这样 10 的负次幂。

  • 不要使用浮点数进行比较！很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误！需要比较请使用BigDecimal类（后续内容讲）。

  • 浮点类型 float、double 的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。

  • 测试用例：

java
//测试1：（解释见章末企业真题：为什么0.1 + 0.2不等于0.3）
System.out.println(0.1 + 0.2);//0.30000000000000004

//测试2：
float ff = 0.1f;
double dd = 1.0/10;
System.out.println(ff == dd);//

//测试3：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);

应用举例 ​

案例 1：定义圆周率并赋值为 3.14，现有 3 个圆的半径分别为 1.2、2.5、6，求它们的面积。

java
/**
 * @author 尚硅谷-宋红康
 * @create 12:36
 */
public class Exercise1 {
    public static void main(String[] args) {
        double PI = 3.14; //圆周率

        double radius1 = 1.2;
        double radius2 = 2.5;
        int radius3 = 6;

        System.out.println("第1个圆的面积：" + PI * radius1 * radius1);
        System.out.println("第2个圆的面积：" + PI * radius2 * radius2);
        System.out.println("第3个圆的面积：" + PI * radius3 * radius3);
    }
}

案例 2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。 它需要一个程序将华氏温度（80 度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

℃ = (℉ - 32) / 1.8
java
/**
 * @author 尚硅谷-宋红康
 * @create 12:51
 */
public class Exercise2 {
    public static void main(String[] args) {
        double hua = 80;
        double she = (hua-32)/1.8;
        System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
    }
}

字符类型：char ​

  • char 型数据用来表示通常意义上“字符”（占 2 字节）

  • Java 中的所有字符都使用 Unicode 编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

  • 字符型变量的三种表现形式：

    • 形式 1：使用单引号（''）括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
    • 形式 2：直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX 代表一个十六进制整数。如：\u0023 表示 '#'。
    • 形式 3：Java 中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n'; // '\n'表示换行符
    转义字符说明Unicode 表示方式
    \n换行符\u000a
    \t制表符\u0009
    \"双引号\u0022
    \'单引号\u0027
    \\反斜线\u005c
    \b退格符\u0008
    \r回车符\u000d

  • char 类型是可以进行运算的。因为它都对应有 Unicode 码。

布尔类型：boolean ​

  • boolean 类型用来判断逻辑条件，一般用于程序流程控制语句中：

    • if 条件控制语句；
    • while 循环控制语句；
    • for 循环控制语句；
    • do-while 循环控制语句；

  • boolean 类型数据只有两个值：true、false，无其它。

    • 不可以使用 0 或非 0 的整数替代 false 和 true，这点和 C 语言不同。
    • Java 虚拟机中没有任何供 boolean 值专用的字节码指令，Java 语言表达所操作的 boolean 值，在编译之后都使用 java 虚拟机中的 int 数据类型来代替：true 用 1 表示，false 用 0 表示。———《java 虚拟机规范 8 版》

  • 举例：

java
boolean isFlag = true;

if(isFlag){
    //true分支
}else{
    //false分支
}

经验之谈：

Less is More！建议不要这样写：if ( isFlag = = true )，只有新手才如此。关键也很容易写错成 if(isFlag = true)，这样就变成赋值 isFlag 为 true 而不是判断！老鸟的写法是 if (isFlag)或者 if ( !isFlag)。

类型转换 ​

在 Java 程序中，不同的基本数据类型的值经常需要进行相互转换。Java 语言所提供的七种基本数据类型（不包括 boolean 类型） 之间可以相互转换，基本数据类型转换有两种转换方式：自动类型提升和强制类型转换。

自动类型提升 ​

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

image-20220523162200891

基本数据类型的转换规则如图所示：

image-20220311002543688

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

java
int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换

//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

java
int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当 byte,short,char 数据类型的变量进行算术运算时，按照 int 类型处理。

java
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113

声明 long 类型省略L后缀原理：

java
long l1 = 123L;
long l2 = 123; // 可以看做是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;

//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

练习：

C
设 x 为float型变量，y为double型变量，a为int型变量，b为long型变量，c为char型变量，则表达式
x + y * a / x + b / y + c的值类型为：

A. int   B. long  C. double  D. char

强制类型转换 ​

将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

java
int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

强制类型转换（Explicit Type Conversion）：是 Java 中一种显式的类型转换方式，用于将一个数据类型的值转换为另一个不兼容或范围更小的数据类型。

这种转换可能导致精度丢失或数据溢出，Java 编译器不会自动执行，必须由程序员手动指定。

语法格式：

通过括号 () 包裹目标类型，将一个表达式的值从一种类型强制转换为另一种类型。

java
目标数据类型 变量名 = (目标数据类型) 源数据或变量;

基本数据类型的强制转换：

转换规则：将范围大、精度高的类型向范围小、精度低的类型转换。

java
// 1. double -> int (丢失小数部分)
double pi = 3.14159;
int intPi = (int) pi; // 结果为 3 (小数部分被舍弃)

// 2. float -> long (丢失小数部分)
float f = 123.45f;
long longF = (long) f; // 结果为 123

// 3. long -> int (可能溢出)
long bigLong = 1234567890123L;
int intFromLong = (int) bigLong; // 结果取决于 bigLong 的值是否在 int 范围内

// 4. int -> byte (可能溢出)
int largeInt = 200;
byte byteFromInt = (byte) largeInt; // 结果为 -56 (因为 200 超出了 byte 的范围 -128~127)

注意事项：

  1. 数据精度丢失与溢出：

    • 精度丢失：当浮点类型转换为整数类型时，小数部分会被直接舍弃，而不是四舍五入。

      java
      double d1 = 12.7;
int i1 = (int) d1; // 结果为 12 (小数部分被直接舍弃，而不是四舍五入)

    • 数据溢出：当一个大数值转换为小范围类型时，超出小范围类型表示范围的值会按照模运算进行处理，导致结果不正确。

      java
      int largeInt = 128;
byte byteFromInt = (byte) largeInt; // 结果为 -128 (因为 128 超出了 byte 的范围 -128~127)

      模运算：int 转 byte 后会截除高位的 3 个字节，只剩 1 个字节。此时最高位为1，就变成了负数。

      image-20251125103046534

  2. boolean 类型不能转换：

    boolean 类型不能与任何其他基本数据类型进行强制转换。

  3. 转换必须在兼容类型之间进行：

    例如，不能将一个 String 类型强制转换为 int 类型（需要使用 Integer.parseInt() 方法）。

  4. 可以通过强制类型转换提升数据类型：

    当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

    java
    // int -> double（提升数据类型）
int i = 1;
int j = 2;
double bigger = (double)(i/j);

练习：判断是否能通过编译

java
1）short  s = 5;
   s = s-2;                     //判断：n
2） byte b = 3;
    b = b + 4;                  //判断：n
    b = (byte)(b+4);            //判断：y
3）char c = ‘a’;
   int  i = 5;
   float d = .314F;
   double result = c+i+d;       //判断：y
4） byte b = 5;
    short s = 3;
    short t = s + b;            //判断：n

问答：为什么标识符的声明规则里要求不能数字开头？

java
如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
进而，如下的声明中l的值到底是123？还是12呢？ 出现歧义了。
long l = 123L;

与 String 的运算 ​

字符串类型：String：

  • String 不是基本数据类型，属于引用数据类型
  • 使用一对 "" 来表示一个字符串，内部可以包含0 个、1 个或多个字符。
  • 声明方式与基本数据类型类似。例如：String str = "尚硅谷";

运算规则：

  1. 任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果一定也是 String 类型

    java
    System.out.println("" + 1 + 2);// 12

int num = 10;
boolean b1 = true;
String s1 = "abc";
System.out.println(s1 + num + b1);// abc10true
System.out.println(num + b1 + s1);// 编译不通过：num+b1是加法运算，不是连接运算，布尔类型不能参与加法运算
System.out.println(num + (b1 + s1));// 编译通过：10trueabc

  2. String 类型不能通过()强制类型转换为其他的类型，只能通过 Integer.parseInt() 转换。

    java
    String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

案例：公安局身份登记

要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用 true 表示，单身用 false 表示）、联系方式等等。

java
/**
 * @author 尚硅谷-宋红康
 * @create 12:34
 */
public class Info {
    public static void main(String[] args) {
        String name = "康师傅";
        int age = 37;
        char gender = '男';
        double weight = 145.6;
        boolean isMarried = true;
        String phoneNumber = "13112341234";

        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("性别：" + gender);
        System.out.println("体重：" + weight);
        System.out.println("婚否：" + isMarried);
        System.out.println("电话：" + phoneNumber);

        System.out.println("name = " + name + ",age = " + age + "，gender = " +
                           gender + ",weight = " + weight + ",isMarried = " + isMarried +
                           ",phoneNumber = " + phoneNumber);
    }
}

练习：

练习 1：

java
String str1 = 4;                       //判断对错：N
String str2 = 3.5f + “”;               //判断str2对错：Y
System.out.println(str2);              //输出：3.5
System.out .println(3+4+“Hello!”);     //输出：7Hello!
System.out.println(“Hello!”+3+4);      //输出：Hello!34
System.out.println(‘a’+1+“Hello!”);    //输出：98Hello!
System.out.println(“Hello”+‘a’+1);     //输出：Helloa1

练习 2：

java
System.out.println("*    *");				//输出：*    *
System.out.println("*\t*");					//输出：*  *
System.out.println("*" + "\t" + "*");		//输出：
System.out.println('*' + "\t" + "*");		//输出：
System.out.println('*' + '\t' + "*");		//输出：
System.out.println('*' + "\t" + '*');		//输出：
System.out.println("*" + '\t' + '*');		//输出：
System.out.println('*' + '\t' + '*');		//输出：

进制 ​

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

image-20251125141756147

世界上有 10 种人 ，认识和不认识二进制的。

进制的分类 ​

进制的分类：

  • 十进制（decimal）

    • 数字组成：0-9
    • 进位规则：满十进一

  • 二进制（binary）

    • 数字组成：0-1
    • 进位规则：满二进一，以0b或0B开头

  • 八进制（octal）：很少使用

    • 数字组成：0-7
    • 进位规则：满八进一，以数字0开头表示

  • 十六进制

    • 数字组成：0-9，a-f
    • 进位规则：满十六进一，以0x或0X开头表示。此处的 a-f 不区分大小写

代码演示：

java
class BinaryTest {
  public static void main(String[] args) {

    int num1 = 123;		//十进制
    int num2 = 0b101;	//二进制
    int num3 = 0127;	//八进制
    int num4 = 0x12aF;	//十六进制

    System.out.println(num1);
    System.out.println(num2);
    System.out.println(num3);
    System.out.println(num4);

  }
}

进制的换算举例 ​

十进制二进制八进制十六进制
0000
1111
21022
31133
410044
510155
611066
711177
81000108
91001119
10101012a 或 A
11101113b 或 B
12110014c 或 C
13110115d 或 D
14111016e 或 E
15111117f 或 F
16100002010

二进制的由来 ​

二进制，是计算技术中广泛采用的一种数制，由德国数理哲学大师莱布尼茨于 1679 年发明。

二进制数据是用 0 和 1 两个数码来表示的数。它的基数为 2，进位规则是“逢二进一”。

二进制广泛应用于我们生活的方方面面。比如，广泛使用的摩尔斯电码（Morse Code），它由两种基本信号组成：短促的点信号“·”，读“滴”；保持一定时间的长信号“—”，读“嗒”。然后，组成了 26 个字母，从而拼写出相应的单词。

image-20220520105721126

记忆技巧：

morsecode

我们偶尔会看到的：SOS，即为：

image-20220520110206899

二进制转十进制 ​

二进制如何表示整数？

  • 计算机数据的存储使用**二进制补码形式存储，并且最高位是符号位**。

    • 正数：最高位是 0
    • 负数：最高位是 1

  • 规定：

    • 正数：补码与反码、原码一样，称为三码合一

    • 负数：补码与反码、原码不一样：

      • 负数的原码：把十进制转为二进制，然后最高位设置为 1

      • 负数的反码：在原码的基础上，最高位不变，其余位取反（0 变 1,1 变 0）

      • 负数的补码：反码+1

        image-20251125150027489

二进制转十进制：权相加法

针对于 byte 数据举例来说：

image-20220523114701881

  • 例如：byte 类型（1 个字节，8 位）

    25 ==> 原码 0001 1001 ==> 反码 0001 1001 -->补码 0001 1001

    -25 ==>原码 1001 1001 ==> 反码 1110 0110 ==>补码 1110 0111

java
整数：
正数：25   00000000 00000000 000000000 00011001（原码）
正数：25   00000000 00000000 000000000 00011001（反码）
正数：25   00000000 00000000 000000000 00011001（补码）

负数：-25  10000000 00000000 000000000 00011001（原码）
负数：-25  11111111 11111111 111111111 11100110（反码）
负数：-25  11111111 11111111 111111111 11100111（补码）

为什么要使用原码、反码、补码表示形式呢？

计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂！于是人们想出了将符号位也参与运算的方法。我们知道，根据运算法则减去一个正数等于加上一个负数， 即：1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法，这样计算机运算的设计就更简单了。

image-20220311234841261

一个字节可以存储的整数范围是多少？

java
//1个字节：8位

0000 0001  ~  0111 111 ==> 1~127

1000 0001 ~ 1111 1111 ==> -127 ~ -1

0000 0000 ==>0

1000 0000 ==> -128（特殊规定）=-127-1

十进制转二进制 ​

十进制转二进制：除 2 取余的逆

image-20220312000042595

二进制与八进制、十六进制间的转换 ​

二进制转八进制

image-20220312000233863

二进制转十六进制

image-20220312000251113

八进制、十六进制转二进制

image-20220312000341297

各进制间的转换 ​

image-20220312000143438

练习：

1.将以下十进制数转换为十六进制和二进制
123  256  87  62


2.将以下十六进制数转换为十进制和二进制
0x123   0x25F  0x38  0x62