java基础（2）-变量、数据类型和运算符

注 ： 参考自https://mp.weixin.qq.com/s/MrrN7BDcKMu8SCKs6zij_g

2.1变量的声明和数据类型

2.2基本数据类型的变量

2.3Java的表达式和运算符

2.4运算符的优先级别

2.1变量的声明和数据类型

一、关键字

关键字是程序语言的最小单位，是程序语言事先定义的，并且具有特殊意义的一些标 识符，在有些语言里也称为保留字。正如我们使用人类的语言一样，一篇文章总是一个个的文字组成，完整的程序就像一篇文章，关键字就是一个个的文字。相比我们人类语言的复杂性,java程序语言的关键字只有53个。具体如下：

访问控制:private protected public

修饰类、方法、属性和变量:

abstract class extends final implements interface native new static 

strictfp synchronized transient volatile enum assert

程序控制:break continue return do while if else for instanceof switch case default

基本类型:boolean byte char double float int long short null true false void

错误处理:try catch throw throws finally

包相关:import package

变量引用:super this

保留字:goto const

有些初学者总是问学习编程需要英文是否要很好。上面这些关键字你还是要记的。也就这么50几个。所以不用担心英文不好就学不会变成。

以上这些关键字就是程序员编写程序时使用的最小单位。其中const和goto虽然在Java中未被使用，但考虑到它们与C++的关联性，所以仍然保留为关键字。

二、数据类型

我们在编写程序时处理由于数、字符、和浮点类型的对象无法再分为更简单的部分，我们在自然界称为简单数据，到了计算机编程的世界，我们称之为基本数据类型，大多数语言都有定义基本数据类型，这些类型为我们处理信息的最小单位。Java有8种基本类型，分别是：

类型

名称

含义

bit

字节数

值范围

整型

byte

字节

8

1字节

-128—127

short

短整型

16

2 字节

-32768—32767

int

整型

32

4 字节

-2,147,483,648 —2,147,483,647

long

长整型

64

8 字节

-9223372036854775808—922337203685477580

浮点型

float

浮点数

32

4 字节

有效位数15位

double

双精度浮点数

64

8 字节

有效位数15位

字符

char

字符

16

2 字节

Unicode字符集

布尔型

boolean

布尔型

1

true/false

除了基本数据类型外，为了实际应用的需要，Java还提供了两个用于高精度计算的非基本数据类型的数字类，他们是：

BigInteger——任意大的整数，可用于密码学计算等。

BigDecimal——任意精度的定点实数，可用于精确的货币计算等。

三、定义变量

数据类型确定要存储在内存中的数据的类型，变量则是存储数据的基本单元 。变量就好比一个杯子，而数据类型就定义了这个杯子的大小和它能装载什么内容。

java是强类型语言，所有的变量都必须先声明才能使用，声明变量时必须指定变量存储信息的类型。变量的声明一般使用名值对的方式，包含变量名和变量值，通过变量名可以引用变量值，也可以修改变量名的值。

首先，声明一个变量的基本格式是：

数据类型 变量名;

在下面这个例子中，我们在main方法中声明了三个变量：

public static void main(String[] args) {
       int type;
       boolean flag;
       float score;
}

可以看到，我们每一个变量的声明都是以类型说明符（参考上一节的java基本类型）开始，后面你可以自定义一个变量名，然后别忘了以分号结束，表示变量声明结束。类型的定义，约束了变量在存储区里所能表示的数据类型和空间大小。

我们在声明一个变量的时候也可以同时为其赋初值，上面提到变量的声明一般使用名值对的格式，具体格式如下：

数据类型 变量名 = 数值;

如下面这个例子：

public static void main(String[] args) {
       int box=100;
       int a=300;
       boolean f=true;
}

声明变量并同时赋予初值，我们称之为初始化。注意这里的等号（=）并不是我们以前学习数学时表示相等，而是赋予值的意思。这个时候名为box的这个变量所在的存储区保存的值就是100了。

