20220324 java学习笔记总结-----第一阶段

语言基础：

 

1 java开发环境：

JVM:java虚拟机加载.class，并运行.class

JRE: java运行环境 JRE=JVM+java系统类库（小零件）

JDK：java开发工具包 JDK=JRE+编译、运行等命令

---------------------------------------------------------------------------------------------------------------------------------

2-1 变量：

变量使用前必须声明和初始化。

命名：只能包含字母、数字、_和$符，严格区分大小写，不能使用关键字，允许中文命名（不建议）

2-2 数据类型分为：基本（内置）数据类型和引用数据类型

2-3 八种基本类型：

1. byte :8位 1个字节 ，取值范围-128（-2^7）~127（2^7-1）

2.short：16位 2个字节，取值范围-32768（-2^15）~32767（2^15 - 1）

3.int:32位4个字节，取值范围-2,147,483,648（-2^31）~ 2,147,483,647（2^31 - 1）

4.long：64位8个字节，取值范围：-9,223,372,036,854,775,808（-2^63）~ 9,223,372,036,854,775,807（2^63 -1）

整数类型初始值为0；系统默认整数是int类型，long类型赋值需要加L

5.double 数据类型是双精度:64位8字节，精度 位数15位

6.folate数据类型是单精度32位4个字节，精度位数7位

浮点数类型默认值是0.0，系统默认浮点类型是double类型，folate类型赋值需要加F，double类型赋值也可以在数据后面加D

7.char 字符类型是一个单一的 16 位 Unicode 字符，2个字节,0~65535，单引号包裹

8.Boolean：布尔类型：8位1个字节，只要true、false。默认值是false

2-4 类型间的转换

2-4-1 自动转换：

1.不能对boolean类型进行类型装换

2.不能把对象类型转换成不相关类的对象

3.小转大自动转换

4.转换过程中可能造成损失精度

2-4-2 强制转换

1.浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

2.转换的数据类型必须是兼容的

---------------------------------------------------------------------------------------------------------------------------------

3 运算符

3-1 算术运算符：

+ 、-  、* 、/ 、  %  、 ++ 、 --（注：++或者--单独使用在前后都一样）

3-2关系运算符：

==   !=  >  < >=   <=

3-3位运算符

&  见0为0

|   见1为1

^   相同为0不同为1

~ 取反

<<   左移运算符

>>> 按位右移补零操作符（java特有，C/C++没有）

>> 按位右移运算符

相同数据左移位比右边移位后的结果大

3-4逻辑运算符（短路逻辑）

&& 逻辑与运算符，见假为假；

||  逻辑或操作符， 见真为真

！逻辑非运算符      取反

3-5赋值运算符：

= 、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、！=

3-6三目运算：

        boolean?true:false 

3-7运算符优先级

后缀<一元<乘性<加性<移位<关系<相等<按位与<按位异或<按位或<逻辑与<逻辑或<条件<赋值<逗号

() [] . (点操作符)<(++\-)<（* /％）<（+ -）<（>> >>>  << ）<（> >= < <= ）<（==  !=）<（＆）<（^）<（|）<（&&）<（| |）<（？：）<（= + = - = * = / =％= >> = << =＆= ^ = | =）<（，）

---------------------------------------------------------------------------------------------------------------------------------

4 分支结构

4-1 if 结构

一个if语句包含一个布尔表达式和一条路

4-2 if...else 语句

        当if语句的布尔表达式值为false时，else语句为会被执行

4-3 if ...else if.....else语句

一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

4-4 switch.....case结构

多条路，效率高、结构清晰

break ：跳出switch

作用于数据：byte、short、int、char、String、枚举

---------------------------------------------------------------------------------------------------------------------------------

5 循环结构：反复多执行一段相同或相似的代码

  循环的三要数：

1.初始化

2.条件

3.迭代

5-1 while循环   

先判断后执行，有可能一次都不执行

5-2 do....while循环

先执行后判断，至少执行一次，

5-3 for循环：

应用效率高、与次数相关的循环

5-4For-Each 循环

For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组和集合

5-5三种循环结构的选择规则

1.次数相关-----for

2.1、3相同------do ....while

3.1、2不同  -------while

---------------------------------------------------------------------------------------------------------------------------------

6 异常

 ArrayIndexOutOfBounds:数组下标越界异常
  NullPointerException:空指针异常
  ClassCastException:类型转换异常

---------------------------------------------------------------------------------------------------------------------------------

