JAVA编程语言-导图

JAVA编程语言基础语法知识总结，包括JAVA语言的特点、JAVA开发环境、数据类型、类和对象、输入输出等等。

JAVA

基础知识

JAVA语言的特点

面向对象

安全性

删除了指针和释放内存，避免非法内存操作

Java安全体系架构

平台无关性

JVM支持

支持多线程

内置多线程

内存管理

内存回收技术

要被回收的无用对象的定义： 1.当前代码段不属于对象的作用域 2.把对象的引用赋为空 即：对象变得不可达到

垃圾收集器(gc:garbage collector)

作为JVM的一个后台线程运行 在系统空闲时异步执行 当系统内存用尽时执行 调用System.gc()时执行 自动扫描对象的动态内存区， 对需要回收的对象标记并回收

finalize()方法

Object中有声明，类比C++析构函数 //需要释放出内存以外的资源需要重写finalize方法 //建议避免主动使用 protected void finalize() throws throwable{ }

JAVA开发环境

JDK 开发工具

基础类库（API）

即JAVA中自带的包 

JAVA编译器javac.exe

JAVA解释器java.exe

bin目录下

JRE 运行环境

配置环境变量时的CLASSPATH，文件在lib中

JVM（JAVA虚拟机）

用于实现跨平台性

JAVA核心类库

通常一起安装

JAVA程序的编译过程

1.编写.java文件 2.由java编译器javac.exe进行编译(Compiler)，生成.class文件(一种可以让JVM识别的指令，字节码文件) 3.由java解释器java.exe进行解释(Interpreter)、交由JVM运行程序

不同类型的JAVA平台

JAVA SE

Standard Edition（基础版）

JAVA ME

Micro Edition（用于手持设备和嵌入式设备的开发）

JAVA EE

Enterprise Edition（分布式开发，面向Web的企业级应用）

数据类型

基本数据类型

*值传递 *不初始化的基本数据类型 若是类的成员，会有缺省值 若是局部变量，不会有缺省值 缺省值表： 

数值型

整型默认 int 浮点型默认 double

整数类型(byte/short/int/long)

浮点类型(float/double)

字符型(char)

布尔型(boolean)

对应的有封装类对象，可自动装箱拆箱

引用数据类型

引用传递

数组

一维数组： type [] arrayName = new type[x]; 二维数组，每个数组可以不等长： type [][] arrayName = new type[x][y]; x可以为变量 系统会默认初始化

类

接口

内存划分

栈内存

储存基本数据类型和对象的引用变量

堆中的对象或数组的首地址赋给了栈中的引用变量

堆内存

储存new出来的对象实体

表达式与运算符

基本与C/C++类似

类型比较运算符：e instanceof Point

编译器会检查 待判断变量 是否能转换成右边的类型， 如果不能转换则直接报错， 如果不能确定类型，则通过编译，具体看运行时定

类型转换

Java类型转换包括： 自动类型转换（子集到超集，以占位多少为依据：如int->double，数值型） 显式类型转换（反之） 所以Java是强类型语言 而弱类型语言则是无论什么变量都可以相互转换

赋值转换

方法调用转换

强制转换

字符串转换

toString()函数显式转换

类和对象

类是对 对象的抽象

面向对象思想

抽象

数据抽象

属性

过程抽象

方法

封装

隐蔽信息 降低耦合度 易于程序的维护与修改

访问控制符

接口

受保护的内部实现

继承

提高代码的可重用性 默认继承（由JVM实现）：Object是所有类的祖先类

Java仅支持类的单继承

多态

同名的不同方法

方法重载 overload

一个类中有两个及以上同名的方法，但参数表不同 这些方法的签名（signature）不同

类的声明和使用

类的声明

[public] [abstract| final] class 类名称 [extends 父类名称] [implements 接口名称列表] { 变量成员声明及初始化； 方法声明及方法体； } *类的访问权限只有public和无修饰符两种 *一个.java文件只能有一个public类/公开接口（可以没有），且类名与文件名一致

数据成员

可以是Java中任意的数据类型 格式 [ public | protected | private ] [ static ][ final ][ transient ] [ volatile ] 变量数据类型 变量名1[=变量初值] , 变量名2[=变量初值], … ; *数据成员可以有自定义默认值 *static: 静态（不能修饰局部变量） *final: 终结 *transient: 瞬态 *voatile: 共享 *未定义访问权限时为default

