JAVA基础整理

java开发环境：

编译运行过程：
- 编译期：.java源文件，经过编译，生成.class字节码文件
- 运行期：JVM加载.class并运行.class(0和1)
> 特点：跨平台、一次编程到处使用

• 名词解释：
  • JVM：java虚拟机
    ​ 加载.class并运行.class
  • JRE：java运行环境
    ​ 除了包含JVM以外还包含了运行java程序所必须的环境
    ​ JRE = JVM+java系统类库(小零件)
  • JDK：java开发工具包
    ​ 除了包含JRE以外还包含了开发java程序所必须的命令工具
    ​ JDK = JRE+编译、运行等命令工具

    说明：

    1. 运行java程序的最小环境为JRE
    2. 开发java程序的最小环境为JDK
       IDEA：

• JetBrains公司的，分为社区版(免费的)和终级版(收费的)
• 开发步骤：
  • 新建Java项目/工程-------------------------小区
  • 新建Java包------------------------------------楼+单元
  • 新建Java类------------------------------------房子
• 注释：解释性文本(计算机不执行)
  • 单行注释：//
  • 多行注释：/* */-------------------明天才用
  • 文档注释：/** */------------------API时讲

补充：

1. IDE：集成开发环境，一套带图形界面的功能强大的工具，常见的有IDEA和Eclipse

2. Java以前是Sun公司，但是Sun已经被Oracle收购了，所以现在说java是Oracle公司的

3. Java是开源(开放源代码)的、免费的语言
   变量：
   存数的，代词，指代的就是里面的那个数

   • 声明：-------相当于在银行开了个帐户
   • 初始化/第一次赋值：-----相当于给帐户存钱
   • 使用：----使用的是帐户里面的钱
     • 对变量的使用就是对它所存的那个数的使用
     • 变量在用之前必须声明并初始化
   • 命名：
     • 只能包含字母、数字、_和$符，不能以数字开头
     • 严格区分大小写
     • 不能使用关键字
     • 允许中文命名，但不建议，建议"英文的见名知意"、“小驼峰命名法”
       八种基本数据类型：
       byte,short,int,long,float,double,boolean,char
   • int：整型，4个字节，-21个多亿到21个多亿
     • 整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
     • 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
     • 运算时若超范围，则发生溢出(溢出不是错误，但是需要避免)
   • long：长整型，8个字节，很大很大很大
     • 长整型直接量需在数字后加L或l
     • 运算时若有可能溢出，建议在第1个数字后加L
   • double：浮点型，8个字节，很大很大很大
     • 浮点数直接量默认为double型，若表示float需在数字后加F或f
     • double和float型数据参与运算时，有可能会发生舍入误差，精确场合不能使用
   • boolean：布尔型，1个字节
     • 只能存储true或false
   • char：字符型，2个字节
     • 采用Unicode字符集编码格式，一个字符对应一个码，
       表现的形式是字符char，但本质上是码int(0到65535之间)
       ASCII码：‘a’—97 ‘A’—65 ‘0’—48
     • 字符型直接量必须放在单引号中，有且仅有一个字符
     • 特殊符号需通过\来转义

类型间的转换：

基本类型由小到大依次为：
​ byte----short----int----long----float----double
char----

• 两种方式：
  • 自动/隐式类型转换：小类型到大类型
  • 强制类型转换：大类型到小类型

    语法：(要转换成为的数据类型)变量

    注意：强转有可能发生溢出或丢失精度

• 两点规则：
  • 整数直接量可以直接赋值给byte,short,char，但不能超出范围
  • byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算

补充：

1. 命名法：
   • 小驼峰命名法：第1个单词首字母小写，其余单词首字母大写 -----变量、方法(score,myScore)
   • 大驼峰命名法/帕斯卡命名法：所有单词首字母都大写-----------------类(Score,MyScore)
     2.数据类型分为：基本数据类型、引用数据类型

运算符、循环判断语句
1、算术：+，-，，/，%，++，–
2、关系：>，<，>=，<=，==，!=
3、逻辑：&&（短路与，都为真才真 ），||（短路或都为假才假），！
4、赋值：=，+=，-=，=，/=，%=
5、字符串连接：+
6、条件/三目：?
7、分支结构：基于条件执行某语句
8、if结构：1条路
9、if…else结构：2条路
10、补充：
&为不短路与，|为不短路或
任何复杂的程序逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句，并非每句必走