7 结束循环

break:跳出循环

continue:跳出循环中剩余语句而下一次循环

returm:结束方法

void：方法无返回值

---------------------------------------------------------------------------------------------------------------------------------

8 数组

1.数组是引用型数据

2.相同数据类型元素的集合

3.初始化：给数组中元素初始化

4.通过下标索引从0开始

5.遍历

①for(int i:i<arr.length;i++){

}

②for(int i:arr){

}

8-1数组的创建

int[] arr={1,2,3};

int[] arr=new int[5];

int[] arr=new int[]{1,2,3};

8-2数组方法

int binarySearch(Object[] a, Object key)：用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。

 boolean equals(long[] a, long[] a2)：如果两个指定的 long 型数组彼此相等，则返回 true

 fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

fill(int [] a,int fromIndex,int endIndex,int value);(不包括最后一个元素)

Arrays.soft(Object); //从小到大排序

Arrays.copyOf(object,length) 复制数组

---------------------------------------------------------------------------------------------------------------------------------

9 方法（函数、过程）

9-1方法简绍

1.封装一段特定的业务逻辑功能

2.尽肯能的独立

3.减少代码重复

4.方法可以重复使用

9-2五要素

9-2-1修饰符

public  对所有类可见

protected:同包类、派生类、当前类

default:当前类、同包类、

private：当前类

数据（成员变量）私有化（private），方法大部分公开化（public）

9-2-2参数类型

形参：形式参数，定义方法时的参数为形参

实参：实际参数，调用方法时用的参数为实参

注：通过值传递参数

9-2-3剩下三要素

返回值（void 和return）、方法名、方法体

---------------------------------------------------------------------------------------------------------------------------------

面向对象

1 类和对象、方法

1-1类和对象

对象：单个个体

类：具体一类个体

类是对象的模子，对象是类型的具体实例

对象的属性/特征------成员变量

对象的行为/动作-----方法

1-2变量的分类

局部变量：在方法、构造方法或者语句块中定义的变量称为局部变量，变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法之外的变量，这种变量在创建对象的时候实例化。成员变量可以被类中方法，构造方法和特定类的语句块访问。默认已经初始化

类变量：类变量也声明类中，在上面的例子中，方法体外，但是必须声明为static类型，类变量可以直接输出。

1-2-1变量的作用域：

1.变量的范围是程序中该变量可以被引用的部分

2.局部变量的作用范围从声明开始，直到包含它的块结束

3.方法的参数就是一个局部变量

1-3创建对象

对象是根据类的创建的，在java中使用new来创建一个新的对象，创建对象需要以下三步

1.声明：声明一个对象，包括对象名称和对象的类型

2.实例化，使用关键字new来创建一个对象

3.初始化：使用new创建对象时会调用构造方法初始化对象

1-4方法的重载（overload）：

1.发生在同一个类中，方法名相同，参数列表不同

2.编译器在编译时会自动根据方法的签名自动绑定。

3.不能仅仅依据修饰符或者返回类型的不同来重载方法。

---------------------------------------------------------------------------------------------------------------------------------

2 构造方法、this

2-1构造方法（构造函数、构造器、）：

1.给成员变量赋初始值

2.与类同名，没有返回值（连void都没有）

3.在创建（new）对象时被调用

4.若不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默认提供

5.构造方法可以重载

2-2 this：指代当前对象，那个对象调用方法方法他指的就是那个对象

只能在方法中，方法中访问成员变量之前默认有个this

2-2-1 this的用法：

this.成员变量----------访问成员变量

this.方法名（）------调用方法

this()-----------调用构造方法

注：成员变量与局部变量同名时，若想访问成员变量则this不能省略！

---------------------------------------------------------------------------------------------------------------------------------

3 引用型数组、继承、super

3-1 引用型数组

3-1-1 与基本类型数组的区别：

1.给数组元素赋值必须new一下

2.若想访问对象数据必须通过数组元素打点

3-2继承：

作用：代码复用

1.通过extends来实现继承

2.超类：共有的属性和行为

3.派生类：特有的属性和行为

4.派生类既能访问自己的，也能访问超类的，但超类不行

5.一个超类可以有多个派生类，一个派生类只能有一个超类-----单一继承

具有传递性

6.--在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

7.子类拥有父类非 private 的属性、方法

8.提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super（）调用超类的构造方法，必须位于派生类构造方法的第一行

3-3super：

指代当前对象的超类对象

3-3-1super的用法：