我们可以在同一行同时声明多个同一类型的变量，这样可以简化我们的代码，提高可阅读性，具体格式如下：

数据类型 变量名, 变量名，变量名;

如下面这个例子：

public static void main(String[] args) {
    int a,b,c;
}

上面例子中，同时声明了三个整型变量（a,b,c）,变量和变量之间使用英文逗号(,)隔开。当然我们也是可以想上面介绍的，为变量赋予初始值。如下面这个例子：

public static void main(String[] args) {
  //变量a和变量c分别赋予了初始值。
  int a=100,b,c=20;
}

变量声明后，我们就可以通过变量名引用变量值或者修改变量名所存储的值了。在同一作用域下，变量只能声明一次，但是可以多次的赋值，不断根据程序的需要修改变量原来存储的变量值。具体格式如下：

变量名 = 新的数值;

引用该变量名的值就更简单了，直接使用变量名即可。如下面这个例子：

public static void main(String[] args) {
      //声明变量a，并同时赋初始化值是100；
      int a=100;
      //引用变量a,这时候输出的是变量所存储的值，应该是100
      System.out.println(a);
      //为赋值200
      a=200;
      //再次引用变量a,输出的也是变量所存储的值，但这时候应该是200了
      System.out.println(a);
}

上面的示例综合讲述了变量的声明，赋初始化值，应用和重写赋值等常用的语句，这里要重点说明的是，我们可以在程序运行时为变量多次赋值，但是每一次赋值都会覆盖该变量之前的变量值。这个例子看上去非常简单，但是要好好理解，这里理解复杂程序的关键基础，有着举足轻重的作用。

三、变量的命名规范

Java语言中，变量命名要符合一定规则。标识符是赋予变量、类或方法的名称。标识符可从一个字母、下划线(_)或美元符号($)开始，随后也可跟数字。标识符是大小写区别对待的并且未规定最大长度。

有效标识符如下：

identifier ， userName ，User_name ， _sys_varl ，$change

无效标识符如下：

123abc ， abc￥5 ，abc ert ， add34）

java的变量命名还有很多约定俗成的习惯，虽然你不按照这样的命名习惯也不会出现语法错误，不过为了提高程序的可读性，我们建议你还是使用上面的这几个习惯。

2.2基本数据类型的变量

一、整型变量

上一节中我们介绍了描述整型的三个符号：短整型（short）、整型（int）和长整型（long），它们都可以定义整型变量，但是由于分配的内存空间不同，所能表示的数据的长度也不同。

我们可以定义并初始化一个整型变量：

      int a=100;

那么变量a最大只能表示2147483647。如果赋值超过这个数，程序会报错，我们要根据实际需要使用不同的整型类型。下面我们重新给a赋值

      a=2147483647;

这个数据比较大，对我们而言比较难以看清，JDK 7之后整型数据我们可以使用以下这种方式赋值

       a=2_147_483_647;

另外我们定义整型时一般使用十进制表示，java也提供了定义为八进制和十六进制来表示：

八进制就是只能表示：0 1 2 3 4 5 6 7 ，

注意：八进制必须以0开头。如：

0123 045 098 046

十六进制：

0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F

注意：以十六进制表示时，需以0x或0X开头，如：

0x8a 0Xff 0X9A 0x12

还有就是对长整型的初始化和赋值时要主意，一般我们定义一个整数时默认都是整型，为了表示长整型我们需要在整数的后面加一个英文字符'L'或者'l',由于英文字符'l'和数字‘1’比较类似，所以我们习惯使用大写字母'L'。

如：

long a=9L;
long b=156L;// 长整型必须以L做结尾

二、浮点型

浮点数类型有float(32位)和double（64位）两种类型，分别叫做单精度浮点数和双精度浮点数，表示浮点数时，要在后面加上f(F)或者d(D)，用指数表示也可以。注意：由于小数常量的默认类型为double型，所以float类型的后面一定要加f(F),用以区分。初始化和赋值时除了支持一般的小数的写法外，也支持科学记数法。如以下例子都是可以的。

