目录
简单代码分析
利用JDK熟悉Java程序执行过程
流程图解
具体操作
类型
java中的基本数据类型和所提供的包装类
int（整型）
long（长整型）
double（双精度类型）
char（字符类型）
byte（字节类型）
short（短整型）
boolean（布尔类型）
String（字符串类型）
变量
局部变量
类型转换
整型变量的赋值
byte类型相加
两种类型变量相加
总结
利用包装类实现int 和String的转换
算术运算符
1.除法
2 .取余（求模）
复合运算符
自增自减运算符
关系运算符
逻辑运算符
&& 和||和！
位运算符
按位与（&）
按位或（|）
按位异或（^）
按位取反（~）
1,1->0">二进制位按位取反，0->1,1->0
进制转换（计算时候需将其他进制形式转为2进制）
移位运算
左移运算符（<<）
>）">右移操作符（>>）
>>）"> 无符号右移（>>>）
条件运算符（三目运算符）
简单代码分析
利用JDK熟悉Java程序执行过程
流程图解
JDK包含了JRE和JVM，三者的关系如下：
具体操作
1.用记事本复制一段简单代码保存后将其后缀改成.java,后在SublimeText3中可以看到以下场景
2.再利用命令提示符应用在已配置JDK的情况下用命令语句将.java文件编译成.class文件
①命令提示符应用打开：
②在命令提示符应用的窗口打开.java所在的文件，做法：cd+空格+所在地址+回车
注意：当文件地址不在默认的C盘，需要打开文件具体的储存的盘，入D盘，做法：d:+回车
③将.java文件编译为.class文件即二进制文件，做法：javac+空格+完整文件名+回车
④ 编译运行.class文件，做法：java+空格+文件名（无需后缀）+回车
注意：每次修改.java文件代码需要保存，然后在重新编译为.class再重新编译运行
类型
java中的基本数据类型和所提供的包装类
1.在Java中有8种基本数据类型，分别是byte,short,int,long,float,double,boolean,char.
2.Java为这8种基本数据类型提供了8种包装类，分别是Byte,Short,Integer,Long,Float,Double,Boolean,Character;除了int和char的包装类写法稍有不同，其余的只需首字母大写。
int（整型）
1.不管是多少位的操作系统，int的大小为4个字节（16个bit）。
2.Java当中，int没有所谓的无符号类型，统一为有符号类型。
3.int能表示的范围可以利用其包装类输出，因为其位4个字节32个bit，故数值储存为
所以能取到的取值范围为-2^31~2^31-1
在内存中的反码其最大值和最小值相差1，所以Integer.MAX_VALUE+1和Integer.MIN_VALUE-1
会和原先的最大值和最小值相反
4.变量的命名：小驼峰(maxNum),由数字 字母 下划线 美元符号 组成，不能以数字开头
long（长整型）
1.大小为8个字节（64bit）
2.long可取到的范围类别int类型，为-2^63~2^63-1
3.定义long类型变量初始化时，应该在其末尾加l或者L，如：long a = 10L
4.注意：Java中不存在long long类型
double（双精度类型）
1.大小为8个字节
2.定义方法:double a = 1.0
3.double类型数据在内存中存储遵循IEE754标准
4.float a =12.5,这样定义程序会报错，因为Java语言中12.5会默认为一个double数据类型，将double类型赋值给float类型会报错，正确的定义方法为float a=12.5f
char（字符类型）
1.大小不同于C语言的一个字节，大小为2个字节.
2.char类型可以内容为文字的变量
3.char类型同过ASCII码值解析打印其字符
byte（字节类型）
1.大小为1个字节（8bit）。
2.能够取到的范围-128~127
short（短整型）
1.大小为2个字节（16个bit）。
2.可取得的范围-2^15~2^15-1
boolean（布尔类型）
1.Java中boolean的只要两个取值分别为true和false，不能有其他的取值。
2.boolean类型和int类型不能相互转换，不存在1表示true，0表示false。如下列编译会产生错误：
3.在JVM的规范中，没有明确规定boolean类型大小，有些资料会资料会记载大小为1bit或者1字节。
String（字符串类型）
1.不属于8种基本的数据类型，属于引用类型
2.定义方法：string str = "hello world";
判断类型是否为引用类型可通过看定义的变量里是否存储地址
3.字符串用+拼接
System.out.println("hello"+"world");//拼接，会和为一个字符串
System.out.println("hello"+10+20);//其他数据类型和字符串使用拼接，结果为字符串hello1020
System.out.println("hello"+(10+20));//加上括号拼接，结果就会为字符串hello30
System.out.println(10+20+"hello");//30和hello拼接，再全部转换为字符串为30hello
System.out.println(10+""+20+"hello");//10先与""结合变为字符串类型与20与"hello"拼接结果为字符串
4.利用转义字符保留想打印的内容
System.out.println("bit");//直接打印bit
System.out.println(""bit"");//"将引号转义保留，会打印"bit"
System.out.println("\bit\");//结果会打印bit,\将转义保留
System.out.println("\\bit\\");//结果会打印\bit\,\会保留一个
5.常见的转义字符
n 换行 t 水平制表符 ' 单引号 " 双引号 \ 反斜杠
变量
局部变量
1.找变量的作用域需找花括号，如：
int a = 10;
{
a = 99;
}
System.out.println(a);
此时，打印的结果为99.
2.变量的定义过程中需做到合法合理，变量名包含数字，字母，下划线和$，但是不能以数字开头。
3.用final定义的变量为常量，类比与C语言的const。变量在程序运行时可以发生修改，而常量一般建议书写为大写，在程序运行时不发生改变，如：
final int A = 10;
{
A = 99;
}
System.out.println(A);
A为常量，其值无法修改，此时程序会报错
4.常量和变量的值确定的时间也不相同，常量在编译时值就以确定，而变量在编译时才确定值
类型转换
整型变量的赋值
1.小整型给大整型：
int b = 10;
long l = b;
System.out.println(l);
int类型的b赋值为10，后将其给long，编译结果为10，说明大整型可以存放小整型
2.大整型给小整型
long c = 10;
int s = c;
因为将一个8字节的整型放到4字节的整型中，此时代码会报错。即使数值放得下，但在运行过程中是将c放到s中，并不知道c的大小，所以会提前报错。
long c = 1111111111111111111L; int s = (int)c;
若将long类型的变量强制类型转换给int会通过，但存在风险，会造成数据丢失
byte类型相加
byte a = 10;
byte b = 20;
byte c = a + b;
这种情况下，代码会报错。原因：在计算的类型小于4个字节时，都会将此类型提升为int类型，即a，b提升为int类型将其给byte类型会报错。
正确做法是：
byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
注意：short类型为2个字节，同理算术计算结果应该强制类型转换。但在进行强制类型转换过程中会导致精度丢失
两种类型变量相加
int i1 = 10;
long i2 = 20;
int i3 = i1 + i2;
此时，代码会报错，int类型i1和long类型i2相加时，也会发生类型转换，转换为long类型；将long类型的值放到int类型中会报错。
正确做法是：
int i1 = 10; long i2 = 20; int i3 = (int)(i1 + i2);
但同样存在风险。
总结
所有的类型提升的目的是什么？
原因：为了提高效率。由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算.
利用包装类实现int 和String的转换
1.int类型转换为String类型
String str = "123"; int ret = Integer.valueOf(str); System.out.println(ret);
其中Integer为int的包装类，利用valueOf(str)将字符串"123"转换为整型123.
2.String类型转换为int类型
int ret2 = 123; String str2 = String.valueOf(ret2); System.out.println(str2);
String为String类型的包装类，利用valueOf(int)将整型123转换为字符串"123".
算术运算符
1.除法
int a = 1;
int b = 2;
System.out.println(a/b);
int a = 1;
int b = 2;
System.out.println(a/b);
以上代码运行结果没有精确到小数，故结果为0
int a = 10;
int b = 0;
System.out.println(a/b);
除法运算中，除数不能为0，所以以上带码运行时会报错
2 .取余（求模）
1.
int a = 12;
int b = 5;
System.out.println(a%b);
以上代码，运行结果为2
2.除了对整型数据求模，也能对double型数据求模，代码如下：
System.out.println(11.5%2);
代码运行结果为1.5
3.正数和负数之间也可进行取模运算
System.out.println(-10%3); System.out.println(-10%-3); System.out.println(10%-3);
以上代码求得结果为-1，-1和1
复合运算符
符合运算过程中会自动进行强制类型转换
short s = 10;
s = s + 2;//这句代码会报错，因为s+2会默认整型转换为int型，给short类型的s发生错误；正确写法：s = (short)(s + 2)
s += 2;//这句代码不会报错，因为符合运算符在运行过程中会自动进行强制类型转换
自增自减运算符
int a = 10;
int i1 = a++;//10
int b = 20;
int i2 = ++b;//11
以上代码中i1=a++，先用了a的值后在a++，所以值不变；i2=++b，先++b后使用了b的值，所以值会加1
总结：
1. 如果不取自增运算的表达式的返回值, 则前置自增和后置自增没有区别.
2. 如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值.
关系运算符
1.关系运算符包括== != < > <= >=
2.关系运算符的结果都为一个布尔类型的值
int a = 10;
int b = 20;
System.out.println(a == b);
System.out.println(a != b);
System.out.println(a < b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a >= b);
以上代码段，运行返回结果都为布尔类型的值分别为false true true flase true flase
逻辑运算符
&& 和||和！
1.(表达式1 && 表达式2)，这个两个表达式全为布尔表达式，两个表达式都为真，整个表达式结果为真。断路：当表达式1为假时，不会执行表达式2
2.（表达式1 || 表达式2），这两个表达式也全为布尔表达式，只要有一个表达式为真，整个表达式结果为真。短路：当表达式1为真时，不会执行表达式2
3.！+布尔表达式，！false=true，！true=false
位运算符
位运算符表示对二进制位计算，计算机中都是用二进制来表示数据（01构成的序列），按位运算就是按二进制的每一位进行计算
//以字节类型的a和b为例，按位运算
byte a = 10;//0000 1010
byte b = 11;//0000 1011
按位与（&）
如果二进制位的对应位都为1，结果为1
按位或（|）
如果二进制位的对应位只要有1，就为1；没1，为0
按位异或（^）
二进制位对应位，相同为0，不同为1
按位取反（~）
二进制位按位取反，0->1,1->0
进制转换（计算时候需将其他进制形式转为2进制）
进制转换（计算时候需将其他进制形式转为2进制）
移位运算
分别位<< >> >>>三种,按照二进制位运算
//以字节类型的b为例，进行移位运算
byte b = 11;//0000 1011
左移运算符（<<）
移法：最左侧的数字舍去，最右侧每一次补0
假设2进制位代表的数字是N，移动的位数为n，则结果为N*2^n
右移操作符（>>）
移法：最右侧的数字舍去，最左侧每一次补符号位（0/1）
无符号右移（>>>）
移法：最右侧的数字舍去，最左侧每一次统一补0
条件运算符（三目运算符）
Java当中唯一的三目运算符，形式为：表达式1?表达式2:表达式3其中表达式1为布尔表达式，结果为true或false。
当表达式1结果为true时，结果为表达式2的值；当表达式1结果为false时，结果为表达式3的值。
int a = 10;
int b = 20;
int c = a > b ? a : b;
System.out.println(c);
以上代码，a>b为布尔表达式，结果为false，所以c被赋b的值，结果为20
