1、标识符
关于java语言当中的标识符
（1、标识符是什么？
凡是在java源程序当中，有权利自己命名的单词都是标识符
可以标识的元素有：类名、方法名、接口名、常量名。。。
（2、标识符的命名规则？【不按这个规则来标识符会报错】
*一个合法的标识符只能由数字、字母、_、$ 组成，不能含有其他特殊符号。
*不能以数字开头
*严格区分大小写
*关键字不能作为标识符
*理论上无长度限制，最好不要太长
（3、标识符的命名规范？【只是一种规范，不属于语法，不符合规范不会报错】
*最好见名知义
public class UserService{public void login(String username,String password){}}
*遵守驼峰命名法SystemServiceUserService*类名、接口名：首字母大写、后面单词首字母大写*变量名、方法名：首字母小写、后面单词首字母全部大写*常量名：全部大写
public class IdentifierTest1{//IdentifierTest1是一个类名，可以修改public static void mian(String[] args){//main是一个方法名，args是一个变量名}//dosome就是方法名public dosome(){int i =10;//i就是变量名}}
2、关键字
访问控制
private 私有的
protected 受保护的
public 公共的
default 默认
类、方法和变量修饰符
abstract 声明抽象
class 类
extends 扩充,继承
final 最终值,不可改变的
implements 实现（接口）
interface 接口
native 本地，原生方法（非 Java 实现）
new 新,创建
static 静态
strictfp 严格,精准
synchronized 线程,同步
transient 短暂
volatile 易失
程序控制语句
break 跳出循环
case 定义一个值以供
switch 选择
continue 继续
default 默认
do 运行
else 否则
for 循环
if 如果
instanceof 实例
return 返回
switch 根据值选择执行
while 循环
错误处理
assert 断言表达式是否为真
catch 捕捉异常
finally 有没有异常都执行
throw 抛出一个异常对象
throws 声明一个异常可能被抛出
try 捕获异常
包相关
import 引入
package 包
基本类型
boolean 布尔型
byte 字节型
char 字符型
double 双精度浮点
float 单精度浮点
int 整型
long 长整型
short 短整型
变量引用
super 父类,超类
this 本类
void 无返回值
保留关键字
goto 是关键字，但不能使用
const 是关键字，但不能使用
null 空
3、字面值
关于字面值
*字面值：10、100、3.14、“字符串”、‘a’、true、false
*字面值就是数据
*字面值时Java源程序的组成部分之一，包括标识符和关键字也是java源程序的组成部分。
*数据在现实世界当中是分门别类的，所以数据在计算机编程语言中也是有类型的【数据类型】
10、100属于整数类型，true属于bool类型值,"abc"属于字符串值。
注意：
java语言中所有的字符串类型值必须用双引号括起来
java与语言当中所有的字符型字面值必须使用单引号阔起来,单引号中只能出现单个字符，属于字符型数值
public class {public static void mian(String[] args){//一个字面值存储在内存当中，必然会占用内存空间。System.out.println("abc");System.out.println(10);System.out.println(false);System.out.println('A');}}
4、变量
关于Java源当中的变量
（1、什么是变量？
*变量本质上是内存上的一块空间，这块空间上有数据类型、名字、字面值。
*变量含有三部分：数据类型、名称、字面值【数据】
*变量是内存中存储数据的最基本单元。
（2、数据类型的作用是什么？
*不同的数据有不同的类型，不同的数据类型底层会分配不同的大小空间。
*数据类型是指导程序在运行阶段该分配多大的内存空间。
（3、变量要求：变量中存储的具体数据必须和变量的数据类型一致，当不一致时，编译报错
（4、声明/定义变量的语法格式：
数据类型 变量名;
*数据类型：int、flout、char等
*变量名：合法的标识符，规范：首字母小写，后面每个单词首字母大写。
例如： int i;
int age;
（5、变量声明之后，怎么赋值？
*语法格式：
变量名 = 字面值;
*要求：字面值的数据必须和变量的数据类型一致。等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行后的结果赋值给左边的变量（6、声明和赋值可以放在一起完成
数据类型 变量名 = 字面值;int i = 10;
（7、变量赋值之后可以重新赋值，变量的值可变化。
int i = 10;System.out.println(i)//10i = 20;System.out.println(i)//20
（8、有了变量的概念后，内存空间得到了重复的使用。（9、通常访问一个变量包括两种访问形式：*第一种：读取内存中保存的具体数据*第二种：修改变量中保存的具体数据（10、变量在一行上可以声明多个数据类型 变量名、变量名、变量名...;int a,b,c;
public class VarTest1{public static void main(String[] args){//声明一个变量，起名为iint i;//System.out.println(i); //编译报错，变量i没有初始化i = 10;//i变量初始化，内存被开辟System.out.println(i);i=100;//i再次重新赋值System.out.println(i);int a,b,c=300;//一行上可以定义多变量//System.out.println(a);//System.out.println(b);//编译报错，变量a和b没有赋值，只赋值了c变量。System.out.println(c);}}
（11、变量必须先声明再赋值再访问
int i; //程序运行到这里，内存空间并没有被开辟出来，变量i没有初始化，//所以没有初始化之前的变量是不能访问的public class VarTest2{public static void main(String[] args){/*System.out.println(i);int i = 100;以上代码的顺序有错误，先声明，然后赋值，再访问*/}}
（12、在方法体中的java代码，是遵循自上而下的顺序依次进行的。前一次行代码没有执行前，后面的代码不会执行，只有前面的代码执行之后，后面的代码才能执行。（13、在同一个作用域当中，变量名不能重名，但是可以重新赋值。（14、变量的作用域：什么是作用域？变量的有效范围。在范围之内是可以被访问的，出了变量就不能被访问了。出了大括号就不认识了
public class VarTest3{//static不能去掉static int k = 90;public static void main(String[] args){int i =100;//变量i的作用域是在main方法内是有效的for (int a=0;a<10;a++){}//System.out.println(a);//无法访问a变量，因为a变量的作用域是整个for循环，//for循环结束之后，a变量的内存就释放了int j;for (j=0;j<10;j++){}System.out.println(j);//j变量可以被访问}public static void DoSome{//System.out.println(i);//这里无法访问main方法当中的变量i，已经出了i的变量范围。System.out.println(k);//k变量的作用域是整个类体}}
（15、关于变量的分类：根据变量声明的位置来分类：*局部变量在方法体当中声明的变量叫做局部变量*成员变量在方法体外【类体内】声明的变量叫成员变量在不同的作用域当中，变量名是可以相同的。在同一个作用域当中，变量名不能重名
public class VarTest4{public static void main(String[] args){//i变量是全局变量int i = 10;System.out.println(i);//java遵循就近原则，先访问方法体内的变量，若方法体内没有该变量，再去访问类体}//成员变量int i = 100;//System.out.println(i);//类体内不能直接编写java语句【除了声明变量以外】public static DoSome(){int i = 90;//局部变量}}
5、数据类型
关于java当中的数据类型：
（1、数据类型的作用是什么？
程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。
数据类型的作用是指导jvm虚拟机在运行程序的时候给该数据分配多大的空间。
（2、java中的数据类型包括两种：
*基本数据类型
*引用数据类型【以后讲】
类、接口、数组…
（3、关于基本数据类型：
*基本数据类型包括四大类八小种：
-.第一类：整数型
byte,short,int,long
-.第二类：浮点型
float,double
-.第三类：布尔型
boolean
-.第四类：字符型
char
（4、字符串不属于基本数据类型，属于引用数据类型，字符属于基本数据类型
*字符串使用双引号""
*字符使用单引号’’
（5、八种数据类型各自占用的空间大小是多少
基本数据类型占用空间大小【1字节】----------------------------------------------------------byte1short2int4long8float4double8boolean1char2
（6、计算机在任何情况下都只能识别二进制。例如：只认识10010101........【现在的计算机底层采用交流电的方式，接通和断开就是两种状态，计算机只识别0和1】（7、字节（byte）
1个字节（byte） = 8个比特位（bit）【一个bit表示一个二进制位：0/1】1 KB = 1024 Byte1 MB = 1024 KB1 GB = 1024 MB1 TB = 1024 GB1TB = 1024*1024*1024*1024*8 bit
（8、计算机是怎么表示现实世界的文字？【字符编码】*八种基本数据类型当中，byte、short、int、long、float、double、boolean这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制的数字之间存在一种固定的转换规则。*但是八种基本数据类型当中的char类型表示的是现实世界当中的文字，文字和计算机二进制之间“默认”情况下是不存在一种固定转换的规则的。*为了让计算机可以让计算机表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好“文字和”和“二进制”之间的对照关系。这种对照转换关系被称为；字符编码。*计算机最初只认识英文，最先出现的字符编码是ASCII码。'a'--->97'A'--->65'0'--->48'a'-----(按照ASCII解码)---->0110000101100001----(按照ASCII编码)---->'a'编码和解码的时候采用同一套字典/对照表，不会出现乱码。当解码和编码不是同一套对照表，会出现乱码。*支持简体中文的：GB2312<GBK<GB18030*后来出现一种编码方式统一了全球所有的文字，容量较大，这种编码叫做：unicode编码unicode编码方式有多种具体的实现UTF-8、UTF-16、UTF-32，java语言采用unicode编码方式，所以“标识符”可以是中文*现在的实际开发中UTF-8居多（9、八种基本数据类型的取值范围
数据类型取值范围----------------------------------------------------byte[-128~127]short[-32768~32767]int[-2147483648~2147483247]longfloatdoubleboolean[true/false]char[0~65535]
（10、关于八种基本数据类型的默认值
数据类型默认值-------------------------------------byte、short、int、long0float、double0.0booleanfalse【在C语言中true是1，false是0】char\u0000
八种基本数据类型的默认值一切向0看齐short和char所表示的种类总数是一样的，只不过char可以表示更大的正整数，因为char没有负数
public class DataType2{int static k=1000;//static必须加int static f;public static void main(String[] args){/*int i;System.out.println(i);//没有初始化不能访问*/System.out.println(k);System.out.println(f);//运行结果为0；成员变量没有手动赋值的时候，系统会默认赋值//【局部变量不会】}}
（11、以下java程序主要讲解的是数据类型之：char类型
public class DataType3{public static void main{//定义一个char数据类型的变量，起名c，同时赋值字符'a'char c = 'a';System.out.println(c);char x = '国';System,out.println(x);//一个中文为两个字节，char数据类型正好是两个字节//所以在java中的char类型变量可以存储一个中文字符//char = 'ab'//ab是字符串，不能用单引号括起来，编译错误。//char k = "a"//"a"是字符串，k是字符型变量，类型不兼容，编译错误char e;//声明 e = 'e';//赋值System,out.println(x);e = 'f'//再次赋值System,out.println(x);}
（12、转义字符
public class DataType4{public static void main(String args[]){char c1 = 'n';//普通的nSystem.out.println(c1);char c2 = '\n';//表示一个“换行符”，属于char类型的数据，反斜杠在java当中具有转义功能。println 和 print 的区别：println：输出且换行print：输出不换行/*System.out.println("Hello");System.out.println("World");*/}}
输出一个反斜杠char k = '\';//编译错误：反斜杠将单引号'转化成不具备特殊含义的普通的单引号，使得前面的单引号缺失一部分。char k = ''';//以下编译报错，第一个单引号和第二个单引号配对，最后的单引号找不到另一半char k = '\'';char k = '\\';//在Java中两个反斜杠表示一个普通的反斜杠字符char m = '\4e2d'//“中”对应的字符编码是4e2dSystem.out.println(m);//输出“中”；转义字符出现在特殊字符之前，会将特殊的字符转换成普通的字符反斜杠u联合起来后面一串字符是unicode的编码常见的转义字符\n换行符\t制表符\'单引号\\反斜杠\"双引号（13、整数型
数据类型占用空间大小默认值取值范围-----------------------------------------------------------------byte10-128~127short20-32768~32767int40-2147483248~2147483247long80L
1、java当中的整数型字面值默认当做int处理，要让整数型字面值被当做long来处理，则需要在字面值后面家l/L，建议使用L2、java语言当中的整数型字面值有三种表示方式第一种：十进制【是一种缺省默认的方式】第二种：八进制【编写八进制整数型字面值的时候需要以0开始】第三种：十六进制【编写八进制整数型字面值的时候需要以0x开始】
public class DataType5{public static void main(String args[]){int a = 10;int b = 010;//整数型字面值以0开头的，后面一串数字就是八进制形式int c = 0x10;//整数型字面值以0x开头的，后面一串数字就是八进制形式System.out.println(a);//10System.out.println(b);//8System.out.println(c);//16System.out.println(a+b+c);//34int i = 123;//123这个整数型字面值是int，i变量声明的时候也是int类型，//int类型的123赋值给int类型的变量i，不存在类型转换long x = 456;//456整数型字面值是int类型，占用4个字节//x变量在声明的时候是long类型，占用8个字节//int类型的456赋值给long类型的变量x，存在类型转换//小容量可以自动转换成大容量的数据类型，称为自动类型转换机制。//long z = 2147483648;//等号右边的字面值没有经过处理，默认为int，但字面值超过int类型的范围，编译错误//需要在字面值后面加上Llong z = 2147483648L;System.out.println(z);}}public class DataType6{public static void main(String args[]){long x = 100L;//100L是long类型的字面值，x是long类型的类型变量，不存在类型转换，直接赋值int y = x;//x变量是long类型的变量，8个字节，y是int类型的变量，4个字节//编译错误，精度损失，大容量不能直接赋值给小容量//大容量转换成小容量需要进行强制类型转换，//强制类型转换，需要加上强制类型转换符，编译才能通过，且精度可能产生损失。//强制类型转换需要谨慎使用，损失精度可能损失严重。/*强制转换原理原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100转换后的数据：00000000 00000000 00000000 01100100将左边的二进制砍掉【所有的二进制转换都这样】计算机存储的数据都是采用补码的形式存储，将以上的补码转换成源码就是最终结果*/int y = (int)x;long k = 2147483648L;int e = (int)k;//损失精度严重，结果为负数。【-2147483648】//没有超过byte类型的数据可以直接赋值，但不能超过byte的容量}}/*计算机二进制的三种表现形式：原码、反码、补码计算机在任何情况下底层表示和存储的数据采用补码的形式。正数的补码：和原码相同复数的补码：负数的绝对值对应的二进制码所有二进制位取反，再加一*/byte m = (byte)198//-58//原始数据：00000000 00000000 00000000 11000110//强转之后：11000110（补码形式）----->10111010（原码）---->-58（十进制）若数据没有超出byte的数据类型，可以对其直接赋值给byte变量，若加上强制类型转换，可能导致精度损失short s =32767;short s1 = 32768;//编译报错，没有超过short范围的数据也可以直接赋值给它char cc = 65535;//65535是int类型，4个字节//cc是char类型，2个字节cc = 65536;//编译报错
总结：当一个整数字面值没有超过byte、int、short、char的取值范围，这个字面值可以直接赋值给byte、int、short、char类型的变量，（14、浮点数float 单精度【4个字节】double 双精度【8个字节，精度较高】double的精度太低【相对】，不适合做财务软件。涉及财务问题，要求精度较高，所以sun公司在基础SE类库中为程序员准备了精确度较高的类型只不过不是基本数据类型，是一种引用数据类型，它是：java.math.BigDecimaljava程序中sun提供了一套庞大的类库，java程序员是基于这套类库来进行开发的。所以要知道java的类库的字节码在哪*SE类库字节码 C:\Program Files\Java\jre1.8.0_131\lib\rt.jar*SE类库的源码 C:\Program Files\Java\jre1.8.0_131\src.zip例如：String.java 和 String.class我们的(String args[])中的String使用的就是String.class字节码文件在java语言当中，所有的浮点型字面值，默认被当做double类型来处理，要想该字面值当做float来处理，需要在字面值后面加上F/f注意：double和float在计算机内部二进制存储的时候都是近似值。在现实世界当中有一些数字是无线的double d = 3.0;//3.0是double类型的字面值，d变量是double类型的变量，不存在类型转换float f = 5.1;//5.1是double类型的字面值，f是float类型的变量//f是float类型的变量//大容量转换成小容量需要加强制类型转换符，编译报错/*解决方案：第一种：float f = (float)5.1;强制类型转换第二种：float f = 5.1F;没有强制类型转换*/（15、布尔类型boolean在java当中，boolean数据类型只有两个值：true、false，没有其他值【不像C语言当中0和非0】在底层中存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1.布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句。boolean flag = 1;//不兼容类型，编译错误【条件控制语句】
boolean loginSuccess = true;if(loginSuccess){System.out.println("登陆成功！");}else{System.out.println("对不起，用户名或密码错误！");}
（16、类型转换（16、类型转换转换规则：（1）、八种基本数据类型当中除了布尔类型外，其他数据类型都可以互相转换（2）、小容量向大容量转换称为自动类型转换八种基本数据类型容量大小排序：byte < short < int < long < float < double < char <char c = 97;//无问题，存在类型转换注意：任何浮点类型数据，不管占用多少个字节，都比整数型容量大。char和short可表示的种类数量相同，但是char可取更大的正整数（3）、大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能损失精度，所以谨慎使用（4）、当整数字面值没有超过byte、short、char的取值范围，可以直接赋值给byte、short、char类型的变量。（5）、byte、short、char混合运算的时候，各自先转换成int类型再做运算。（6）、多种数据类型混合运算，先转换成容量最大的一种数据类型再进行运算。
byte a = 1000;//超出byte类型的范围出错byte a = 20;//变量不能重名short b = 1000;int c = 1000;long d = c;//自动类型转换，小容量转换成大容量。int e = d;//大容量转换成小容量，编译错误，需要加强制类型转换符：int e = (long)d;int f = 10/3;//结果为3double dd = 10/3//结果为3.0，因为在赋值之前，10/3是int之间的运算，结果先算出3，再转换成double类型//可以用dd = 10.0/3 3会先变成3.0，再进行double之间的运算，结果为double 的3.33333333335long g = 10;int h = g/3;//g为long类型变量，不能直接复制给int类型的变量，需要加上强制类型转换符：int h = (int)g/3;byte y = (byte)(int)g/3;//意思是先将g转换成byte再与3相除，最后结果为int类型，赋值给byte类型，所以编译报错int i = 10;byte bbb = i/3;//编译报错，编译器只检查语法，不进行运算byte y = (byte)(int)(g/3);//将g/3进行运算，再进行进制转换short i =10;byte j = 5;short k = i + j;//编译报错，short、byte类型进行运算，先转换成int类型进行运算，结果为int类型，若直接写个15则正确，不超范围。short k = (short)(i + j);//可以char l = 'a';System.out.println((byte)l);//97int m = 100+l;//197
6、运算符
（1、算术运算符
+ 求和
- 相减
* 乘积
/ 商
% 求余数【取模】
++ 自加一
– 自减一
注意：一个表达式当中，有多个运算符，运算符有优先级，不确定加小括号，优先级得到提升，没必要记运算符的优先顺序。
int i = 10;int j = 3;System.out.println(i+j);//13System.out.println(i-j);//7System.out.println(i*j);//30System.out.println(i/j);//3System.out.println(i%j);//1判断奇数还是是偶数，i%2System.out.println(i+j);++和--相似，以下以++为例子：关于++运算符【自加一】int k = 10;k++;//++运算符可以出现在变量的后面【单目运算符】System.out.println(k);//11int y = 10;y++;//++运算符可以出现在变量的前面面【单目运算符】System.out.println(y);//11小结：++运算符可以出现在变量的前面，也可以出现在变量后面，只要++运算结束，该变量中的值一定会自加一//++出现在变量后int a = 100;int b = a++;System.out.println(a);//101System.out.println(b);//100规则：++出现在变量后面，先进性赋值运算，在进行自加一操作//++出现在变量前int m = 20;int n = ++m;System.out.println(m);//21System.out.println(n)//21规则：++出现在变量之前，先进行++操作，再进行赋值操作。int xx = 500;System.out.println(xx);System.out.println(xx++);//500System.out.println(++xx);//501（2、关系运算符>大于>=大于等于<小于<=小于等于==等于!=不等于注意：=是赋值运算符==是关系运算符关系运算符的结果一定是布尔类型：true/falseint a = 10;int b = 20;System.out.println(a>b);//falseSystem.out.println(a>=b);//falseSystem.out.println(a<b);//trueSystem.out.println(a>=b);//trueSystem.out.println(a==b);//falseSystem.out.println(a!=b);//true//关系运算符比较的是变量所保存的值的大小关系int a = 10;double b = 20;System.out.println(a==b);//true
（3、逻辑运算符&逻辑与（两边算子为true，才能为true）|逻辑或（两边算子只要有一个为true，结果就为true）!逻辑非（取反，!false为true，!true为false，单目运算符）^逻辑异或（两边算子只要不一样结果就为true）&&短路与||短路或（1）、逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符运算结果也是一个布尔类型。（2）、短路与和逻辑与最终结果是相同的，只不过短路与存在短路现象。短路或和逻辑或最终结果是相同的，只不过短路与存在短路现象。
System.out.println(5>3 & 5>2);//trueSystem.out.println(5>3 & 5>6);//falseSystem.out.println(5>3 | 5>6);//trueSystem.out.println(5>3 ^ 5>6);//true//注意：运算符优先级不确定，加小括号。//逻辑与与短路与int x=10;int y=8;System.out.println(x<y & ++x<y);//逻辑与System.out.println(x);//11int x=10;int y=8;System.out.println(x<y & ++x<y);//短路与System.out.println(x);//10
逻辑与前面的表达式是false，后面的表达式依然进行运算短路与在前面的表达式为false时，后面的表达式不进行运算【短路现象】结果都为false同理逻辑或在前面的表达式为true时，后面的表达式依旧进行运算短路或在前面的表达式为true时，后面的表达式不进行运算【短路现象】短路与（或）比逻辑与（或）更智能，由于后面的表达式可能不执行，所以执行的效率较高短路与在实际开发中使用比较多，但在无论前面的表达式如何的情况下，要求运算符两边的算子必须执行，则只能用逻辑与（或）（4、关系运算符（字符串连接运算符）关于java中的“+”运算符：（1）、求和（2）、字符串的连接运算规则：当“+”运算符两边是数字的情况下，一定进行加法运算，当“+”运算符两边只要有一个数据是字符串，一定会进行字符串连接运算，且连接结果为字符串数字 + 数字---->数字【求和】数字 + “字符串”---->“字符串”【字符串连接】在一个表达式当中可以出现多个“+”，在没有添加小括号的情况下，遵循自左向右的顺序，依次运算
int i = 10;int b = 20;System.out.println(10 + 20);// 加号作用是求和，结果30System.out.println(10+20+30);//加号作用都是求和，结果60System.out.println(10+20+"30");//第一个加号求和，第二个加号字符串连接，结果为3030System.out.println(10+(20+"30"));//先运行小括号里面的加号，在运算左边的加号，结果为102030//要求在控制台上输出“10 + 20 = 30”,要求以动态的形式输出System.out.println("10+20 =" + a+b);//结果为“10 + 20 = 1020”，运算符的优先级System.out.println(i +"+"+ b +"="+(a+i))//动态输出“10 + 20 = 30”
（5、三元运算符（三目运算符、条件运算符）（1）、语法规则：布尔表达式？表达式1：表达式2（2）、执行原理：当布尔表达式的结果是true的时候，表达式1作为整个表达式的结果当布尔表达式的结果是false的时候，表达式2作为整个表达式的结果。boolean sex = false;sex?'男':'女';//'男'、'女'不是语句，所以编译报错char c = sex?'男':'女';//不确定优先级可以加括号 char c = (sex?'男':'女');（6、赋值类运算符复制类运算符包括两种：基本的赋值运算符：=扩展的赋值运算符：+=、-=、/=、*=、%=复制类运算符特点：先执行等号右边的表达式，将执行结果赋值给右边的变量注意以下代码：byte i = 10;i+=5 和 i=i+5 是不一样的扩展类运算符运算不改变运算结果的类型。无论怎么追加或减，最终变量的类型不变
public class OperatorTest1{public static void main(String[] args){int i = 10;i = i +3;System.out.println(i);//13i+=3;//等同于i = i+3【+=运算符可以翻译成“追加/累加”】System.out.println(i)//16i-=5;//等同于i = i-5i*=5;//等同于i = i*5i/=2;//等同于i = i/2i%=2;//等同于i = i%2//-------------------------------------byte b = 10;b = 15;//编译通过b = b + 5;//编译报错，编译器只检查语法，不允许程序，//编译器发现b+5是int类型，b是byte类型，大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，//纠正错误:b = (byte)(b+5);byte x = 10;x+=5;//等同于x=(byte)(x+5),并不等同于x=x+5，编译通过byte z = 0;z+=128;//等同于z = (byte)(z+128)}}