float a=2.4f;
float b=2e3f,
double c=3.6d;
double d=3.44;
float e=5.022e+23f

上面这些定义都是合法的。

三、布尔类型

布尔类型比较特殊，它的值只有两种：true和false。布尔类型一般用于条件判断。与C语言不同，C语言可使用整数0表示false，而非0表示true，但是在java中不可以这样，表示布尔型只能使用true和false，例子如下：

boolean flag=true;

boolean f=false;

四、字符常量

字符常量是由英文字母、数字、转义序列、特殊字符等的字符所表示，它的值就是字符本身，在java中使用单引号“’”表示，每个字符占用两个字节。如：

'a' '8' '\t' '\u0027'

可以使用全球统一编码(Unicode),码值加上\u来表示对应的字符, 采用Unicode的目的是为了覆盖全球各种各种语言使用的不同的语言标记，分为UTF-8和UTF-16。

五、字符串常量

字符串是自然界描述信息很常用的一种形式，因此使用非常频繁。Java中使用用双引号括起来进行标示，如：

"Hello World"

"123"

"Welcome \nXXX"

使用字符串时需要注意，我们存储信息时会带上一些特殊的方便人类阅读的格式标记，比如回车换行显示、或者直接想标示一个双引号，这是就需要使用转义字符的机制来实现，因此转义字符的目的是在字符串中标示一些特殊的标记信息，格式使用一个\开头，形如：

\r表示接受键盘输入，相当于按下了回车键；

\n表示换行；

\t表示制表符，相当于tab键；

\b表示退格键，相当于Back Space；

\'表示单引号，\"是双引号；

\\表示一个斜杠“\”。

比如上面的"Welcome \n XXX",它的运行结果是：

Welcome

XXX

六、特殊的null值

null字面量：用null表示，表示为空，注意在逻辑上来说：0不是空。null值在定义对象赋初值时使用。

七、变量的作用域变量的分类

与C语言不同，java的所有的变量都必须在类中声明，不允许有变量不在类中声明的，当然变量也是是有具体的使用范围的，这种范围就是变量的作用域。声明在class的根语句块的变量是具有全局作用域，就是在本程序内部任意位置都访问得到，被称作全局变量。局部变量会覆盖全局变量。如下面这个例子：

public class Tt {
   int i = 100;// 类的全局变量
   public void test() {
      System.out.println("访问的是全局变量i=" + i);
      int i = 50;// main方法中的全局变量,覆盖全局变量
      System.out.println("访问的是局部变量i=" + i);
   }
   public static void main(String[] args) {
      Tt tt=new Tt();
      tt.test();
   }
}

我们声明了一个全局变量i，这个变量i的作用域在整个类中都可以访问，然后我们定义了一个普通方法test，在这个方法体中，我们也可以访问全局变量i，但是如果我在这个方法里也声明了一个同名的变量i，也就是局部变量，那么局部变量i会覆盖覆盖全局变量i，所以第一个i输出的是100，而第二个i输出的时50，你可以在main方法中调用这个方法测试一下。

八、常量

常量就是在程序运行中不变的值，使用final关键字进行声明。

final double rate = 3.1415926;

在java中也可以用public static final修饰一个自定义字面量，或者使用枚举类型也可以表示一组字面量，枚举类型我们后面章节讨论。final关键字和public关键字我们也会在后面再讲解

public static final String ONEEDUNAME=”java and android 自学网”;//定义一个字符串常量

2.3Java的表达式和运算符

一、算术运算符

运算符

+

-

*

/

%

说明

加

减

乘

除

取模(余数)

例子

1+2

5-3

20*5

6/4

30%9

结果

3

2

100

1

3

和我们小学学得算术运算一样，不过这里要注意，整数的除法如果结果有小数，那么会自动的截断小数部分，例如以下这个例子：