分支结构：
if…else if结构：多条路
switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
常见面试题：switch可以作用于什么类型的数据上
-------------------------byte,short,int,char,String,枚举类型
循环：反复多次执行一段相同或相似的代码
循环三要素：
循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
循环结构：
while结构：先判断后执行，有可能一次都不执行
do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
补充：
变量的作用域/范围：
从变量的声明开始，到包含它最近的大括号结束
生成随机数：
int num = (int)(Math.random()*1000+1); //1到1000

Math.random()--------------0.0到0.9999999999999999…
*1000----------------------0.0到999.99999999999999…
+1-------------------------1.0到1000.9999999999999…
(int)----------------------1到1000
任何复杂的程序逻辑都可以通过三种结构来实现：

顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句一次，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走

循环结构：

for结构：应用率高、与次数相关的循环
三种循环结构的选择规则：

先看循环是否与次数相关：
若相关----------------------------直接上for
若无关，再看要素1与要素3是否相同：
若相同------------------------直接上do…while
若不同------------------------直接上while
break：跳出循环
continue：跳过循环体中剩余语句而进入下一次循环
嵌套循环：
循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行过程：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
break只能跳出当前一层循环
数组：
是一种数据类型(引用类型)
相同数据类型元素的集合
定义：
初始化：给数组中的元素做初始化
访问：访问的是数组中的元素
通过(数组名.length)可以获取数组的长度(元素的个数)
通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
遍历/迭代：从头到尾挨个走一遍
补充：
变量的同名问题：
作用域重叠时，变量不能同名的
\t：水平制表位，固定占8位
ArrayIndexOutOfBoundsException数组下标越界异常
数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常

数组：
复制：
System.arraycopy(a,1,b,0,4);
int[ ] b = Arrays.copyOf(a,6);
排序：
Arrays.sort(arr); //升序排列(从小到大)
方法：函数、过程

封装一段特定的业务逻辑功能
尽可能的独立，一个方法只干一件事
方法可以被反复多次调用
减少代码重复，有利于代码复用，有利于代码维护
定义方法：五要素
​ 修饰词 返回值类型 方法名(参数列表) {undefined
​ 方法体--------------具体的业务逻辑功能实现
​ }
调用方法：
无返回值：方法名(有参传参);
有返回值：数据类型 变量 = 方法名(有参传参);
return：
return 值; //1)结束方法的执行 2)返回结果给调用方
​ ----------用在有返回值方法中
return; //1)结束方法的执行
​ -----------------用在无返回值的方法中
补充：
形参：形式参数，定义方法时的参数为形参
实参：实际参数，调用方法时的参数为实参

面向对象
1、什么是类？什么是对象？

现实生活中是由很多很多对象组成的，基于对象抽出了类
对象：软件中真实存在的单个个体/东西
类：类别/类型，代表一类个体
类是对象的模子，对象是类的具体的实例
类中可以包含：
对象的属性/特征-----------------------成员变量
对象的行为/动作-----------------------方法
一个类可以创建多个对象
如何创建类？如何创建对象？如何访问成员？
方法的重载(overload/overloading)：---------------更加方便用户的访问
发生在同一类中，方法名相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定方法
补充：
高质量的代码：---------------------以后的目标、拿年薪
复用性好、扩展性好、维护性好、可移植性好\健壮性好、可读性好、效率好…
默认值规则：
byte,short,int,long,char-------------0
float,double-------------------------0.0
boolean------------------------------false
引用类型------------------------------null
//若想访问对象，需要通过引用zs
引用
数据类型 引用类型变量 指向 对象
Student zs = new Student();
方法的签名：方法名+参数列表

构造方法：
构造函数、构造器、构建器---------复用给成员变量赋初值代码
作用：给成员变量赋初始值
与类同名，没有返回值类型(连void都没有)
在创建(new)对象时被自动调用
若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默认提供
构造方法可以重载
this：指代当前对象，哪个对象调用方法它指的就是哪个对象
​ 只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法：

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

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

this.方法名()-----------------调用方法(了解)

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

null：表示空，没有指向任何对象
若引用的值为null，则该引用不能进行任何点操作了，
若操作则发生NullPointerException空指针异常
内存管理

补充：
成员变量和局部变量是可以同名的：
----使用的时候默认采取就近原则
----若想访问成员变量，则this不能省略

内存管理：由JVM来管理的

