在最底层，Java中的数据是通过使用操作符来操作的。几乎所有的操作符都只能操作“基本类型”，例外的操作符是“=”、“==”、“!=”，这些操作符能操作所有的对象。除此之外，String类型支持“+”和“+=”。

先乘除，后加减

赋值使用操作符，它的意思是“取右边的值，把它赋值给左边”，例如a=4，但是不能把任何东西赋给一个常数，常熟不能作为左值（比如不能说4=a）。

对基本类型的赋值是很简单的，基本类型存储了实际的数值，而并非指向一个对象的引用，所以在为其赋值的时候，是直接将一个地方的内容复制到了另一个地方。例如对基本数据类型使用a=b，那么b的内容就复制给a，若接着有修改了a，而b根本不会受这种修改的影响。但是在位对象“赋值”的时候，情况却发生了变化。对一个对象进行操作时，我们真正操作的是对对象的引用。所以倘若“将一个对象赋值给另一个对象”，实际是将“引用”从一个地方赋值到另外一个地方。这意味着假若对对象使用c=d，那么c和d都指向原本只有d指向的那个对象，若接着改变了c，d也会跟着改变，修改c的同时也修改了d，这是由于c和d包含的是相同的引用，他们指向相同的对象，。下面这个例子详细阐述这一点：

 package com.exam.cn. test ;
class Tank{
int level;
}
public class Assignment {
 public static void main(String[] args) {
Tank t1=new Tank();
Tank t2=new Tank();
t1. level =9;
t2.level=47;
System.out.println("赋值前:t1.level:"+t1.level+",t2.level:"+t2.level);
t1=t2;
System.out.println("赋值后:t1.level:"+t1.level+",t2.level:"+t2.level);
t1.level=27;
System.out.println("修改后:t1.level:"+t1.level+",t2.level:"+t2.level);
}
}

输出结果：
赋值前:t1.level:9,t2.level:47
赋值后:t1.level:47,t2.level:47
修改后:t1.level:27,t2.level:27  

原本t1包含的对对象的引用，是指向一个值为9的对象，那个对象在赋值之后丢失了，会由“垃圾回收器”自动清理。这种特殊的现象通常称作“别名现象”，是Java操作对象的一种基本方式。在这个例子中，如果想避免别名问题应该怎么办呢？可以这样写：t1.level=t2.level;这样写便可以保持两个对象的彼此独立，而不是将t1和t2绑定到相同的对象。但你很快就会意识到，直接操作对象内的域容易导致混乱，并且违背了良好的面向对象程序设计的原则。这不是一个小问题，所以从现在开始大家就应该留意，为对象赋值可能会产生意想不到的结果。方法调用中的别名问题：

 package com.exam.cn.test;
class Letter{
char c;
}
public class PassObject {
static void f(Letter y){
y.c='z';
}
public static void main(String[] args) {
Letter x=new Letter();
x.c='a';
System.out.println("方法前：x.c="+x.c);
f(x);
System.out.println("方法后：x.c="+x.c);
}
}

输出结果:
方法前：x.c=a
方法后：x.c=z  

在许多编程语言中，方法f()似乎要在它的作用域内复制其参数Letter y的一个副本，但实际上只是传递了一个引用，所以代码行y.c=’z’;实际改变的是f()之外的对象，别名引起的问题及其解决办法是很复杂的问题，在使用中应该注意这个陷阱。

Java的基本算术操作符包括+、-、*、/以及取模%。整数除法会直接去掉结果的小数位，而不是四舍五入地圆整结果。

通过 random 类的对象，程序可生成许多不同类型的随机数字。

 package com.exam.cn.test;

import java.util.Random;

public class RandomTest {
public static void main(String[] args) {
Random random=new Random();
int i=random.nextInt();
float j=random.nextFloat();
double k=random.nextDouble();
long a=random.next long ();
boolean b=random.nextBoolean();
System.out.println("i="+i);
System.out.println("j="+j);
System.out.println("k="+k);
System.out.println("a="+ a);
System.out.println("b="+b);
}
}

输出结果
i=-1718223771
j=0.009659767
k=0.9256075958095714
a=-3209787307976735976
b=true  

传递给nextInt(n)的参数设置了所产生的随机数的上限，而其下限是0，[0,n]

自动递增和递减：对于前缀递增和前缀递减（如++a或–a），会先执行运算，再生成值。而对于后缀递增和后缀递减（如a++和a–），会先生成值，再执行运算。

关系操作符

==和!=比较的就是对象的引用，如果想比较两个对象的实际内容是否相同，又该如何操作呢？此时，必须使用所有对象都适用的特殊方法equals()。但这个方法不适用于基本类型，基本类型直接使用==和!=即可。equals()方法的默认行为是比较引用。所以，除非在自己新类中覆盖equals()方法，否则不可能表现出我们希望的行为。大多数Java类库都实现了equals()方法，以便用来比较对象的内容，而非比较对象的引用。

 package com.exam.cn.test;
class Value{
int i;
}
public class EqualTest {
 public static void main(String[] args) {
Integer n1=new Integer(47);
Integer n2=new Integer(47);
System.out.println(n1==n2);
System.out.println(n1!=n2);
System.out.println(n1.equals(n2));
Value v1=new Value();
Value v2=new Value();
v1.i=v2.i=100;
System.out.println(v1.equals(v2));
}
}
输出结果
 false 
true
true
false  

逻辑操作符(&&, ||, !)

当使用逻辑操作符时，我们会遇到一种短路现象。即一旦能够明确无误地确定整个表达式的值，就不再计算表达式余下部分了，可以获得潜在的性能提升。

十六进制数适用于所有整数数据类型，以前缀0x（或0X），后面跟随0-9或小写（或大写）的a-f来表示。八进制数由前缀0以及后续的0~7的数字来表示

按位操作符：&，|，^，~，操作的对象是二进制的位

移位操作符：<<能按照操作符右侧指定的位数将操作符左边的操作数向左移动（在低位补0），>>则按照操作符右边指定的位数将操作符左边的操作数向右移动，有符号右移位操作符使用符号扩展，若符号为正，则在高位插入0，若符号为负，则在高位插入1。Java中增加了一种无符号右移操作符>>>，无论正负，都在高位插入0，这一操作符是C或者C++中所没有的。

如果对char、byte或者short类型的数值进行移位处理，那么在移位进行之前，它们会被转换为int类型，并且得到的结果也是一个int类型的值，只有数值右端的低5位才有用。这样可防止我们移位超过int型值所具有的位数。（因为2的5次方为32，而int型值只有32位。）若对一个long类型的数值进行处理，最后得到的结果也是long。此时只会用到数值右端低6位，以防止移位超过long型数值具有的位数。

截尾和舍入

将float和double转换为整型值时，总是对该数字执行截尾，去掉小数和小数点以后的部分。如果想要得到舍入的结果，就需要用到java.lang.Math中的round()方法。

如果对两个够大的int值进行乘法运算，，结果就会溢出。

 package com.exam.cn.test;

public class OverFlow {
public static void main(String[] args) {
int big=Integer.MAX_VALUE;
System.out.println("big="+big);
int bigger=big*4;
System.out.println("bigger="+bigger);
}
}
输出结果
big=2147483647
bigger=-4
  

你不会从编译器那里收到出错或警告信息，运行时也不会出现异常。这说明虽然java是好东西，但也没有那么好!