int x = 10;
int y = 6;
int result=x/y;
System.out.println(result);

其结果是1，不会带有小数部分，也就是整数运算后的到的结果也是整数，不会自动变成浮点数。

上面所具的例子都是表示二元运算符，也就是说有两个运算参数，其中“+”和“-”两个符也可以表示一元运算符，分别表示正数和负数这些运算符也可以组合成为一个复杂的运算式子，如下面这个例子：

int x = 10,y = 6,a = 20,b = 2;
int result=-x/y+a-b+a%x+-a;
System.out.println(result);

运算的优先级和我们平时的数学算法一样，基本按照从左到右的计算，其中+和-具有相同的优先级，它们的优先级比*，/和%的运算低，但是*，/和%的运算优先级别又比一元运算符的+和-要低。与我们的数学算式一样，算术表达式也支持使用小括号更改计算的优先级，如下面这个例子:

int x = 10,y = 6,a = 20,b = 2;
int result=(x+y)*a+(a-b)*x;
System.out.println(result);

上面示例会先计算小括号的x+y和a-b两个式子，然后在按照先先乘除后加减，从左到右的计算顺序。有关优先级的详细讲解我们在后面的章节中讲解。

二、赋值运算符

运算符

=

+=

-=

*=

/=

++

--

说明

赋值

加等于

减等于

乘等于

除等于

自增1

自减1

例子

x=10

x+=y；

y-=5；

y*=z-3;

z/=3;

y++;

x--

等价于

x=x+y；

y=y-5；

y=y*z-3;

z=z/3;

y=y+1;

x=x-1;

在程序中“=”的意义与我们平时的数学计算的式子不同，他表示赋值的意思，就是把赋值表达式中右边的计算结果赋值左边的变量中。如下面这里例子都是赋值运算：

int x=5； //用专业的说法是把右边5的值赋值给左边的int变量x
int y=x=6; // y和x都赋值6；
int a;
a=100+200;

在赋值运算时，经常会出现左边的变量重复出现在赋值表达式的右边，如：

int a=100;
a=a+200;

赋值运算符的计算顺序都是从右边开始计算，也就是会先计算a+200的值，然后才会赋值给a，所以上面的例子会先取得a变量的值100，然后再加上200，最后把300的结果赋值给a变量，这时候a变量的值就是300。

由于像上面这样的运算在程序中常常会出现，为了提高编译的效率和书写代码的简易，java提供了一些相应的运算符号如：

+= -= *= /= %= >>= <<= &= ^= |=

有些运算符，我们在后面的章节中才会介绍，这些自操作赋值运算符是一种对编码简化的写法。有时运算比较复杂是为保证编码的可读性也可不用这种缩写的语法。像上面的列子：

a=a+200;

等价于以下形式：

a+=200;

归纳一下也就是，如果expr1和expr2分别代码两个表达式，op代表运算符号，那么：

expr1=(expr1) op (expr2)

等价于

expr1 op= expr2;

注意第一个表达式，有时候括号是不可缺少的，比如以下这个例子：

int a=10,b=3;
a*=b+1;

其意思是:

a=a*(b+1);

而不是：

a=a*b+1;

这点尤为注意。

三、自增1和自减1

我们要实现一个数的自增1或者自减1，目前可以有以下两种方法：

a=a+1或者a+=1；

a=a-1或者a-=1；

但是由于在编写程序时自增1或者自减1用得非常频繁，java语言提供了两个专门用于变量的自增1和自减1的特殊运算符，其中++是自增1运算符号，可以使操作数自增1，--是自减1运算符号，可以使操作数自减1。比如下面这个例子就是自增1：

int i=1;
i++;
System.out.println(i);//结果是2

需要特别留意的是++和--运算符可以前置、后置，都是合法的语句，如a++和++a都是合法的，上面这两种写法其最终的结果都是是变量a的值加1了，但是它们之间也是有区别的，其区别是：表达是++a会先将a的值自增1，然后在使用变量a。而表达式a++是先使用了a的值，然后再让a的值自增1。也就是说在一些表达式，使用a++和使用++a得到的结果时不一样的。例如：