堆：new出来的对象(包括成员变量)
栈：局部变量(包括方法的参数)
方法区：----------面向对象第五天讲
成员变量：写在类中，方法外--------有默认值
局部变量：方法中------------------------没有默认值

数组也是一个对象，所以数组对象也存储在堆中，
将数组的元素当作成员变量一并存储在堆中

引用类型数组：
与基本类型数组的区别：
给数组元素赋值必须new一下
若想访问对象数据必须通过数组元素打点
继承：
作用：代码复用
通过extends来实现继承
超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
派生类既能访问自己的，也能访问超类，但是超类不能访问派生类的
一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承
具有传递性
java规定：构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
super()调用超类构造方法，必须位于派生类构造方法的第1行

super：指代当前对象的超类对象
super的用法:

super.成员变量名---------------------访问超类的成员变量
super.方法名()-------------------------调用超类的方法--------------明天下午讲
super()-----------------------------------调用超类的构造方法

向上造型：
超类型的引用指向派生类的对象
能点出来什么，看引用的类型-------------这是规定，记住就行了
方法的重写(override/overriding)：重新写
发生在父子类中，方法名相同，参数列表相同
重写方法被调用时，看对象的类型-------这是规定，记住就行了
重写遵循"两同两小一大"原则：-----------了解，一般都是一模一样的
两同：
方法名相同
参数列表相同
两小：
派生类方法的返回值类型小于或等于超类方法的
void和基本类型时，必须相等
引用类型时，小于或等于
派生类方法抛出的异常小于或等于超类方法的-------------API时讲
一大：
派生类方法的访问权限大于或等于超类方法的-------------明天讲
重写与重载的区别：-----------常见面试题
重写(override)：发生在父子类中，方法名相同，参数列表相同
重载(overload)：发生在同一类中，方法名相同，参数列表不同
补充：
向上造型的意义：--------实现代码复用
当多种角色能干的事是一样的，可以将那多种角色造型到超类数组中，统一访问

package和import：

package：声明包
避免类的命名冲突
同包中的类不能同名，但不同包中的类可以同名
类的全称：包名.类名
包名常常用层次结构，建议所有字母都小写
import：导入类
同包中的类可以直接访问
不同包中的类不能直接访问，若想访问：
先import声明类，再访问类------建议
类的全称-----------------------------太繁琐，不建议
访问控制修饰符：--------------------------保证数据的安全
修饰符：
public：公开的，任何类
private：私有的，本类
protected：受保护的，本类、派生类、同包类
默认的：什么也不写，本类、同包类
说明：

• 类的访问权限只能是public或默认的
• 类中成员的访问权限如上4种都可以
• 访问权限由高到低依次为：public>protected>默认的>private

final：最终的、不可改变的------------单独应用几率极低

修饰变量：变量不能被改变
修饰方法：方法不能被重写
修饰类：类不能被继承
static：静态的

静态变量：
由static修饰
属于类，存储在方法区中，只有一份
常常通过类名点来访问
何时用：所有对象所共享的数据(图片、音频、视频等)
静态方法：
由static修饰
属于类，存储在方法区中，只有一份
常常通过类名点来访问
静态方法中没有隐式this传递，不能直接访问实例成员
何时用：方法的操作与对象无关
静态块：
由static修饰
属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次
何时用：加载/初始化静态资源(图片、音频、视频等)
补充：
数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
成员变量分两种：
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
通过引用(对象)点来访问
静态变量：由static修饰，属于类的，存储在方法区中，只有一份
通过类名点来访问
内存管理：由JVM来管理
堆：new出来的对象(包括实例变量)
栈：局部变量(包括方法的参数)
方法区：.class字节码文件(包括静态变量、所有方法)
图片存储位置：点项目名称submarine，右键New一个Directory，命名为img，将8张图片复制进去

static final常量：
必须声明同时初始化
类名点来访问，不能被改变
建议：常量名所有字母都大写，多个单词用_分隔
编译器在编译时会将常量直接替换为具体的数，效率高
何时用：数据永远不变，并且经常使用
抽象方法：
由abstract修饰
只有方法的定义，没有具体的实现(连{}都没有)
抽象类：
由abstract修饰
包含抽象方法的类必须是抽象类
抽象类不能被实例化(new对象)
抽象类是需要被继承的，派生类：
重写所有抽象方法-----------------变不完整为完整
也声明为抽象类---------------------一般不这么用
抽象类的意义：
封装共有的属性和行为---------------代码复用
为所有派生类提供统一的类型------向上造型
可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，
派生类的行为不同，但入口是一致的，同时相当于定义了一个标准(强制重写)
补充：
设计规则：
将共有的属性和行为，抽到超类中-------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法
将部分派生类所共有的属性和行为，抽到接口中
抽象方法/抽象类的疑问:
抽象方法存的意义是什么？
保证当发生向上造型时，通过超类的引用能点出来那个方法
既然意义只在于能点出来，那为什么不设计为普通方法呢？
若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写
----------做了个标准，强制必须重写