1.super.成员变量-------访问超类的成员变量

2.super.方法名（）-------访问超类的方法

3.super（）----------调用超类的构造方法

---------------------------------------------------------------------------------------------------------------------------------

4 向上造型、方法的重写

4-1向上造型

1.超类型的引用指向派生类的对象

2.能点出什么，看引用的类型

4-2方法的重写

1.发生在超类中，方法名相同，参数列表相同

2.重写方法被调用时，看对象的类型

4-2-1重写遵循“两同两小一大”原则：

1.两同：方法名相同，参数列表相同

2.两小：1.派生类方法的返回值类型小于或等于超类方法（void和基本类型必须相等、引用类型时，小于或等于）

 ----  2.派生类方法抛出异常小于或等于超类的

3.一大：派生类的方法的访问权限大于或等于超类的

返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类

父类的成员方法只能被它的子类重写

声明为 static 的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法

构造方法不能被重写。

---------------------------------------------------------------------------------------------------------------------------------

5 package 和import   static  和final

5-1package和import

5-1-1package:声明包

1.同包中的类可以直接访问，不同包的类不能直接访问

2.避免类的命名冲突

3.类的全称：包名.类名

4.包名常常用层次结构，建议所有字母都小写

5-1-2import：导入类

1.同包中的类可以直接访问，不同包的类不能直接访问，先import声明类

5-2static：静态的

5-2-1静态变量：

1.由static修饰

2.属于类，存储在方法区中，只有一份

3.类名点来访问

4.所有对象所共享的数据（图片、音频、视频）

5-2-2静态方法：

1.由static修饰

2.属于类。存储在方法区，只有一份

3.常常通过类名点来访问

4.静态方法没有隐式this传递，不能直接访问实例变量

5.静态方法操作与对象无关

5-2-3静态块

1.由static修饰

2.属于类，在类被加载期间自动执行，一个类只能被加载一次，所以静态块之执行一次

3.加载/舒适化静态资源（图片、音频、视频）

5-3 final：最终的、不可变的

1.修饰变量：变量不能再改变

2.修饰方法：方法不能被重写

3.修饰类：类不能被继承

---------------------------------------------------------------------------------------------------------------------------------

6 static final常量 、抽象方法、抽象类

6-1static final常量

1.必须声明同时初始化

2.类名点来访问，不能改变

3.建议：常量名所有字母都要大写，多个单词用_分割

4数据不变，并且经常使用

6-2抽象方法

1.abstract修饰

2.只有方法的定义，没有具体实现

6-3抽象类

1.由abstract修饰

2.包含抽象方法必须是抽象类

3.抽象类被继承抽象方法需要被重写

抽象类的意义：

封装共有的属性和行为

为派生类提供统一的类型-------向上造型

6-4抽象类方法总结

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

---------------------------------------------------------------------------------------------------------------------------------

7 成员内部类、匿名内部类

7-1成内部类：

1.类中套类

2.内部类通常只服务外部类，对外不具可见性

3.内部类中可以直接访问外部类的成员包括私有的

内部类中有一个隐式的引用指向了创建它的外部类对象：外部类.this

7-2匿名内部类：

1.若想创建一个类（派生类）的对象，并且对象只能被创建一次

2.在匿名内部类中默认外面的变量为final的

---------------------------------------------------------------------------------------------------------------------------------

8 接口

1.是一种引用型数据类型

2.由interface定义

3.接口不能实例化

4.只能包含常量和抽象方法

5.接口需要被实现/基础的，抽象方法必须重写

6.一个类可以实现多个接口

7.接口可以实现接口

8-1接口与类相似点：

1.一个接口可以有多个方法。

2.接口文件保存在 .java 结尾的文件中，文件名使用接口名。

3.接口的字节码文件保存在 .class 结尾的文件中。

4.接口相应的字节码文件必须在与包名称相匹配的目录结构中。

8-2接口与类的区别：

1.接口不能用于实例化对象。

2.接口没有构造方法。

3.接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

4.接口不能包含成员变量，除了 static 和 final 变量。

5.接口不是被类继承了，而是要被类实现。

6.接口支持多继承。

8-3抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

---------------------------------------------------------------------------------------------------------------------------------

9 多态

9-1意义：

1.所有抽象方法都是多态的

2.所有对象都是多态的

9-2向上造型/自动转换

1.超类类型的引用指向派生类的对象

2.能点出来什么，看引用的类型

3.能造型成为的数据类型有：超类+所实现的接口