int a=1;
int b= a++;
System.out.println(b);//这时候b是1

得到的结果是1，因为先使用了a的值后，才让a自增1。再看这个例子：

int a=1;
int b= ++a;
System.out.println(b);//这时候b是2

这时候b的值是2。再看看下面这个示例：

int a=1,b=1,c;
c=++a+b++;
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);

请读者上机测试，并回答为什么c最后的值是3。

最后再提一下++和--两个运算符都只能作用于变量，而不作用域表达式。如下面这个例子是非法的。

    int a=1,b=1;
 (a+b)++;

四、比较运算符

比较运算符也称为关系运算符，用于测试两个操作数之间的关系。使用关系运算符表达式的最终结果为 boolean 型，也就是其结果只有两个true和false。具体运算符号如下表所示：

运算符

==

!=

>

<

>=

<=

比较

等于

不等

大于

小于

大于等于

小于等于

例子

i==1；

i!=1；

i >1；

i<1；

i>=1；

i<=1；

结果

true

false

false

false

true

true

由上表所示，我们判断两个数是否相等使用两个等号（==），它与（!=）具有相同的优先级。比>、<、>=、<=的优先级要高，但是算术运算符的优先级比关系运算符高，也就是说i<a+100和i<(a+100)等结果都是一样。不同数据类型之间也可以进行比较，它们会被自动转换为相同的类型后再比较，如以下例子：

int x = 10;
float y=10.9f;
char a='0';
System.out.println(x>y);
System.out.println(a>x);

上面这些不同类型的变量进行比较是合法的。

五、逻辑运算符

运算符

&

|

!

&&

||

说明

与

或

非

阻断与

阻断或

示例

true&false

True|false

!false

true&&false

true||false

结果

false

true

true

false

true

逻辑运算符非常重要，尤其是在学习了后面的条件判断后，会大量使用这些逻辑运算符。

1、与运算

与运算符号有&和&&两个，表示必须两个条件都为true时，结果才能返回true。如：

(1>2)&&(1>3) (1>2)&&(3>1) (2>1)&&(1>3) (2>1)&&(3>1)

其对应比较运算过程就是

false&&false false&&true true&&false true&&true

也就是最后的结果就是前面三个的返回都是false，只有最后一个是true。

2、或运算

或运算符号有|和||两个，表示两个条件只要有一个满足为true，最后结果返回true。还是以上面例子说明如：

(1>2)&&(1>3) (1>2)&&(3>1) (2>1)&&(1>3) (2>1)&&(3>1)

其对应比较运算过程就是

false&&false false&&true true&&false true&&true

也就是最后的结果就是第一个返回为false，后面三个返回都是true。

3、取反运算符

取反运算符只有一个!,它是单元运算符，这个比较简单，如果是true就返回false，false就返回true，如下面的示例：

!(1>2) !(2>1)

其对应比较运算过程就是

!false !true

所以第一个返回是true，第二个返回是false。

4、组合的逻辑运算符

逻辑符可以组合使用,并结合上面比较运算符，形成一个复杂的条件判断，比如下面这个判断是否是闰年的条件判断式，闰年的判断条件是，如果此年份是4的陪数，但不是100的陪数，那么就是闰年，如果是100的陪数，还要是400的倍数才是闰年，实现代码如下：

      int year=2008;
   boolean result=year%4==0&&year%100!= 0||year % 400 == 0;

5、 &和&&、|和||的区别

参与运算的都是boolean布尔类型，在上表中的逻辑运算符&和&&、|和||的示例中，结果的都是一样的，但是在运算时却有区别。&&和||有一些比较特殊的属性，其运算的顺序是从左至右进行判断的，但是对&&而言如果在判断时得到的结果是false时，那么后面的计算就不会继续，对||而言，如果在判断时得到的结果是true，那么后面的计算也不会继续，这种机制称之为阻断判断或者短路判断，在有些情况之下，这种机制可以提高程序运行的效率。