成员内部类：应用率低--------了解即可
类中套类，外面的称为外部类，里面的称为内部类
内部类通常只服务于外部类，对外不具备可见性
内部类对象通常在外部类中创建
内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this----API时会用
匿名内部类：-----------------------大大简化代码
若想创建一个类(派生类)的对象，并且对象只被创建一次，可以做成匿名内部类
在匿名内部类中默认外面的变量为final的----这是规定，记住就行了-----API时会用
面试题：问：内部类有独立的.class吗？ 答：有
补充：
隐式的引用：
this：指代当前对象
super：指代当前对象的超类对象
外部类名.this：指代当前对象的外部类对象
做功能的套路：
先写行为/方法：
若为某对象所特有的行为，则将方法设计在特定的类中
若为所有对象所共有的行为，则将方法设计在超类中
窗口调用：
若为定时发生的，则在定时器中调用
若为事件触发的，则在侦听器中调用

接口：
是一种引用数据类型
由interface定义
只能包含常量和抽象方法
接口不能被实例化(new对象)
接口是需要被实现/继承的，实现类/派生类：
----必须重写所有抽象方法
一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现
接口可以继承接口

多态：
意义：
同一类型的引用指向不同的对象时，有不同的实现--------所有抽象方法都是多态的
----行为的多态：cut()、getImage()、move()…
同一个对象被造型为不同的类型时，有不同的功能--------所有对象都是多态的(明天才能体会)
----对象的多态：我、你、水…
向上造型/自动类型转换：
超类型的引用指向派生类的对象
能点出来什么，看引用的类型
能造型成为的数据类型有：超类+所实现的接口
强制类型转换，成功的条件只有如下两种：
引用所指向的对象，就是该类型
引用所指向的对象，实现了该接口或继承了该类
强转时若不符合如上条件，则发生ClassCastException类型转换异常
建议在强转之前先通过instanceof判断引用的对象是否是该类型

内存管理：由JVM来管理的

堆：
存储new出来的对象(包括实例变量)
垃圾：没有任何引用所指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾，回收过程是透明的(看不到的)，
不一定一发现垃圾就立刻回收，通过调用System.gc()可以建议JVM尽快调度GC回收
实例变量的生命周期：
​ 创建(new)对象时存储在堆中，对象被回收时一并被回收
内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的崩溃
建议：不再使用的对象应及时将引用设置为null
栈：

存储正在调用的方法中的局部变量(包括方法的参数)

调用方法时，会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除

局部变量的生命周期：
​ 调用方法时存储在栈中，方法调用结束时与栈帧一并被清除
方法区：
存储.class字节码文件(包括静态变量、所有方法)
方法只有一份，通过this来区分具体的访问对象
面向对象三大特征：-------------敲黑板、重点之重点

面向对象三大特征
封装：
类：封装的是对象的属性和行为
方法：封装的是具体的业务逻辑功能实现
访问控制修饰符：封装的是具体的访问权限，以保护数据的安全
继承：
作用：代码复用
超类：所有派生类所共有的属性和行为
接口：部分派生类所共有的属性和行为
派生类：派生类所特有的属性和行为
单一继承、多接口实现，具有传递性
多态：
行为多态：所有抽象方法都是多态的(通过方法的重写实现的)
对象多态：所有对象都是多态的(通过向上造型来实现)
向上造型、强制类型转换、instanceof判断
String：字符串类型

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

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

String：
面试题：
/*
String s = new String(“hello”);
问:如上语句创建了几个对象?
答:2个
第一个:字面量"hello"
—java会创建一个String对象表示字面量"hello"，并将其存入常量池
第二个:new String()
—new String()时会再创建一个字符串对象，并引用hello字符串的内容
*/
String常用方法：
indexOf()和lastIndexOf()：检索给定字符串在当前字符串中的开始位置
length()：获取字符串的长度(字符个数)
trim()：去除当前字符串两边的空白字符
toUpperCase()和toLowerCase()：将当前字符串中的英文部分转为全大写/全小写
startsWith()和endsWith()：判断当前字符串是否是以给定的字符串开始/结尾的
charAt()：返回当前字符串指定位置上的字符------------------根据下标找字符
置
substring()：截取当前字符串中指定范围内的字符串
String的静态方法valueOf()：将其它数据类型转换为String
StringBuilder类：

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

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

