Java基础（第二期）:第一个Java代码 && 变量 && Debug调试 && 数据类型及面试题 && 进制转换 && Scanner键盘输入 &&字符串拼接

Java基础（第一期）

注意：由于有编程语言的基础（以及开始不需要完全掌握，只需要多用）、所以，这里不单独讲解 注释、关键字、字面量、数据类型 等。后面的学习中，遇到会第一时间补充，谢谢！

一、使用 lntellij IDEA 创建类的步骤

1.1先了解java项目的组成

1.1.1、 java项目的组成：

首先：java的项目分为四个部分

1. 工程 （Project）
2. 模块 （Module）
3. 包 （Package）
4. 类 (Class）

• 由此可见：当我们想要创建一个类的时候，需要经过四个步骤。

创建项目

创建模块

创建包

创建类

• 创建的方法都在第一期有讲到过：从下载、安装、到创建、修改、删除都详细图解步骤教学：java基础（第一期）

二、Java中的注释

• 考虑了一下，既然是Java基础，那么还是有必要重将一下 注释了

在Java中，注释可以分为类：

① 单行注释

单行注释格式：   // 我是注释内容

② 多行注释（块注释）

多行注释的格式：  /* 
			我是注释的内容1
			我是注释的内容2
			......

*/

③ 文档注释 （用的少）

文档注释的格式：    /**
			注释内容1
			注释内容2
			....
*/

其实用一下就会了，不需要死记硬背。

三、关键字和标识符

在Java中，关键字和标识符是两个重要的概念。

关键字（Keywords） 是Java语言中具有特殊含义的保留字。这些关键字被用于表示语言的各种结构、控制流程以及表示数据类型等。例如，if、else、for、while、class等都是Java的关键字。关键字具有固定的含义，不能用作变量名、方法名或类名等标识符。

标识符（Identifiers） 是由程序员定义的符号名称，用于表示变量、方法、类等在代码中的命名。标识符可以包含字母、数字、下划线和美元符号，并且必须以字母、下划线或美元符号开头。标识符大小写敏感，即myVariable和myvariable是不同的标识符。

以下是一些关于关键字和标识符的示例：

java复制代码// 关键字示例
public class MyClass {
    public static void main(String[] args) {
        int if = 10; // 错误 - if是关键字，不能用作标识符
        int myVariable = 20; // 正确 - myVariable是有效的标识符
    }
}

// 标识符示例
public class MyClass {
    public static void main(String[] args) {
        int age = 25; // age是有效的标识符
        double _salary = 1000.50; // _salary是有效的标识符
        String $name = "John"; // $name是有效的标识符
    }
}

总结一下 ，关键字是Java语言中具有特殊含义的保留字，而标识符是程序员定义的符号名称，用于表示变量、方法、类等在代码中的命名。理解并正确使用关键字和标识符是编写有效的Java代码的基础之一。

四、第一个Java代码的固定语法解释

// 类名所在的包名
package com.itheima.demo1;
// 主要类的名称
public class HelloWorld {
//    主入口
    public static void main(String[] args) {
//        输出语句
        System.out.println("Ststem.out.println");
    }
}
/* 该文件将输了第一个 Java程序，解释了固定的语法格式*/

• 注释： 单行注释 // 和多行注释 /**/ 在上面代码块中已经展示和使用了。多用即可。

五、变量

5.1 定义变量

数据类型 变量 = 数据值

切记： 在同一个范围（所作用域内，不能重复定义一个变量），就如下面定义了一个变量 a ，不能在次重复定义一个 变量a哦！

//    主入口
    public static void main (String[] args) {
        int a = 10;
        System.out.println(a);  // 输出结果为： 10
    }

铺垫知识（代码解释）

public  static void main (String[] args) {}

上面这行代码是类的主入口，正如上面所说，是固定的。

---

// 数据类型   变量  = 数据值
int a = 10 

上面这行代码是声明了一个变量， int（整数类型）是一个数据类型，用来定义一个变量，后面对变量类型的秒数，就取决于数据类型的定义了。

a则就是一个变量（a就是变量的名字），你可以理解为a就是一个盒子，a只不过是这个盒子的名字而已。 同样的，a就是变量的名字。

= 表示的就是赋值（现在只需要记住即可，到后面会详细和运算符中的等于进行讲解）他的用途就是，将 = 右边的数据值 ，给左边的变量

---

##### 5.2 java的输出函数

System.out.println();

该行代码也是java中的固定语法。

他的作用就是输出语句，例如其他编程语言中的输出语句如下：

printf("hello c语言")

print("hello python语言")

console.log("hello JavaScript")

System.out.println("hello java")

由此发现：这几种编程语言中的打印语句中，都是写在小括号里面的，同时还用引号引起来的。

1. 其实，在所有编程语言中，所有被引号括起来的都是 字符串
2. 固定的打印输出，都需要引号（绝大多数），可变的（变量），本质就是作为一些数据的代号，如上面打印 变量a 一样。直接写，不需要引号！

• 后面会详细讲解哦！

---

5.3、变量的使用方式

基本用法: 主要讲解了 整型类型的数据（int）定义变量

1. 定义变量，进行输出

   public static void main (String[] args) {
        int a = 10;
        System.out.println(a);

2. 变量参与计算

// 从这里开始不在书写  java 的主入口固定的语法哈！ 忘了直接回看复制即可
int b = 10;
int c = 20;
System.out.println(b + c);  // 输出结果为：30

3. 修改变量所记录存储的值

// 修改变量的值
int x = 520;
x = 1314;
System.out.println(x);      // 输出结果为：1314

5.4、变量的注意事项（重点）

① 变量只能存储一个值（重新赋值也就是修改，会覆盖原来的值）

② 变量名在同一个作用域中不能重复定义

③ 一条语句可以定义多个变量

④ 变量在使用之前，必须要进行赋值 （将 = 右边的值 给 右边的）

⑤ 变量的作用域（后面详细说明）

演示：

一条语句可以定义多个变量 （不建议这样使用）

//      一条语句可以定义多个变量
        int y = 100, z = 200, k = 300;
        System.out.println(y);      // 输出结果为：100
        System.out.println(z);      // 输出结果为：200
        System.out.println(k);      // 输出结果为：300

变量在使用之前，必须要进行赋值 （将 = 右边的值 给 右边的）

//      变量在使用之前，必须要进行赋值 （将 =  右边的值 给 右边的）
        int g;
        System.out.println(g);      // 报错： java: 可能尚未初始化变量g

解决方法就是给 变量g 赋值 g = 666；记得在使用它之前哦！

建议：定义变量后，最好立即赋值。

---

5.5、变量小练习

需求：我有一个盒子，我在盒子中放了100个乒乓球。后来，我在盒子中取了20个乒乓球。然后，我又放了52个乒乓球进去。第二天，我准备了第二个盒子，将第一个盒子里的一半的乒乓球放入了第二个盒子中，请问，第一个盒子和第二个盒子此时各有多少个乒乓球？

分析：

1. 两个盒子，我们声明两个变量
2. 使用数学解题思路，加减 、触来实现代码的算法

代码示例：

        int box1 = 100;          // 定义第一个盒子变量
//		数学运算后，赋值给盒子（因为最终变的是盒子）
        box1 = box1 - 20;
        box1 = box1 + 52;
//        第二天
        int box2;				// 定义第二个盒子变量
        box2 = box1 / 2;
//      第一个盒子个数
        System.out.println(box1);       // 输出结果为： 132
//      第二个盒子个数
        System.out.println(box2);       // 输出结果为：66

• 特别注意变量的定义和基本的操作。

六、Debug调试工具

Debug： 是给程序员提供的一个代码调试工具

他可以查看程序的执行流程（断点调试），亦可以跟踪程序的执行。

6.1 调试步骤：

1、在行号的位置进行断电，选择需要卡住的位置：

2、右击代码空白区域，运行按钮的下面点击：

3、看到如下页面，表示Debug断点调试启动成功：

4、点击下箭头执行下一行代码，同时右侧显示执行过程记录：

5、切换到控制台，查看运行的结果：

6.2Debug 注意点：

第一个注意点

当我们所有的程序执行完毕，即表示本次Debug断点调试完毕，然后我们想在此调试的话有两种方式：

1、第一种方式就是，重新重复上面Debug步骤方式

2、第二种方式就是点击重复按钮：

第二个注意点

当我执行到一半的时候，发现了问题或者理解了解决了。想要终止怎么实现呢：

上图的 绿色 类似于开始按钮是直接从上一个断电执行语句后 调到下一个断点处执行的按钮（多用于多个断点调试）

两个红色圆圈用于清除多个断点，点击后 点击 - 号即可。

七、数据类型

在java中 数据类型分为两大类

① 基本数据类型

② 引用数据类型

这里先讲基本数据类型，引用数据类型等后面学完数组、面向对象再讲。

7.1、基本数据类型

数据类型	关键字
整数	byte（1）、short（2）、int（4）、long（8）
浮点数	float（4）、double（8）
字符	char（2）
布尔	boolean（1）

括号里面的表示 字节数 ，取值范围需要使用积累即可（不知道直接查找记忆），写出来我相信也不会记忆是吧！

虽然一个类型有几种，但是最本质的区别就是取值范围不同。不同的数据类型取值类型和内存的大小也不同。

7.1.1 整数型数据类

首选数据类型为：int

代码示例：

        // 1、 你看？大于十位的数字，int类型就存放不下
        int num = 10000000000;  //报错，取值范围超出
        System.out.println(num);

        // 2、 此时我们得使用 long 类型, 注意L
        long num1 = 10000000000L;
        System.out.println(num1);

注意点：看我在数字后面加上了一个 L，这是long类型的特变之处，虽然大小写都支持，但是小写和数字1 很难区分哦！

7.1.2 浮点数数据类型

首选数据类型为：double

代码示例：

        // 1、首选double ，正常使用
        double height = 1000.1;

        // 2、float就会报错，解决方法得加上个F 或者 f(建议大写)
        float height1 = 1000.1F;

注意：首先double ， float 后面一样需要加标识（f 后者 F）。

7.1.3 字符数据类型

代码示例：

//        字符类型
        char gender = '男';

单引号括起来的就是字符类型

7.1.4 布尔数据类型

代码示例：

//        字符类型
        char gender = '男';

注意：结果就是 true 和 false

7.2 简单数据类型的综合练习

拓展：string是引用数据类习；（后面学习）

练习要求：

打印下面简介：

1、 姓名 ： 科比布莱恩特

2、年龄： 18

3、性别：男

4、身高： 198.24

5、是否单身： 否

代码实现：

//        综合练习
        String name = "科比布莱特";
        int age = 18;
        char gender = '男';
        double height = 198.24;
        boolean flag = false;
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
        System.out.println(flag);

注意点：数字和小数 默认的是 int 类型 和 double类型

7.3 数据类型的补充

char类型的数据虽然是个字符，但我们也可以使用数字书出来，这里只需要知道就行了，没有人会使用ASCII表去写字符

// 定义一个 字符  a
char c = 97 // 返回结果为 a

你只需要知道，以后看见这种情况，不要觉得奇怪就行了。

// 默认类型

System.out.println(1234)  // 类型为 int
    
System.out.println(123.4)   // 类型为 double

八、Scanner 键盘输入

Scanner就是内置的模块，类似于python中的input 、C语言中的scanf_s等中的输入语句。

使用需要经历，键盘的录入的三个步骤：

1、先要导入 Scanner 模块

2、通过 Scanner 创建一个实例对象（后面会学习，直接背）

3、使用，接受键盘的值，用变量保存

8.1 代码示例：

// 从java 仓库里面找到 Scanner模块，创建一个实例对象，调用里面的方法（注意：所有的导入都必须在最上面）
import java.util.Scanner;

public class ScannerDemo {
    /*
        Scanner模块的使用：下面是从键盘获取整数 和 小数 的方法。
     */
    public static void main(String[] args) {
        // 2、创建实例对象：
        Scanner Liu = new Scanner(System.in);
        // 3、使用实例对象（让它发挥作用）
        int num = Liu.nextInt();
        double height = Liu.nextDouble();
        System.out.println(num);
        System.out.println(height);

        // 注意点：字符串直接使用next接收就好了
        String name = Liu.next();
        System.out.println(name);
    }
}


// 特别要注意数据类型

• 注意观察数据类型和 不同数据类型调用接受不同数据类型的方法。

8.2 Scanner 小结练习

需求：使用Scanner模拟简单的注册功能

功能：能够实先输入：姓名、年龄、性别、身高、婚姻状况、是否注册成功！

理清思路分析步骤：在进行实现

代码实现：

// 1、 导入 Scanner 功能模块
import java.util.Scanner;

public class ScannerCase {
    /*
        Scanner 键盘录入小结案例练习：
            1、导入 从java工具仓库中，导入Scanner模块
            2、通过该模块创建一个实例对象，使用Scanner去定义
            3、使用我们的实例对象，实现功能（记得用变量接收），以及数据的使用和定义
     */
    public static void main(String[] args) {
        // 2. 创建实例对象，给我们第三步创造获取的能力
        Scanner Input = new Scanner(System.in);
        // 3. (根据我们的需求)使用我们的实例对象

        // 1. 输入姓名
        System.out.println("请输入姓名：");
        String name = Input.next();

        // 2. 输入年龄
        System.out.println("请输入年龄：");
        int age = Input.nextInt();

        // 3. 输入性别
        System.out.println("请输入性别：");
        String gender = Input.next();

        // 4. 输入身高
        System.out.println("请输入身高: ");
        double height = Input.nextDouble();

        // 5. 输入婚姻状况
        System.out.println("是否已婚：");
        boolean flag = Input.nextBoolean();

        System.out.println("注册成功！");

        // 打印所有信息结果：
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
        System.out.println(flag);
    }
}

在此强调，注意使用的步骤和数据类型，尤其是数据类型的问题！！！

九、运算符和表达式

9.1运算符和表达式是什么？

• 运算符：对字面量或者变量进行操作的符号
• 表达式：用运算符把字面量或者变量连接起来符合 Java语法的格式就可以成为表达式。不同运算符链接的表达式体现的是不同类型的表达式。

        int a = 10;
        int b = 20;
        int c = a + b;

+: 是运算符，并且是算数运算符

a + b ：是表达式，由于 + 是算数运算符， 所以这个表达式叫做算数表达式。

9.2 运算符整合表

符号	作用	说明
+	加法	加法运算
-	减法	减法运算
*	乘法	乘法运算
/	除法	除法运算
%	取余	求余运算

加减乘 代码示例：

public class operatorDemo1 {
    public static void main(String[] args) {
        // 1、 下面是加减乘的运算符表达式：
        System.out.println(10 + 20);
        System.out.println(10 - 20);
        System.out.println(10 * 20);
        /*
            运行结果：
                30
                -10
                200
         */
    }
}

除 余代码示例：

• / ：整数和整数操作的时候，只能得到整数，想要得到小数，需要有小数参与
• %: 取模，作用是用来取余数的 (结果不是 0 就是 1)

public class operatorDemo1 {
    /*
        加减乘运算符没什么需要注意的，重点讲解 除法  和  求余
     */
    public static void main(String[] args) {
        // 1. 除法
        System.out.println(5 / 2);
        System.out.println(5.0 / 2);
        System.out.println(5 / 2.0);
        System.out.println(5.0 / 2.0);
        /*
            运行结果：
                2
                2.5
                2.5
                2.5
         */

        // 2. 求余取模
        System.out.println(5 % 2);      // 5 / 2 = 2....1
        System.out.println(4 % 2);      // 4 / 2 = 2....0
        System.out.println(3 % 2);      // 3 / 2 = 2....1
        System.out.println(2 % 2);      // 2 / 2 = 2....0
        /*
            运行结果：
                1
                0
                1
                0
         */

    }
}

/ 得到的是商 % 得到的是余数

9.3 数值拆分练习

需求：键盘录入一个三位数，将其拆分为 十位、个位、百位 后，打印在控制台。

分析：

1. 使用Scanner键盘录入一个三位数；
2. 对这个数进行拆分，使用 / and % 操作符号进行处理；

代码示例：

// 1. 导入 Scanner 模块
import java.util.Scanner;

public class operatorText1 {
    /*
        需求： 键盘输入一个三位数，将一个三位数的个位十位百位进行拆分，并打印
     */
    public static void main(String[] args) {
        // 2. 使用导入的  Scanner 模块创建实例对象
        Scanner Input = new Scanner(System.in);

        // 3. 使用 创建的实例对象
        int number = Input.nextInt();
        
        int g = number % 10;
        int s = number / 10 % 10;
        int b = number / 100;

        System.out.println(g);
        System.out.println(s);
        System.out.println(b);

        /*
            运行结果：
                3
                2
                1
         */

    }
}

9.3 拆分数值

需求： 键盘输入一个三位数，将一个三位数的个位十位百位进行拆分，并打印

注释了代码实现步骤：仔细观察

// 1. 导入 Scanner 模块
import java.util.Scanner;

public class operatorText1 {
    /*
        需求： 键盘输入一个三位数，将一个三位数的个位十位百位进行拆分，并打印
     */
    public static void main(String[] args) {
        // 2. 使用导入的  Scanner 模块创建实例对象
        Scanner Input = new Scanner(System.in);

        // 3. 使用 创建的实例对象
        int number = Input.nextInt();

        int g = number % 10;
        int s = number / 10 % 10;
        int b = number / 100;

        System.out.println(g);
        System.out.println(s);
        System.out.println(b);

        /*
            运行结果：
                3
                2
                1
         */

    }
}

对于数值的最高位：我们直接 / 除以他就可以拿到他的最高位

例如：

123 / 100 … 1

1234 / 1000 … 1

12345 / 10000 … 1

123456 / 10000 … 1

十、字符串拼接

拼接： 就是当 + 操作中，遇到了字符串，这时 + 就是字符串连接，而不是算数运算。

• 需要注意优先级

通过字符串拼接优化上面数值拆分效果：

        System.out.println("整数" + number + "的个位为" + g);
        System.out.println("整数" + number + "的十位为" + s);
        System.out.println("整数" + number + "的百位为" + b);

        /*
        输入： 123
        输出结果为：
            整数123的个位为3
            整数123的十位为2
            整数123的百位为1
         */

System.out.println("13+14=" + 13 + 14)     // 结果为 13+14=1314

这就是优先级的问题，解决办法就是使用小括号。

十一、自增自减运算符

注意：自增自减运算符只能操作变量，不能操作常量。

System.out.println(10++) 	// 报错： 自增玩，你给谁？不是变量搞不了

作用：

符号	作用	说明
++	自增	变量自身的值加1
–	自减	变量自身的值减1

10.1单独使用的情况：

public class operatorDemo2 {
    /*
        自增自减运算符：
            1. ++： 让变量自身加1
            2、--： 让变量自身减1
     */
    public static void main(String[] args) {
        int a = 10;
        a++;
        System.out.println(a);
        int b = 10;
        b--;
        System.out.println(b);
    }
    /*
        运行结果为：
            a = 11
            b = 9
     */
}

++ – 符号，在前在后效果都一样。

10.2参与运算符使用的情况

参与运算的时候： ++ 在前的话：

++ 在前的操作：（先自增，在赋值）

代码示例：

        // 1、 ++ 在前的操作：（先自增，在赋值）
        int a = 10;
        int b = ++a;
        System.out.println("a=" + a);
        System.out.println("b=" + b)
        /*
        运行结果：
            a=11
            b=11
         */

++ 在后的操作：（先赋值，在自增）

代码示例：

        // 2、 ++ 在后的操作：（先赋值，在自增）

        int a = 10;
        int b = a++;
        System.out.println("a=" + a);
        System.out.println("b=" + b);
        /*
        运行结果：
            a=11
            b=10
         */

10.3 自增自减运算符的练习：

public class operatorTest2 {
    /*
        经过观察：说出下面的输出结果
            符号在前：先自增，在赋值
            符号在后：先赋值，在自增

     */
    public static void main(String[] args) {

        // 第一题
        int X = 10;
        int Y = X++;
        int Z = ++Y;
        System.out.println("X=" + X);
        System.out.println("Y=" + Y);
        System.out.println("Z=" + Z);

        // 第二题
        int a = 3;
        int b = (++a) + (a++) + (a * 10);
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
    /*
        第一题：运行结果：（注意分析步骤）
            X=11
            Y=11
            Z=11

        第二题：运行结果：（注意分析步骤）
            a = 5
            b = 58
     */
}

• 注意点：就是那句话：

•         `符号在前：先自增，在赋值
          符号在后：先赋值，在自增`
  

十二、类型转换

12.1 隐式转换

• 把一个取值范围小的数值或者变量，赋值给另外一个取值范围大的变量。(这里指的是 数据类型的取值范围)

类型转换 → 隐式转换
隐式转换：将取值范围小的数值或变量，给取值范围大的数值或变量赋值。
口诀： 小的给大的，可以直接给

public class TypeConversionDemo1 {
    public static void main(String[] args) {
        int a = 10;
        double b = a;
        System.out.println(b);  // 运行结果为： 10.0(发生转换)
    }
}

12.1.2 隐式转换的执行原理：

如上面的示例代码：
1、a 赋值给 b （底层是复制）

​ 2、b 得到了 10

​ 3、但是 b 为double 类型：所以打印结果为 10

12.1.3 取值范围从大到小的排列

byte -> short -> int -> long -> float -> double

float不是占用四个字节吗？为 long 八个字节在他前面？

解释：这里float的取值范围，注意是取值范围要比 long 更大。

因为小数的二进制存储所占用的空间要比整数的小。

12.2 运算过程中的隐式转换

• 取值范围小的数据，和取值范围大的数据进运算，小的会先提升为大的之后，在进行运算.

在 java 中，计算的时候，数据类型要统一

所以：看下面代码：

    /*
        计算中的隐式转换
     */

    public static void main(String[] args) {
        int a = 10;
        double b = 12.3;
        double c = a + b;
        System.out.println(c);

    }

int 和 double 运算，int 会先提升为 double 然后运算，所以，c 类型需要为： double类型

• 计算需要先统一

注意点：byte 、 short 、char、 三种数据类型在运算的时候，都会提升为 int 类型，然后再进行运算。

拿byte举例：

    /*
        计算中的一些类型注意点（byte 、 short、 char）
            这里使用 byte举例
     */

    public static void main(String[] args) {
        byte aa = 10;
        byte bb = 20;
        int cc = aa + bb;
        System.out.println(cc);
    }
}

• 这里必须使用int来接收，因为上面说到的三种类型，在运算的时候，默认会转换为 int 类型，然后再去运算。

那为啥这里 char 类型都会默认为 int 类型呢？

因为：字符的底层就是数字（前面也讲到过，我用数字都可以实现字符的赋值）

12.3 强制转换

• 把一个 取值范围大 的数值或者变量 ，赋值给另一个取值范围小的变量（和隐式转换相反）

不允许直接赋值，需要加入强制转换。

语法格式： 目标数据类型 变量名 = （目标数据类型）被强转的数据

public class TypeConversionDemo2 {
    /*
        强制数据类型转换“
            语法格式： 目标数据类型 变量名 = （目标数据类型） 被强转数据
            注意： 强制数据类型转换，可能会丢失精度
            原因，byte 和 int 都是数字类型的整数，（取值范围合理的情况下）这两个之间就不会直接丢失精度。
     */
    public static void main(String[] args) {
        double a = 12.6;
        int b = (int)a;
        System.out.println(b);
    }
    }

强制数据类型的转换，特别记住会丢失精度 和 取值范围的问题！（打的给小的转，别过头了哈哈！）

十三、二进制源码、反码、补码 - 强转精度丢失问题

13.1 计算机进制的分类

二进制： 二进制数据是使用 0 和 1 两个数码来表示的。

进位规则是 逢二进一，借位规则是借二进一

十进制：由 0、1、2、3、4、5、6、7、8 进行表示的

逢十进一，借十当一

八进制： 采用 0、1、2、3、4、5、 6、7八个数字表示，逢八进一

十六进制：用数字0 - 9 和 字符 A 到 F （或者a-f）表示：其中（a-f） 表示 数字 10-15，这就是十六进制。

【0】 【1】 【2】【3】【4】【5】【6】【7】【8】【9】【a】【b】【c】【d】【e】 【f】

注意事项：

• 计算机中进制的分类(知道了解就好了)
  十进制: 默认
  二进制： 0b开头
  八进制： 0开头
  • 今后编写代码最好不要使用0开头
    开头
    + 今后看到了 0-9 和 a-f 组合排列的，要知道这是 十六机制数据。

代码示例：

public class ScaleDemo1 {
    public static void main(String[] args) {
        System.out.println(110);
        System.out.println(0b110);
        System.out.println(0110);
        System.out.println(0x110);
    }
    /*
        运行结果：
            110
            6
            72
            272
      */
}

13.2 二进制转十进制

公式：系数 * 基数的权次幂 相加

系数：就是每一位上的数

基数：当前进制数

权： 从右往左，依次为 0 1 2 3 4 5 …

例如：

二进制 101 转为十进制：

1 * 2 ^0 + 0 * 2^1 + 1 * 2^2

结果等于： 5

快速转换法：

8421法则：从右往左依次倍数递增 你看看，然后将二进制一一比对然后加起来 就行了（快的很哈哈！）

​ 1 0 1

8 4 2 1

​ 4 0 1 = 5

13.3 源码反码补码

原码：将一个整数，转换成二进制，就是其原码。如单字节的5的原码为：0000 0101；-5的原码为1000 0101。

反码：正数的反码就是其原码；负数的反码是将原码中，除符号位以外，每一位取反。如单字节的5的反码为：0000 0101；-5的反码为1111 1010。

补码：正数的补码就是其原码；负数的反码+1就是补码。如单字节的5的补码为：0000 0101；-5的原码为1111 1011。

二进制经过了上面几个过程，后，看看下面的：

由此可知道，为何会变成 -126 吗？（不需要深入去完全了解，只需要知道为什么即可）

不必刻意深究

十四、类型转换面试题

第一题：

public class TypeConversionTest {
    /*
        类型转换面试题：下面代码是否存在错误，有则指出，并改正；
                byte b1 = 3;
                byte b2 = 4;
                byte b3 = b1 + b2; 错误  因为： (注意：运算的时候，byte类型参与运算默认转为 int类型）
                
                错误原因：
                	b1和b2是两个byte类型，在进行运算的时候，都会隐式转换提升为int类型，那么，你int类型给byte能不报错吗？
         			打给小除了强制转换，能大给小吗？

     */
    public static void main(String[] args) {
        byte b1 = 3;
        byte b2 = 4;
        // 解决方法：1 (修改数据类型)
        int b3 = b1 + b2;
        // 解决方法：2 （强制转换类型）
        byte b3 = (byte)(b1 + b2);
        System.out.println(b3);

    }
}

第二题：

public class TypeConversionTest {
    public static void main(String[] args) {
        // 问题二： 为什么下面这行代码不会报错？
        byte x = 10 + 20;
        System.out.println(x);
    }
    /*
        运行结果为： 30；
     */
 
}

表面上看，10 + 20 这两个字面量不都是整数类型吗？不管是byte类型还是short还是int，最终进行运算会成为int类型啊！为什么？

• 由于（java常量优化机制）：虽然这里是字面量，如果你使用变量来代替这两个数组字面量，就会报错。因为底层javac编译直接将这个字面量编译。

其次底层都是二进制的，直接加载一起，依旧是属于byte范围内，所以将字面量表达式计算完毕后小于byte的取值范围，依旧使用byte类型处理它，然后赋值给我们 byte类型的 x 变量，是可以的。如果超出了范围，也是会报错的

---

Java基础持续更新中........敬请期待，谢谢！