JAVA基础介绍
1、java 开发环境：
1、编译运行过程：
1、编译器：.java源文件，经过编译，生成.class字节码文件
2、运行期：JVM加载.class并运行.class（0和1）；
2、名词解释：
1、JVM：java虚拟机
加载.class并运行.class
2、JRE：java运行环境
除了包含JVM以外，还包含了运行java程序所必须的环境
JRE = JVM+java系统类库（小工具）
3、JDK:java开发工具包
除了包含JRE以外包含了开发java程序所必须的命令工具
JDK = JRE+ 编译、运行等命令工具
2、IDEA:
1、JetBrains公司的，分为社区版和终极版
2、开发不走：
1、新建java项目/工程 -------------------校区
2、新建java包---------------------楼/单元
3、新建java类 -------------------房子
3、注释：结石性文件（计算机不执行）；
1、单行注释：//
2、多行注释 /* /
3、文档注释： /* */
3、IDE：集成开发环境，一套带图形界面的功能强大的工具，常见的有IDEA和Eclipse
java以前是Sun公司，但是Sun已经被Oracle收购了，所以现在说java是Oracle公司的
java是开源的，免费的语言；
JAVA语法基础
1、变量：存数的，代词，指代的就是里面的那个数
1、声明：--------相当于在银行开了账户
2、初始化/第一次赋值： ------相当于给账户存钱
3、使用：------使用的是账户里面的钱
1、对变量的使用就是对它所存的那个数的使用
2、变量在使用之前必须声明并初始化
4、命名：
1、只能包含字母、数字、_和$符，不能以数字开头
2、严格区分大小写
3、不能使用关键字
4、允许中文命名，但不建议，建议“英文的简明之一”、“小驼峰命名
2、八种基本数据类型：byte、short、int、long、float、double、boolean、char
1、int：整形，4个字节，-231到231-1 之间
1、整数直接量默认为int类型，但不能超出范围，若超出范围则发生编译错误。
2、两个整数相除，结果还是整数，小数位无条件舍弃（不会四舍五入）
3、运算时若超范围，则发生溢出（已初步是错误，但是需要避免）
2、long：长整型，8个字节，范围 ：-263到263-1
1、长整型直接量需在数字后加L或l
2、运算时若可能溢出，建议在第1个数字后加L
3、double ：浮点型，8个字节
1、浮点型直接量默认为double类型，若表示float需在数字后加F/f
2、double和float类型数据参与运算时，有可能发生舍入误差，精确场合不能使用
4、boolean ：布尔型，1个字节
只能存储false和true
5、char：字符型，2个字节
1、采用Unicode字符集编码格式，一个字符对应一个码，
表现得形式时字符char，但本质上时int（0到65535）；
ASCII码： a-----97， A-----65 0---------48
2、字符型直接量必须放在但引导中，有且仅有一个字符
3、特殊符号需要通过\进行转移： ’ \ ’ ’
6、数据类型转换
基本类型由大到小 ： byte short int long float double
( char)
1、两种方式
1、 自动/隐式类型转换，：小类型到大类型
2、强制类型转换，：大类型转为小类型
语法：（要转成的数据类型）变量
注意： 强转有可能发生溢出或者丢失精度
2、两点规则：
1、整数直接量可以直接赋值给byte，short，char，但不能超出范围
2、byte，shaort，char类型数据参与运算时，系统一律自动将其转化为int类型再运算
补充：
1、命名法：
1、小驼峰命名法：第一个单词首字母小写，其余单词首字母大写，-----变量、方法名（score myScore）
2、大驼峰命名法/帕斯卡命名法：所有单词首字母都大写，--------类名
2、数据类型分为： 基本数据类型、引用数据类型
3、内存换算
1G = 1023M. 1M =1024KB 1KB = 1024B（字节） 1B = 8bit（位）
7、运算符： 运算的符号
1、算术：+ - * / % ++ – （a++先赋值后加1 ，++a先加1后赋值）
2、关系运算符： > < >= <= == !=
3、逻辑： && || ！
4、赋值： 简单赋值 =
拓展赋值 += -= *= /= %=
5、字符串连接： + （同化作用）
6、条件/三目运算符： boolean ？ 数据1 ： 数据2
8、分支结构：基于条件执行某语句
1、 if结构：一条路
2、if…else 结构 两条路
补充：
1、& 为不短路与 | 为不短路或
2、任何复杂的程序逻辑都可以通过三种结构来实现：
1、顺序结构：从上往下逐行执行，每句必走；
2、分支结构：有条件的执行某语句，并非每句必走
3、循环结构：
1、Scanner 接收用户输入的数据：共3步
Scanner是一个类，需要new对象，并且含有参构造
方法有返回值
9、分支结构：
1、if …else if …结构：多条路
2、switch…case 结构： 多条路
优点：效率高，结构清晰
缺点：只能对整数判断相等
break：跳出switch，没有的时候会发生穿透效应
常见面试题： switch可以作用于什么类型的数据上：
byte ，short ，int，char，String ，枚举类型
10、循环：反复多次执行一段相同或相似的代码
11、循环的三要素：
1、循环变量的初始化，
2、循环的条件（以循环变量为基础）；
3、循环变量的改变（想着循环的结束变）；
循环变量：在整个循环过程中所反复改变的那个数
12、循环结构
1、while结构：先判断后执行，有可能一次都不执行
2、do…while结构，先执行后判断，至少执行一次
要素1与要素3相同时，首选do ……while
补充：
1、变量的作用域/范围；
1、从变量声明开始，到包含它最近的大括号结束
2、生成随机数
int num = (int)(Math.random()*100+1);
Math.random() …… 0.0到0.999999999999………………
3、任何复杂的程序逻辑都可以通过三种结构来实现；
1、循序结构： 从上往下逐行执行，每句必走
2、分支结构：有条件的执行某语句一次，并非每句必走
3、循环结构：有条件的执行某语句多次，并非每句必走
13、循环结构：
1、for结构：应用率高、与次数相关的循环
14、三种循环结构的选择规则;
1、先看循环是否与次数相关：
1、若相关----------------直接上for
2、若不相关，再看要素1和要素3是否相同；
1、相同------------------直接上do……while
2、若不相同…………直接上while
15、break：跳出循环
continue ：跳过循环体中剩余语句而进入下一次循环
16、嵌套循环：
1、循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
2、执行过程： 外层循环走一次，内层循环走所有次数
3、建议：嵌套层数越少越好，能用一层就不用两层，能有两层就不用三层；
4、break只能跳出当前一层的循环；
17、数组：
1、是一种引用数据类型（引用类型）
2、相同数据类型元素的集合
3、定义：
4、初始化：给数组中的元素做初始化
5、访问：访问的是数组中的元素
1、通过（数组名.length）可以获取数组的长度（元素的个数）；
2、通过下标/索引来访问数组中的元素
下标从0开始，最大到（数组长度-1）；
6、遍历/迭代：从头到尾挨个走一遍
补充：
1、变量的同名问题：
1、作用域重叠时，变量不能同名；
2、\t ：水平指标为，固定8位
3、ArrayIndexOutOfBoundsException数组下标越界异常
1、数组下标范围时0到长度-1 超出范围则发生如上异常
18、数组：
1、复制
1、System.arraycopy(a,1,b,0,4);
2、int[] b = Arrays.copyOf(a,6);
2、排序
1、Arrays.sort(arr); //升序排列，（从小到大）
19、方法： 函数、过程
1、封装一段特定的业务逻辑功能
2、尽可能的独立，一个方法只干一件事
3、方法可以被反复多次调用
4、减少代码重复，有利于代码复用，有利于代码维护
20、定义方法：五要素
修饰词 返回值列表 方法名（参数列表） {
方法体------具体额业务逻辑功能实现
}
22、调用方法：
1、无返回值： 方法名（有参传参）；
2、有返回值： 具体类型 变量 = 方法名（有参传参）；
5、return ：
1、return 值; //1）结束方法的执行，2）返回结果给调用方
-----------用在有返回值方法中
2、return ; //1） 结束方法的执行
--------------用在无返回值的方法中
补充：
1、形参：形式参数，定义方法时的参数为形参
2、实参：实际参数，调用方法时的参数为实参
面向对象基础
1、什么是类？什么是对象？
1、现实生活中是由很多很多对象组成的，基于对象抽出了类
2、对象：软件中真实存在的单个个体/东西
类：类别/类型，代表一类个体
3、类是对象的模子，对象是类的具体的实例
4、类中可以包含：
1、对象的属性/特征------------成员变量
2、对象的行为/动作-------------方法
5、一个类可以创建多个对象
2、如何创建类？ 如何创建对象？ 如何访问成员？
.class new .
3、方法的重载(overload/overloading)-----------更方便用户的访问
1、发生在同一类中，方法名相同，桉树列表不同
2、表一起在编译是会根据方法的签名自动绑定方法
补充：
1、高质量的代码：
1、复用性好、扩展性好、维护性好、可移植性好\健壮性好、可读性好、效率好……
2、默认规则：
byte、short、int、long、char --------0
float \ double ------------0.0
boolean ---------------false
引用类型----------------null
3、
Student zs = new Student();
数据类型 引用变量（引用） 指向 对象
//若想访问对象，需要通过引用zs.
4、方法的签名: 方法名+参数列表
1、构造方法： 构造函数、构造器、构建器-------------复用给成员变量赋初始值代码
1、作用：给成员变量赋初始值
2、与类同名，没有返回值类型（连void没有用）
3、在创建（new） 对象时被自动调用
4、若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默认提供
5、构造方法可以重载
2、this ： 指代当前对象，那个对象调用方法它值的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this
this的用法：
1、this.成员变量名------------访问成员变量
成员变量与局部变量同名时，若想访问成员变量则this不能省略
2、this.方法名（）； -----------条用方法
3、this（）；-------------------调用构造方法
3、null 表示空，没有指向任何对象
若引用的值为null，则该引用不能进行任何点操作了
若操作则发生NullPointerException 空指针异常
补充：
1、成员变量和局部变量是可以同名的：
-------使用的时候默认采取就近原则
--------若想访问成员变量，则this不能省略
2、内存管理： 由JVM来管理的
1、堆： new出来的对象（包括成员变量）；
2、栈：局部变量(包括方法的参数);
3、方法区： ----------------
3、成员变量：写在类中，方法外--------------有默认值
局部变量： 方法中--------------------没有默认值
4、数组也是一个对象，所以数组对象也存储在堆中，
将数组的元素当作成员变量一并存储在堆中
1、引用类型数组：
1、与基本类型数组的区别：
1、给数组元素赋值必须new一下
2、若想访问对象数据必须通过数组元素打点
2、继承
1、作用：代码复用
2、通过extends来实现继承
3、超类/父类： 共有的属性和行为
派生类/子类：特有的属性和行为
4、派生类既能访问自己的，也能访问超类，但是超类不能访问派生类的；
5、一个超类可以有多个派生类，一个派生类只能有一个超类----------单一继承
6、具有传递性
7、java规定：构造派生类之前必须先构造超类
1、在派生类的构造方法中若没有调用超类的构造方法，则默认super()嗲用超类的无参构造方法
2、在派生类的构造方法中若想自己调用超类的构造方法，则不再默认提供
super()调用超类构造方法，必须位于派生类构造方法的第一行
3、super： 指代当前对象的超类对象
super的用法：
1、super.成员变量名----------------访问超类的成员变量
2、super.方法名()----------------------调用超类的方法
3、super（）；--------------------调用超类的构造方法
1、向上造型
1、超类型的引用指向派生类的对象
2、 能点出生么，看引用类型--------------------规定
2、方法的重写（override/overriding） ：重新写
1、发生在父子类中，方法名相同，参数列表也相同
2、重写方法被调用时，看对象的类型，------规定
3、重写遵循“两同两小一大”原则： ----------------一般都是一样的
1、两同：
1、方法名相同
2、参数列表相同
2、两小：
1、派生类方法的返回值类型小于或等于超类方法的
1、void 和基本类型时，必须相同
2、引用类型时，小于或等于
2、派生类方法抛出的异常小于或等于超类方法的
3、一大：
1、派生类方法的访问权限大于或等于超类的方法
3、重写和重载的区别：常见面试题
1、重写（override） ；发生在父子类中，方法名相同，参数列表相同
2、重载（overload）：发生在同一类中，方法名相同，参数列表不同
补充：
1、向上造型的意义：-----实现代码的复用
1、当多种角色能干的事是一样的，可以将那么多种角色造型到超类数组中，统一访问
1、package和import
- package：声明包
- 避免类的命名冲突
- 通报中的类不能同名，但不同包中的类可以同名
- 类的全程：包名.类名
- 包名常常用层级结构，建议所有字母都小写
- import：导入类
- 同包中的类可以直接访问
- 不同包的类不能直接访问，若想访问
- 先import声明类，在访问类-
- 类的全程---------------太繁琐，不建议；
2、访问控制修饰符：-------------保护数据的安全
public：公开的，任何类
protected：受保护的，本类、派生类、同包类
默认的：什么也不屑，本类，同包类
private：私有的，本类
说明：
- 类的访问权限只能是public或者默认的
- 类中成员的访问权限如上4种都可以
- 访问全新由高到低：public>protected>默认的>privaate
3、final：最终的、不可改变的--------单独应用几率极低
- 修饰变量：变量不能被改变
- 修饰方法：方法不能被重写
- 修饰类：类不能被继承
4、static：静态的
静态变量：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据（图片、音频、视频）
静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法中没有隐式this传递，不能直接访问实例成员
- 何时用：方法的操作与对象无关
静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次
- 何时用：加载/初始化静态资源（图片、音频、视频）
补充：
1、数据（成员变量）私有化（private），行为（方法）大部分公开化（public）
2、成员变量分两种：
- 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过应用（对象）点来访问
- 静态变量：由static修饰，属于类的，存储在方法区中，只有一份，通过类名点来访问
3、内存管理：由JVM来管理
- 堆内存：new出来的对象（包括实例变量）
- 栈内存：局部变量（包括方法的参数）
- 方法区：.class字节码文件（包括静态变量、所有方法）
4、图片存储位置：点项目名称submarine，右键new一个Directory，命名为img，将图片复制进去
1、static final 常量:
- 必须声明同时初始化
- 类名点来访问，不能被改变
- 建议：常量名所有的字母都大写，多个单词用_分隔
- 何时用：数据永远不变，并且经常使用
2、抽象方法：
- 由abstract修饰
- 只有方法的定义，没有具体的实现（连{}都没有）
3、抽象类：
由abstract修饰
包含抽象方法的类必须是抽象类
抽象类不能被实例化（不能new对象）
抽象类是需要被继承的，需要有派生类；
- 重写所有的抽象方法----------变不完整为完整
- 也生命为抽象类-----------一般不用
抽象类的意义：
- 封装共有的属性和行为------------代码复用
- 为所有派生类提供统一的类型---------向上造型
- 可以包含抽象方法，为所有派生类提供统一的入口（能点出来），派生类的行为不同，但入口是一只的，同时相当于定义了一个标准（强制重写）
补充：
1、设计规则：
将共有的属性和行为，抽到超类中-----------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，则设计为抽象方法
若部分对象的属性和行为相同，抽到接口中，去实现就可以
2、抽象方法/抽象类的疑问：
抽象方法存在的意义：
保证当发生向上造型是，通过超类的引用能够点出来
既然意义只能在于点出来，那么为什么不涉及为普通方法：
若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写
-----------做了个标准，强制必须重写
1、成员内部类：应用率低
类中套类，外面的成为i外部类，里面的成为内部类
内部类通常只服务于外部类，对外不具备可见性
内部类对象通常在外部类中创建
内部类中可以直接访问外部类的成员（包括私有的）
内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this—API
2、匿名内部类：-------------大大简化代码
- 若想创建一个类（派生类）的对象，并且对象只被创建一次，可以做成匿名内部类
- 在匿名内部类中默认外面的变量为final的------这个是规定
- 面试题： 问：内部类有对立的.class文件吗？答：有
补充
1、隐式的引用
- this.：指代当前对象
- super：指代当前对象的超类对象
- 外部类名.this：指代当前对象的外部类对象
2、做功能的套路：
先写行为/方法：
- 若为某对象所特有的行为，则将方法设计在特定的类中
- 若为所有对象所共有的行为，则将方法设计在超类中
窗口调用：
- 若为定时发生的，则在定时器中调用
- 若为事件触发的，则在侦听器中调用
1、接口：
是一种引用数据类型
有interface定义
只能包含常量和抽象方法
接口不能被实例化（不能new对象）
接口是需要被实现的，实现类
– 必须重写所有的抽象方法
一个类可以实现多个接口，用逗号隔开，若又继承又实现时，应先继承后实现
接口可以继承接口
2、关系：
- 类和类-----------------继承 extends
- 接口与接口--------------继承extends
- 类和接口---------------实现implements
3、设计规则：
将所有派生类所共有的属性和行为，抽到超类中---------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法
将部分派生类所共有的属性和行为，抽到接口中
接口是对继承的单根性的扩展------------------实现多继承
4、接口的意义:
- 实现多继承
- 制定了一套标准，规则
多态：
意义：
同一类型的引用指向不同的对象时，有不同的实现----------所有抽象方法都是多态的
-行为的多态：cut()\getImage()\move()\
同一个对象被造型为不同的类型时，有不同的功能—所有对象都是多态的
----对象的多态，我、你、水……
向上造型/自动类转换：
- 超类型的引用指向派生类的对象
- 能点出来什么，看引用的类型
- 能造型成为的数据类型有：超类+所实现的接口
强制类型转化，成功的条件只有如下两种：
- 引用所指向的对象，就是该类型
- 引用所指向的对象，实现了该接口或继承了该类
强转时若不符合如上调解结案，则发生ClassCastException类型转换异常
建议在强转之前先通过instanceof判断引用的对象是否符合该类型
1、内存管理：由JVM来管理：
堆：
存储new出来的对象（包括实例变量）
垃圾：没有任何引用所指向的对象
垃圾回收器（GC）不定时到内存中清扫垃圾，回收过程时透明的（看不见的）
不一定一发现垃圾就立刻回收，通过条用System.gc()可以建议JVM尽快调度GC回收
实例变量的生命周期：
创建（new）对象时存储在堆中，对象被回收时一并被回收
内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的奔溃
建议：不再使用的对象应及时将引用设置为null
栈：
存储正在调用的方法中的局部变量（包括方法的参数）
调用方法时，会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量（包括方法的参数），方法调用结束时，栈帧被自动清除，局部变量一并被清除
局部变量的生命周期：
调用方法时存储在栈中，方法调用结束时与栈帧一并被清除
方法区：
- 存储.class字节码文件（包括静态变量，所有方法）
- 方法只有一份，通过this来区分具体的访问对象
2、面向对象的三大特征：
封装：
- 类: 封装的是对象的属性和行为
- 方法：封装的是具体的业务逻辑功能实现
- 访问控制修饰符：封装的是具体的访问权限，以保护数据的安全
继承：
作用：代码复用
超类：所有派生类所共有的属性和行为
接口：部分派生类所共有的属性和行为
派生类：派生类所特有的属性和行为
单一继承、多接口实现、具有传递性
多态
- 行为的多态：所有抽象方法都是多态的（通过方法的重写来实现）
- 对象的多态：所有对象都是多态的（通过向上造型来实现）
- 向上造型、强制类型转换、instanceof判断
基础API
3、String：字符串类型
- java.lang.String使用final修饰，不能被继承
- java中的String在内存中采取Unicode编码方法，任何一个字符占用两个字节的编码
- 字符串底层封装的是一个字符数组
- 字符串一旦创建，对象内容永远无法改变，的那字符串引用可以重新赋值----不变对象
4、常量池：
- java对字符串有一个优化措施：字符串常量池（堆中）
- java推荐我们使用字面量/直接量的方式来创建字符串，并且会花村所有以字面量形式创建的字符串对象到常量池中，当使用相同字面量再创建对象时将复用常量池中的对象以减少内存开销，从而避免内存中堆积大量内容相同的字符串对象
1、String：
- 面试题：
- String str = new String(“asdf”);
- 这个语句创建了几个对象？
- 两个，一个"asdf"字面量对象和一个String对象
2、String常用方法：
- length（）：获取字符串的长度（字符个数）
- trim（）：去除当前字符串两边的空白字符
- toUpperCase（）和toLowerCase（）：将当前字符串中的英文部分全部转化为大写或者小写
- startsWith（）和endsWith（）：判断当前字符串开始/结尾是否与给定字符串相同
- charAt（）：返回当前字符串指定位置上的字符
- indexOf（）和lastIndexOf（）：检索给定字符串在当前字符串中的开始位置，
- substring（）：截取当前字符串中指定范围内的字符串
- String的静态方法valueOf（）：将其他类型转换为String
3、StringBuilder类:
- 由于String是不变对象，每次修改内容要创建对象，因此String不适合做频繁的修改操作，为了解决这个我呢提，java提供了StringBuilder类
- StringBuilder是转为用于修改字符串的一个API，内部维护一个可变的char数组，修改都是在这个数组上进行的，修改速度、性能优秀，并且提供了一个修改字符串的常见方法：增、删、改、插
4、StringBuilder常用的方法：
- append（）：追加内容
- replace（）：替换部分内容
- delete（）：删除部分内容
- insert（）：插入内容
- reverse（）：翻转内容
补充
1、StringBuilder和StringBuffer：
- StringBuffer：是线程安全的，同步处理的，性能缓慢
- StringBuilder：非线程安全的，并发处理 的，性能稍快
1、正则表达式：
- 正则表达式是用来描述字妇产内容格式，使用它通常用来匹配一个字符串的内容是否符合要求
- 正则表达式语法：
2、String支持与正则表达式相关的方法：
- matches():使用给定的正则表达式验证当前字符串的格式是否符合要求
- spilt():将当前字符串按照满足正则表达式的部分进行拆分
- replaceAll()：将当前字符串中满足正则表达式的部分替换为给定的字符串
3、Object：对象/东西
- 是所有类的鼻祖，所有类都直接或间接继承了Object中有几个经常被派生类重写的方法：同String（）和equals()
- 调用toString()默认返回：类的全称@弟子，没有参考一i，所以常常重写equals()来比较具体的属性值
- 需要注意：java的类（String）以及重写了equals（）了，但我们自己定义的类必须自己重写equals()
- 派生类重写equals()的基本原则：
- 两个对象必须是同一个了欸i选哪个，若类型不同则返回false
- 若参数对象null，则返回false
- 原则上两个对象要比较对象的属性是否相同
- 派生类重写equals()的基本原则：
4、包装类：
- java定义了8个包装类，目的是为了解决基本类型不能直接参与面向对象开发的我呢提，是的基本类型可以通过包装类的实例以对象的方式存在
- 包括:Integet\Character\Byte\Short\Long\Float\Double\Boolean，其中Character和Boolean是直接继承自Object的，而其余6个包装类都继承自java.lang.Number
- JDK1.5推出了一个新的特性：自动拆装箱，该特性是编译器自动完成，当编译器编译时若发现由基本类型与包装类型相互赋值时，将会自动补充代码来完成他们的转换工作，这个过程称为自动拆装箱
进制简介
1、什么是2进制，逢2进1的计数规则，计算机中的变量/常量都是按照2禁止来运算的
2进制
- 规则：逢2进1
- 数字：0 1
- 基数：2
- 权：128 64 32 16 8 4 2 1
如何将2进制转换为10进制：
- 将一个2进制数每个1位置上的全职相加即可------------正数
2、什么是16进制：逢16进1的计数规则
16进制:
- 规则：逢16进1
- 数字：0 1 2 3 4 5 6 7 8 9 a b c d e f
- 基数：16
- 权：4096 256 16 1
用途:因为2进制书写太麻烦，所以常常用16进制来缩写2进制数字
如何缩写：将2进制从最低为开始，每4位2进制缩写为1位16进制