int x=1,y=2;
boolean b;
b=x>y&&++x==--y;

b, x, y的值分别是false, 1, 2。x和y虽然上面都有自增和自减的表达式，但是却并没有执行，那是因为x>y的结果是false，后面使用了短路判断&&,所以不管后面的表达式的结果是什么，最后的结果必然是false，所以后面的++x和--y其实都没有执行过，如果改成以下例子：

int x=1,y=2;
boolean b;
b=x>y&++x==--y;

因为使用了&符号，所以b, x, y的值是false, 2, 1了。

六、条件运算符

java的条件运算符是三元运算符，也就是说有三个参数参与运算，其功能是对表达式条件进行判断，根据判断结果是true或者false两种情况赋予赋予不同的返回值,其语法如下：

表达式?值1:值2;

例如以下所示：

int a=2;
int b=1;
int c=(a>b)?3:4;
System.out.println(c);

上面这个例子的意思就是说，如果a大于b，那么就返回3，否则就返回4，所以根据代码的执行，最后c的值就是3。

七、位运算符

位运算符在java的企业应用中使用的频率并不高，但是在一些追求效率和编写底层应用时，还是会用到位运算符，前面介绍的各种运算都是基本都是以字节作为最基本位进行运算的，而位运算符是以位(bit)作为运算单位的，所以要弄明白位运算符，必须要知道二进制表示法。

int a=1;//int 是 32 位 取最后的8位是 00000001按位位与运算符"&"就是实现参与运算的两个数对应的二进制位数执行与的操作。如果两个二进位均为1时，结果位才为1，否则就为0。前面介绍过，计算机都是采用补码的方式运行的，所以参与运算的数都是补码方式进行的。如下面所示例子：1、按位与

int b=5;//int 是 32 位 取最后的8位是 00000101
System.out.println(a&b);//结果是 00000001

如代码所示00000001和00000101运算的结果是00000001。所以最后输出的结果是1 。

2、按位或

按位或运算符“|”就是实现参与运算的两个数对应的二进制位数执行或的操作。如果两个二进位均为0时，结果位才为0，否则就为1。我们继续以上面所示的例子：

int a=1;//int 是 32 位 取最后的8位是 00000001
int b=5;//int 是 32 位 取最后的8位是 00000101
System.out.println(a|b);//结果是 00000101

如代码所示00000001和00000101运算的结果是00000001。所以最后输出的结果是5。

3、按位异或

按位异或运算符“^”就是实现参与运算的两个数对应的二进制位数执行异或的操作。如果两个二进位相同时，结果位为0，不同时就为否1，简称“同0异1”。也就是说两个都是1或者两个都是0时结果为0，否则为1。还是以上面作为例子

int a=1;//int 是 32 位 取最后的8位是 00000001
int b=5;//int 是 32 位 取最后的8位是 00000101
System.out.println(a^b);//结果是 00000100

如代码所示00000001和00000101运算的结果是00000100。所以最后输出的结果是4

4、求反

求反运算符只是单目运算符，具有右结合性，这个功能比较简单，就是对参与运算的数的各二进位按位求反。但是这个结果需要补码的运算有所了解才行。

//int 是 32 位  对应二进制就是 00000000 00000000 00000000 00000001
int a=1;
//结果也是 32 位 对应的二进制是 11111111 11111111 11111111 11111110
System.out.println(~a);

因为部门的第一位是符号位，按照补码的运算，对应的结果就是-2了。

5、左移

左移运算符“<<”其功能把“<<”左边的运算数的各二进位根据右边定义的数量全部左移若干位，移动的数位由右边所定义的数量决定。 移动时依据高位丢弃，低位补0的原则。

int a = 2;//int 是 32 位 取最后的8位是 00000010
System.out.println(a<<1);//左移一位后就是 00000100