补充：
StringBuilder和StringBuffer：--------现在不要纠结，我先写着，学完线程之后再来看就懂了
StringBuffer：是线程安全的，同步处理的，性能稍慢
StringBuilder：非线程安全的，并发处理的，性能稍快
getter/setter：
class Point{ //点
private int x;
private int y;

public int getX(){ //getter获取值
    return x;
}
public void setX(int x){ //setter设置值
    this.x = x;
}

public int getY(){
    return y;
}
public void setY(int y){
    this.y = y;
}

}

//getter和setter的演示
public class GetterSetterDemo {
public static void main(String[] args) {
Point p = new Point();
p.setX(100); //赋值
p.setY(200); //赋值
System.out.println(p.getX()+“,”+p.getY()); //取值
}
}

正则表达式：
正则表达式是用来描述字符串内容格式，使用它通常用来匹配一个字符串的内容是否符合要求
正则表达式的语法：-----------了解、不用纠结、不用深入研究
String支持与正则表达式相关的方法：
matches()：使用给定的正则表达式验证当前字符串的格式是否符合要求
split()：将当前字符串按照满足正则表达式的部分进行拆分
replaceAll()：将当前字符串中满足正则表达式的部分替换为给定的字符串
Object：
对象/东西
是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态
Object中有几个经常被派生类重写的方法: toString()和equals()
调用toString()时默认返回: 类的全称@地址，没有参考意义，所以常常重写toString()返回具体数据
调用equals()时默认比较的还是==(即比较地址)，没有参考意义，所以常常重写equals()来比较具体的属性值
需要注意：java提供的类都已经重写equals()了(String、StringBuilder)，但我们自己定义的类必须自己重写equals()
派生类重写equals()的基本规则:
1)两个对象必须是同一个类型，若类型不同则返回false
2)若参数对象为null，则返回false
3)原则上两个对象要比较对象的属性是否是相同
包装类：
java定义了8个包装类，目的是为了解决基本类型不能直接参与面向对象开发的问题，使得基本类型可以通过包装类的实例以对象的方式存在
包括：Integer、Character、Byte、Short、Long、Float、Double、Boolean。其中Character和Boolean是直接继承自Object的，而其余6个包装类都继承自java.lang.Number
JDK1.5推出了一个新的特性:自动拆装箱，该特性是编译器认可以，当编译器编译时若发现有基本类型与包装类型相互赋值时，将会自动补充代码来完成他们的转换工作，这个过程称为自动拆装箱
补充：
十进制的权：
个：10的0次幂-------1
十：10的1次幂-------10
百：10的2次幂-------100
千：10的3次幂-------1000
万：10的4次幂-------10000
二进制的权：
2的0次幂-------1
2的1次幂-------2
2的2次幂-------4
2的3次幂-------8
2的4次幂-------16
二进制转为10进制规则：所有为1的权相加就是10进制值
例如：
权: 32 16 8 4 2 1
二进制： 1 1 0 1 0 1
十进制：32+16+4+1---------------53

二进制

什么是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
面试题：
System.out.println(~100+1); 前面代码的运算结果是©：注:求100的补码
A.-98 B:-99 C:-100 D:-101
System.out.println(~-100+1); 前面代码的运算结果是©: 注:求-100的补码
A.98 B:99 C:100 D:101
位运算：

~：取反(0变1、1变0)
&：与运算(有0则0)
|：或运算(有1则1)

：右移位运算

<<：左移位运算
补充：
必须掌握的：
什么是2进制
什么是16进制、16进制存在的原因
2进制与16进制之间的换算
权: 64 32 16 8 4 2 1
1 1 0 0 1 0 0 = 100 右移位
1 1 0 0 1 0 = 50
1 1 0 0 1 = 25
1 1 0 0 = 12

权: 64 32 16 8 4 2 1
n 0 1 0 1 = 5
m 0 1 0 1 = 10
k 0 1 0 1 = 20

int n = 5;
int m = n<<2;
System.out.println(m); //20