9-3强制装换：

1.引用所指向的对象，就是该对象

2.引用所指向的对象，实现了该接口或继承了该类

建议：强转之前先通过instanceof判断引用的对象是否是该类型

9-4多态的优点

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

9-5多态存在的三个必要条件

继承

重写

父类引用指向子类对象：Parent p = new Child();

---------------------------------------------------------------------------------------------------------------------------------

10内存管理：JVM来管理

10-1.堆

1.存储new出来的对象（包括实例变量）

2.垃圾：没有任何引用所指向的对象

垃圾回收器（GC）不定时到内存中情理垃圾，回收过程是透明的（看不到的）

3.创建（new）对象时存储在堆中，对象被回收一并回收：生命周期

4.内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的崩溃

建议：不再使用的对象应及时将引用设置为null

10-2.栈

1.存储在调用周期的局部变量（包括方法的参数）

2.调用方法时，会把栈中该方法分配一块对应的栈帧，栈帧 中存储局部变量（包括方法的参数），方法调用结束时，栈帧被自动清楚，局部变量一并被清楚

10-3.方法区

存储.class字节码文件（包括静态变量、所有方法）

方法只有一份，通过this来调用

10-4.常量池

1.java对字符串有一个优化措施：字符串常量池(堆中)
2.java推荐我们使用字面量/直接量的方式来创建字符串，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相同字面量再创建对象时将复用常量池中的对象以减少内存开销，从而避免内存中堆积大量内容相同的字符串对象

---------------------------------------------------------------------------------------------------------------------------------

API基础+二进制

1 String 常用方法、 StringBuilder

1-1string：字符串类型

1.java.lang.String使用final修饰，不能被继承
2.java中的String在内存中采用Unicode编码方式，任何一个字符占用两个字节的编码
字符串底层封装的是一个字符数组
3.字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值------不变对象

1-2String常用方法

(一)String(char[])
写法1：char a[]={'g','o','o','d'};
String s=new String(a);
等价于：
String s=new String("good");
 
(二)String(char a[], int offset,int length)
offset:表示开始截取字符串的位置，
length:表示字符串的长度。
写法一：
char a[]={'s','t','u','d','e','n''t'};
String s=new String(2,4);
等价于
String s=new String("uden")
 
String substring(int start,int end);
 
(三)两种查找字符串的方法
1.indexOf():搜索的字符首次出现的位置
2.lastIndexOf():搜索字符串最后一次出现的位置
 
(四)字符串截取 
1.substring(int beginIndex):从指定的索引位置开始截取直到该字符串结尾的子串。
2.substring(int beginIndex, int endIndex):从字符串某一索引位置开始截取至
           某一索引位置结束的子串。
(五)去除空格
trim():返回字符串的副本，忽略前导空格和尾部空格。
(六)字符串替换
replace():实现指定字符串替换成新的字符或字符串
(七)判断字符串的开始与结束是boolean
1.startsWith():判断当前字符串对象的前缀是否为指定字符串。
    prefix:前缀的字符串
2.endsWith():该方法判断当前字符对象的后缀是否为指定字符串。
    suffix:后缀字符串
(八)判断字符串是否相等
1.equals():如果两个字符串的长度和具有相同的字符，输出true;

2.equalslgnoreCase()忽略大小写
(九)安装字典顺序比较两个字符串
compareTo():按照字典顺序比较两个字符串，基于unicode值
(十)字母大小写转换
toLowerCase()：将大写字母转成小写字母
toUpperCase():将小写字母转换成大写字母
(十一)字符串分割，分割符|
1.split(String sign):sign为分割字符串的分割复，也可以使用正则表达式
2.split(String sgin,int limit):给定的分割符对文字进行拆分，并且限制次数。
(十二)日期和时间字符串格式化
①日期格式化
Date date=new Date();
String s=String.format("%te",date);0

（十三）String的静态方法valueOf()：将其它数据类型转换为String

1-3 StringBuilder

由于String是不变对象，每次修改内容要创建新对象，因此String不适合做频繁修改操作，为了解决这个问题，java提供了StringBuilder类。
StringBuilder是专门用于修改字符串的一个API，内部维护一个可变的char数组，修改都是在这个数组上进行的，修改速度、性能优秀，并且提供了修改字符串的常见的方法：增、删、改、插

1-4StringBuilder常用方法：

append()：追加内容
replace()：替换部分内容
delete()：删除部分内容
insert()：插入内容
reverse()：翻转内容