最后输出的结果是4，由上面的示例可知，每左移一位后，所得到的结果就是原来的数据乘以2，所以很多时候我们在做乘以2的操作是都是使用这个左移操作，以提高效率。

6、右移

右移运算符“>>”其功能把“>>”左边的运算数的各二进位根据右边定义的数量全部右移若干位，移动的数位由右边所定义的数量决定。 也是按照移动时依据高位丢弃，低位补0的原则。

int a = 12;//int 是 32 位 取最后的8位是 00001100
System.out.println(a>>2);//左移一位后就是 00000110

结果是3，由上面的示例可知，和左移正好相反，每右移一位后，所得到的结果就是原来的数据除以2，所以很多时候我们在做除以2的操作是都也是使用这个由移操作，以提高效率。

2.4运算符的优先级别

一、运算符的优先级

在一系列复杂的运算符中，优先级较高的运算符总是先被运算，然后才按照优先级的高低依次完成所有计算，在前面的章节中我们也简单了提到了一些运算符的优先顺序，其中优先级最高的是小括号括号：”(...)”,多个括号分割运算表达式会让一个复杂的表达式变得更具有可读性。其他的运算符按照优先级别的高低排序分别是：自加/减运算符、 算术运算符、比较运算符、逻辑运算符、赋值运算符。具体请参考下表：

顺序

运算符

1.

括号，如 ( ) 和 [ ]

2.

一元运算符，如 -、++、- -和 !

3.

算术运算符，如 *、/、%、+ 和 -

4.

关系运算符，如 >、>=、<、<=、== 和 !=

5.

逻辑运算符，如 &、^、|、&&、||

6.

条件运算符和赋值运算符，如 ? ：、=、*=、/=、+= 和 -=

当两个运算符拥有同样优先级时跟代数的四则运算一样，从左到右依次执行表达式。当要表示一个比较复杂的运算表达式时，最好多使用小括号，可以使用表达式更加清晰，对于一些比较复杂的，尽量可以分开多个步骤，这样虽然可能会降低效率，但是可以提高代码的可读性。比如下面这个例子：

int i=1,j=2;
int a=i+++j+++i++;
System.out.println(a);

看着就让人头晕了，我们可以修改以下这样。

int a=(i++)+(j++)+(i++);

二、类型转换

我们在写运算符时，经常会碰到一个运算符中包含好几个不同数据类型的参数，这就涉及到数据类型的转换。java有两种类型的转换，分别是自动类型转换和强制类型转换。

1、自动类型转换

一般而言，java编译器还是比较智能的，对不同数据类型的参数，会自动转换类型，为了不至于数据的丢失，一般是较窄的数据类型转换为较宽的数据类型。也就是说如果一个short类型和一个int类型相加，那么结果就会自动转换为int类型，因为int比short数位要宽，再有如果int类型和float类型相加，那么结果是float类型，因为浮点型比整型所能表示的数据要宽。另外我们也可以把一个较窄的数据类型直接赋值给一个较宽的数据类型。总结一下，在赋值或者计算时，只要满足以下条件，就会发生自动类型转换：

（1）两种类型兼容；

（2）目标类型大于源类型；

例如：

（1）byte、char和 short 型值可提升为 int 型。如果一个操作数为 long 型，则整个表达式结果为 long 型

（2）如果一个操作数为 float 型，则整个表达式结果为 float 型。而如果一个操作数为 double 型，则整个表达式结果为 double 型

2、 强制类型转换

强制转换用于显式类型转换。但是强制类型转换需要小心使用，因为如果被转换的值的数据类型大于其目标类型，就会丢失部分信息。类型强制转换使程序将变量视为某种类型，尽管此变量中包含的是另一类型的数据，其具体格式如下：

（类型名）表达式

示例：

float a = 346.756565f;
int b = (int) a + 10;       // 将 c 转换为整型
System.out.println(b);

最后的结果是356，浮点型a后面的所有的小数都会丢失。