实例变量

类变量（静态变量）

static修饰 可以用类名或对象名调用 类的所有对象共享一份 可以通过类名或者实例对象访问

方法成员

[ public | protected | private ] [static][final|abstract] [native] [synchronized] [<Type{,Type}>] 返回类型方法名([参数列表]) [throws exceptionList] { 方法体 } abstract: 抽象方法 native: 用来集成java代码和其他语言代码 synchronized: 控制多线程对共享数据的访问

按是否被static修饰

实例方法

类方法（静态方法）

static方法属于整个类 不能操作和处理实例变量 不能使用this和super 只能处理类变量/调用类方法

主方法

public static void main ( String[] args ) { //方法体 } 必须位于public类中 Java编译器通过主方法来执行程序 *静态/无返回值/形参为数组

其他特殊方法

不能按是否被static修饰而分类的方法 如构造方法，不能被static修饰，而又不同于一般的实例方法

构造方法

用于对象初始化 *与类同名 *无返回值 *未定义时，系统将提供默认构造方法（无参） *定义后，系统将不会提供任何默认构造方法 *通常声明为public *不能显式调用，由系统自动调用 无参构造函数的重要性： 若无该方法，则子类声明中必须含有构造方法，系统将不再提供默认构造方法 

this关键字

可用于在一个构造方法中调用另一个， 且必须是构造函数中的第一句 

访问控制权限

public: 任何类都可以访问 protected: 子类可访问（不在同包中的子类也可以） private: 其他类均不可访问 default（默认权限）: 包访问权限，同package就可以访问 

对象的声明与引用

仅仅声明引用变量“声明该变量将会存一个地址”时并没有生成对象 需要new出来 类名 变量名=new 类名()； *引用变量也可以被赋以空值

类的组织

包（Package）

不可嵌套 管理类名空间，解决类名冲突，相当于一个装类的文件夹 松散的类（编译单元）的集合 同包内类名不可重复

编译单元

一个Java源代码文件即为一个编译单元

所属包的声明

package xxx;

引入包的声明

import package1[.package2...].( classname |* ); 同包中的类可以相互引用，不必import

类和接口的声明

命名规则

包名必须独一无二 包名全小写 

包的声明

命名的包：package xxx; 默认包：不含有包声明的编译单元属于 default package （eclipse中）

枚举类型

声明： [public] enum枚举类性名称[implements接口名称列表] { 枚举值； //逗号隔开 变量成员声明及初始化； 方法声明及方法体； //构造方法必须为private修饰 } *枚举值使用toString()方法可以输出字符串 使用： 枚举类型名.枚举值 

方法

方法的控制流程

基本与C++相同

顺序结构

选择结构

循环结构

增强for循环

eg: for( int item : numbers ){ //循环体 }

break和label

public static void main(String[] args){ outer: for (int i=1; i<=9;i++) { for (int j=1; j<=9; j++){ if (j > i) break; if (i==6) break outer; System.out.print(" "+i+"*"+j+"="+i*j); } System.out.println(); } }

continue和label

和break/label使用格式一致

异常

异常和错误类的层次结构

Object-->Throwable

Error

由Java虚拟机生成并抛出，Java程序不处理Errors VirtualMachineError StackOverflowError OutOfMemoryError ......

Exception

由应用程序处理或输出

非检查型异常

RuntimeException 由系统检测，用户可不作处理 NullPointerException ArithmeticException IndexOutOfBoundsException NegativeArraySizeException ArrayIndexOutOfBoundsException ArrayStoreException ......

检查型异常

checked exception，需要用户处理 ClassNotFound DataFormat FileNotFoundException IOException ......

异常处理的方法

不处理将会抛至主方法中

抛出（throw）异常

消极的异常处理机制 抛出异常的方法需要在声明中写上 throws 异常类型名 子句

捕获（catch）异常

try {} catch (){ //常用方法 getMessage(); toString(); printStackTrace();//给出方法的调用序列，直到异常的产生位置 } finally{} *特殊异常放在一般异常前捕获

生成异常对象

实现：(异常对象必须是Throwable或其子类) throw new Throwable();

Java虚拟机生成

Java类库中的类生成

自定义异常类

public class MyExceptionName extends SuperclassOfMyException{ public MyExceptionName() { super("Some string explaining the exception"); } }

类的重用

继承

is-a 子类是父类的特殊化，Java只支持单继承 class childClass extends parentClass { //类体 } *子类访问父类中的成员可用super.

隐藏与覆盖

属性隐藏（hiding）

子类中有与父类中同名的变量 则从父类继承的变量将被隐藏 只有当执行从父类继承的操作才使用继承变量 （因而，子类也可修改父类的类变量） 属性不存在覆盖，只有引用对象决定

方法覆盖（overriding）

子类定义与从父类继承来的方法同名、同参的方法 覆盖方法的访问权限不能比被覆盖的严格 理解：原则上为了动态绑定、多态性 因为子类是父类的特殊化，是对父类的拓展，所以访问权限不能变小 eclipse:在函数前加@Override

抽象方法必须被覆盖

否则派生类也成了抽象类

final方法和static方法不可覆盖

同名static方法，父类中的将会被隐藏

覆盖方法和隐藏方法

覆盖方法由调用对象实体决定

隐藏方法调用由调用对象引用决定

有继承时的构造方法

构造方法无法被继承 子类构造方法的第一行必须.super调用父类的构造方法 （否则将调用父类的无参构造方法）

final

不可再变的

数据

不可修改，只能被赋值一次 （final 可以修饰局部变量，但static不行） 同时被static final修饰，表示类常量 static会‘给’该变量缺省值

类

不能被继承 如：String和Math

方法

不能被子类重写（覆盖） 提高安全性和正确性 提高运行效率：final方法将会被内联(inline) （方法体太长也会放弃内联） 类中的private隐式指定为final

abstract

抽象类

不能被实例化

抽象方法

只需声明“;” 不需方法体“{ }” *抽象类可以不含抽象方法 *抽象方法只能出现在抽象类中 *抽象方法必须在子类中被实现 （否则子类仍为abstract，无意义）

泛型（Generics）

类似C++模板： 声明： public class Box<T> { private T t; // T stands for "Type" public void add(T t) { this.t= t; } public Tget() { return t; } } 使用： Box<Integer>intBox = new Box<Integer>(); *有限制的泛型：public class Box<T extends Number>

泛型的继承

参考链接：https://www.cnblogs.com/lihaoyang/p/7104293.html

保留父类泛型

子类也为泛型

全保留

部分保留

不保留父类泛型

子类可以按需拓展为泛型 或不写成泛型，直接擦除泛型

具体类型替代

泛型擦除

类组合

has-a

Java基础类库简介

语言包( java.lang )

不需要import

Object类

Java所有类的祖先类

主要方法



getClass()

返回Class对象 不可重写

equals()

== 判断是否同一 （如果只需要判断相同，则可重写equals()方法）

相等

两个对象具有相同的类型，及相同的属性值

同一

两个引用变量指向同一个实体对象 （用 ' == ' 判断）

数据类型包裹类

为基本数据类型添加对应的类， 使基本数据类型可使用方法 用包裹类.valueOf(字符串)； //手动装箱：把字符串转为对应包裹类对象 用包裹类对象.intValue()； //手动拆箱，返回int基本数据类型 用包裹类.parseInt(字符串)； //手动拆箱，返回int基本数据类型 Java已支持自动拆/装箱 

String类

常量字符串：值和长度都不变化 构造方法  length()方法返回长度

StringBuffer类

可以修改的字符串，方法不可与String混用 比String效率更高 字符的个数：length 分配的存储空间：capacity 

chatAt(int index)

返回对应下标的字符

reverse()

append(Object ob)

将ob接到字符串后

字符串类

Math类

所有的变量和方法都是静态的(static) 是终结类

System类



Runtime类

Runtime run=Runtime.getRuntime(); run.totalMemory();  以字节为单位

系统和运行时类

Class类

getName()

getSuperclass()

ClassLoader类

提供把类装入运行时环境的方法

类操作类

实用包 ( java.util )

Date类

 Date类可以直接输出

Calendar类

抽象类，不能new， 使用getInstance()方法创建一个GregorianCalendar类的对象 Calendar c = Calendar.getInstance(); //返回子类对象

GregorianCalendar类

Calendar的派生类 

日期类

集合类

Java集合框架，第七章详细展开

Collection 无序集合

Set 不重复集合

List 有序不重复集合

Enumeration 枚举

LinkedList 链表

Vector 向量

Stack 栈

Hashtable 散列表

TreeSet 树

StringTokenizer类

建议用String中的split方法 

文本包( java.text )

Format类

DateFormat类

SimpleDateFormat类

 

JAR( Java Archive )

类似ZIP文件， 但JAR文件中包含了 META-INF/MANIFEST.MF文件 部署描述符 

可执行的JAR文件包

接口与多态

接口(interface)

形式上与类类似，但可以实现多继承 命名一般为able结尾 在UML图中用虚线表示接口关系 (理解为对象间的通讯协议，在对象之间架起通用的桥梁)

接口的语法

声明

[public|default] interface 接口名称[<Type{,Type}>][extends 父接口列表] { …//方法的原型声明或静态常量 } *可包含基本数据类型的数据成员，默认被public/static/final修饰，且必须赋值 *方法必须为抽象方法（可以省略public/abstract） *只规定方法声明，不规定方法体 （Java8之后用static修饰的方法可以规定方法体）

实现

不能new，只能利用实现该接口的类来创建对象 对象可以转型成其所属类实现的接口的类型 interfaceType interfaceName=(interfaceType) new ClassType|(); class 类名称 implements 接口名称 { /* Bodies for the interface methods */ /* Own data and methods. */ } *必须实现接口中的所有方法 *来自接口的方法必须声明成public

多重继承

一个类可以实现多个接口

接口的扩展

即接口的继承 *接口可以继承多个接口 *实现接口的类必须实现该接口的所有接口

多态(Polymorphism)

对不同类型的对象进行同样的操作 使程序具有可扩展性

塑型(type-casting)

广义而言，以下情况都算塑型： 类型转换 基本数据类型 引用变量

向上塑型

把子类对象赋值给父类类型的变量，或对象所属类的接口 是自动类型转换 从具体到一般，方法会变少

向下塑型

只有在该对象原本就是向上塑型的情况才能向下塑型（还原） 显式类型转换 从一般到具体 可用instanceof运算符进行判断

应用场合

赋值转换

方法调用转换

算术表达式转换

字符串转换

绑定(Binding)

类似C++的静态联编与动态联编 实现多态的机制 在Java中所有被重写的方法都称为虚方法

早期绑定

运行前

晚期绑定

动态绑定：运行时的虚方法调用 （有private,final,static修饰均不可被重写，不是虚方法，同理构造方法也不是虚方法）

输入输出

步骤： 打开一个读/写流 读/写信息 关闭读/写流 不关闭可能会导致缓冲流中的内容没有全部写入文件中 使用的基础类都在java.io中

输入输出流

按流向分

输入流

读

输出流

写

按分工分

节点流

直接连接数据源读写 从使用层面看，直接new出来就能用

处理流

链接到其他流，过渡作用，增强节点流的功能 从使用层面看，new的时候里面必须要套点东西

按内容分

所有的数据输入输出最后都归为字节流 字符流必须传入字节流作为参数才能使用 字符流算是上层建筑 字节流是地基

面向字节

处理字节，用于一般目的 只能读字节（数字）

InputStream



FileInputStream

PipedInputStream

多线程通过管道进行通讯

FilterInputStream

LineNumberInputStream

DataInputStream

BufferedInputStream

缓冲流的原理： 直接从硬件读取速度慢，从内存读取速度快 在内存中建立缓冲区，把硬件中的字节读取到内存中（并不是读了就用） 等待程序调用，再从内存的缓冲区读入程序 （好比水缸，单纯的点对点字节流用一次去水井打一次水， 用于缓冲的处理流是一个大水缸，先一次性装满，这样程序再读取时就不用 反复跑去水井“取水”了）

PushbackInputStream

ByteArrayInputStream

SequenceInputStream

StringBufferInputStream

ObjectInputStream

OutputStream



FileOutputStream

PipedOutputStream

FilterOutputStream

DataOutputStream

BufferedOutputStream

PrintStream

ByteArrayOutputStream

ObjectOutputStream

面向字符

处理字符 专门用于处理字符数据 实现内部格式和文本文件中的外部格式之间转换

Reader

BufferedReader

不能直接处理System.in

LineNumberReader

CharArrayReader

InputStreamReader

读取字节转换为字符

FileReader

FilterReader

PushbackReader

PipedReader

StringReader

Writer

BufferedWriter

CharArrayWriter

OutputStreamReader

FileWriter

FilterWriter

PipedWriter

StringWriter

FilterWriter

标准输入输出

System类的静态成员变量

System.in

是System的类变量，声明时为InputStream类（抽象类） 线程开始时将会被初始化为BufferedInputStream类实例 “setIn0(new BufferedInputStream(fdIn))” 所以可以调用read()等方法 键盘输入

System.out

PrintStream类，直接就可以用 屏幕输出

System.err

PrintStream类，标准错误信息输出流 屏幕输出

文件读写

读写二进制文件

用字节流 二进制文件：内容应被理解为出了字符以外的东西 （如图片、音乐......）

InputStream

抽象类

FileInputStream

FilterInputStream

DataInputStrean

遇到文件尾会抛出EOFException异常

readInt()

readDouble()

readBytes()

BufferedInputStream

OutputStream

抽象类

FileOutputStream

节点流

FilterOutputStream

DataOutputStream

处理流

writeInt()

writeDouble()

writeBytes()

BufferedOutputStream

用于在中间过程中缓冲

读写文本文件

文本文件：所有内容都应被解释为字符

Reader

BufferedReader

读到文件尾返回null

readline()

鉴别换行符

InputStreamReader

FileReader

read()

文件尾返回-1

Writer

BufferedWriter

newline()

用于换行

OutputStreamReader

FileWriter

FileWriter fw=new FileWriter(String fileName,boolean append)

write()

File类

用于操纵文件 

构造方法



常用方法



对象序列化

不保存对象的transient和static变量 因为序列化保存的是对象的状态，而非类的状态，也不是对象的临时状态 想要实现序列化的对象，其类必须实现Serializable接口 （该空接口用于标记作用）

ObjectInputStream

readObject()

有时需要显式类型转换

ObjectOutputStream

writeObject()

随机文件读写

文件中记录等长

RandomAccessFile

实现了DataInput和DataOutput接口 位置指示器指向当前读写处的位置 可同时支持读写操作 

int skipBytes(int n)

把文件指针向前移动n个字节

void seek(long)

移动文件指针到指定的位置

long getFilePointer()

得到当前的文件指针

read()

按字节读，文件尾返回-1

writeChar(int v)

写入一个字符/两个字节（Java采用Unicode编码，1字符=2字节）

对象群体的组织

数组

优点：支持随机访问，速度较快 缺点：创建后大小固定，每个元素类型相同

基本数据类型数组

对象数组

数组实用方法



集合（集合框架）

集合： 大小动态可变 可以存储不同类型的数据 Java中和集合有关的类和接口被组织起来 这种层次框架被称为集合框架（泛型实现） 作用类比C++ STL（容器/算法/迭代器）

数据结构与实现

Interfaces

集合的抽象数据类型（泛型）

Iterable

Collection

声明了查询方法和修改方法 查询方法：  修改方法： 

Set

元素不可重复，无序 重写了equals方法 包含同样元素的两个Set相等

SortedSet

元素升序排列的接口 通常用于存放类似词汇表的内容

List

可包含重复元素，有序索引

Queue

Map

键值对映射 双射，键不可重复 查询方法：  修改方法： put(Object key,Object val)

SortedMap

关键字升序排列的接口 通常用语词典和电话目录

Implementations

实现集合接口的Java类，可重用的数据结构

HashSet

TreeSet

实现SortedSet接口

Set

Vector

Stack

ArrayList

add()方法添加元素 get(i)获取下标为i的元素

LinkedList

List

ArrayList/Vector能存储任意对象 但不能存储基本类型（需要装箱） 只存储指定类型时可以将泛型确定 ArrayList<String>myList=new ArrayList<String>(); Vector同步且线程安全，但已不推荐使用 ArrayList非同步，效率高

ArrayDeque

PriorityQueue

Queue

HashMap

TreeMap

实现了SortedMap接口

Map

Algorithms

算法 大多数用于操作List对象

排序算法sort

对List进行排序 1.自然序 2.自定义Comparator对象

洗牌算法shuffle

用于List，打乱算法

数据处理算法

查找算法binarySearch

寻找最值

min

max

Iterator

（优于Enumeration接口，推荐使用） 迭代器接口，用于遍历集合 Iterator<ClassType>it=Object.iterator(); Object中存储的ClassType类型

hasNext()

判断是否还有元素

next()

取得下一个元素

remove()

从集合中去除Iterator当前（指向的）返回的元素

多线程

编程基础

线程和进程

进程（Process）

定义：独立程序的一次运行 进程间的通信较麻烦

线程 （Thread）

多线程：同一个进程中多段代码并发执行 线程间的通信较容易 Java是第一个内置多线程操作的主流编程语言

线程的实现

Thread类

创建多线程可以继承Thread类 位于java.lang包中，Thread类已经实现了Runnable接口 实用方法： 1.创建实例，调用start()方法即可 2.new Thread(多线程类).start()

构造方法

1.public Thread(); 2.public Thread(Runnabletarget); 法二会反复调用同一个实例的run()方法 方便实现多线程之间的数据共享 3.public Thread(Stringname) StringName为线程名

重写run()方法

在该方法中写入线程需要执行的语句

start()

调用，使线程开始执行 会自动调用run()方法

sleep(long millis)

让线程睡眠 millis 毫秒 Thread.sleep(n)默认让主线程休眠

yield()

暂停当前线程（放弃执行权） 放弃多久不一定

currentThread()

返回当前正在运行的线程对象

Runnable接口

创建多线程可以实现Runnable接口 接口中只含有一个run()方法 用于为已有基类的类生成多线程 （Java不支持多继承）

线程间共享

代码共享

多个线程的执行代码来自同一个类

数据共享

访问相同的对象 例如用同一个实现了Runnable接口的实例作为参数创建多线程 即可实现这些线程之间的数据共享

多线程同步控制

同步机制：监视器

互斥

同一时刻只有一个线程访问该共享数据 监视区：在同一时刻只能被一个线程执行的方法或代码

协作

允许别的线程在一定条件下进入监视区

synchronized

线程同步关键字

同步对象

使用：synchronized ( Object ) { 监视区代码段 } 机制： 1.判断对象锁旗标是否存在 存在就获得锁旗标 不存在进入等待状态，直至获得锁旗标 2.获得锁旗标后执行监视区代码 3.执行完毕后释放锁旗标

同步方法

用于互斥方法 使用：piblic synchronized void xxx(){} 两个方法同一时间只能有一个在执行 （不论有几个线程）

线程间通信

java.lang.Object类的一些方法

wait()

进入等待池，释放锁旗标 直到其他线程在对象x上调用notify()类方法才可能 再重新获得锁旗标（有时需要等待）继续执行，从wait()语句之后继续

notify()

随机唤醒一个等待池中的线程 本线程继续执行

notifyAll()

唤醒所有等待线程

后台线程（Daemon Thread）

又称“守护线程” 只要有前台线程，守护线程就不会结束 一旦没有前台线程，守护线程（无论是否执行完毕）都会结束 如：垃圾回收 调用Thread类的setDaemon(true)方法使线程变成守护线程

线程的生命周期

一个线程在任何时刻都处于某一种线程状态 

新建（New）

就绪（Runnable）

执行start（） 是一个瞬时状态

运行（Running）

阻塞（Blocked）

进入wait()池，主动调用wait() 进入lock()池，未获得锁旗标 休眠，主动调用sleep()

死亡（Dead）

线程优先级

线程调度

控制多个线程在同一个CPU上以某种顺序运行称为线程调度

固定优先级算法

优先级范围 [1,10]，值越大优先级越高，值相同顺序随机 每个线程的默认优先级为5 线程运行过程中创建的新线程与其具有相同的优先级 后台->后台 改变优先级setPriority(int priority)

线程暂停运行

具有更高优先级的线程就绪

调用某些特定方法

时间片的时间期满

其他tips

java中同名局部变量不存在屏蔽问题，只会报错

此特性与其他编程语言不同 如下例，会报错 int x=1; for(int x=0 ; x<5 ; x++){ }

位运算符

~

按位反

&

同真为真

|

按位或

^

按位异或

移位运算符

分类

>>

左移运算符

低位补零

左移n位相当于乘以2的n次方

<<

右移运算符

高位补高位

右移n位相当于除以2的n次方

>>>

无符号右移运算符

高位补零

tips

适用范围

整型和字符型

低于int将先自动升为int

a>>b=a>>(b mod 32)

移位不改变变量

背单词