补充：

StringBuilder和StringBuffer：
StringBuffer：是线程安全的，同步处理的，性能稍慢
StringBuilder：非线程安全的，并发处理的，性能稍快

---------------------------------------------------------------------------------------------------------------------------------

2 正则表达式、object 、包装类

2-1正则表达式

1.正则表达式定义了字符串的模式。

2.正则表达式可以用来搜索、编辑或处理文本。

3.正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

4.Java 正则表达式和 Perl 的是最为相似的

2-1-1java.util.regex 包主要包括以下三个类

Pattern 类：

pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher 类：

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

PatternSyntaxException：

PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

2-1-2正则表达式语法：

[]:表示一个字符,该字符可以是[]中指定的内容
例如:
[abc]:这个字符可以是a或b或c
[a-z]:表示任意一个小写字母
[a-zA-Z]:表示任意一个字母
[a-zA-Z0-9_]:表示任意一个数字字母下划线
[^abc]:该字符只要不是a或b或c

预定义字符:
.:表示任意一个字符,没有范围限制
d:表示任意一个数字,等同于[0-9]
w:表示任意一个单词字符,等同于[a-zA-Z0-9_]
s:表示任意一个空白字符
D:表示不是数字
W:不是单词字符
S:不是空白字符

量词:
?:表示前面的内容出现0-1次
  例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
+:表示前面的内容最少出现1次
  例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcbabcbabbabab....
        但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
*:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
  例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcbabcbabbabab....或什么也不写
        但是不能匹配:abcfdfsbbaqbb34bbwer...
{n}:表示前面的内容出现n次
  例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
        但是不能匹配: aaaa 或 aad
{n,m}:表示前面的内容出现最少n次最多m次
  例如: [abc]{3,5} 可以匹配:aaa 或  abcab 或者 abcc
        但是不能匹配:aaaaaa 或 aabbd
{n,}:表示前面的内容出现n次以上(含n次)
  例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcbabcba....
        但是不能匹配:aa 或 abbdaw...
()用于分组,是将括号内的内容看做是一个整体
  例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
        但是不能匹配aaa 或abcabc
        (abc|def){3}表示abc或def整体出现3次.
        可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
        但是不能匹配abcdef 或abcdfbde

 

2-2object

是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态
Object中有几个经常被派生类重写的方法: toString()和equals()
调用toString()时默认返回: 类的全称@地址，没有参考意义，所以常常重写toString()返回具体数据
调用equals()时默认比较的还是==(即比较地址)，没有参考意义，所以常常重写equals()来比较具体的属性值
需要注意：java的类(String)已经重写equals()了，但我们自己定义的类必须自己重写equals()
派生类重写equals()的基本规则:
1)两个对象必须是同一个类型，若类型不同则返回false
2)若参数对象为null，则返回false
3)原则上两个对象要比较对象的属性是否是相同

2-3包装类

java定义了8个包装类，目的是为了解决基本类型不能直接参与面向对象开发的问题，使得基本类型可以通过包装类的实例以对象的方式存在
包括：Integer、Character、Byte、Short、Long、Float、Double、Boolean。其中Character和Boolean是直接继承自Object的，而其余6个包装类都继承自java.lang.Number
JDK1.5推出了一个新的特性:自动拆装箱，该特性是编译器认可以，当编译器编译时若发现有基本类型与包装类型相互赋值时，将会自动补充代码来完成他们的转换工作，这个过程称为自动拆装箱

---------------------------------------------------------------------------------------------------------------------------------

3 二进制

什么是2进制：逢2进1的计数规则，计算机中的变量/常量都是按照2进制来运算的

2进制：
规则：逢2进1
数字：0 1
基数：2
权：128 64 32 16 8 4 2 1
如何将2进制转换为10进制：
将一个2进制数每个1位置的权值相加即可----------正数
什么是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进制
补码：

计算机中处理有符号数(正负数)的一种编码方式，java中的补码最小类型是int，32位数
以4位2进制为例讲解补码的编码规则：
计算的时候如果超出4位数就自动溢出舍弃，保持4位数不变
将4位2进制数分一半作为负数使用
最高位称为符号位，高位为1是负数，高位为0是正数
深入理解负值：
记住-1的编码是32个1
负值：用-1减去0位置对应的权值
互补对称：
结论：一个数的补码=这个数取反+1(取反+1) 公式: -n=~n+1
6的补码=6取反+1
-3的补码=-3取反+1