java运算符

public class TypeCast {

	public static void main(String[] args) {
		short i1 = 10;
		short i2 = 20;
		i1 = (short) (i1 + i2);	//必须显式cast 回short，否则编译错误
		i1 = (short) (i1 >> 2);
		i1 += i2;		//+=运算符会自动将运算结果cast为 运算符左边的类型，所以不需要显式cast
		int i3 = 100;
		i3 = (int) (i3 + 100L);	//当运算数类型比int大时，运算结果转换为较大的类型
		
        	System.out.println(new Integer(1) == 1);
        	System.out.println(new Integer(1) != 1);
        	System.out.println(new Integer(1) != 2);
        	System.out.println(new Integer(1) > 1);
        	System.out.println(new Integer(1) >= 1);
        	System.out.println(new Integer(1) < 1);
        	System.out.println(new Integer(1) <= 1);
        
        	System.out.println("=======================");
        	Integer obj = new Integer(1);
        	System.out.println(obj == new Integer(1));
        	System.out.println(obj != new Integer(1));
        
        	System.out.println(obj > new Integer(1));
        	System.out.println(obj >= new Integer(1));
        	System.out.println(obj < new Integer(1));
        	System.out.println(obj <= new Integer(1));
        
        	System.out.println("=======================");
        	System.out.println(new Boolean(null));
        	System.out.println(new Boolean(""));
        	System.out.println(new Boolean("obj"));
        	System.out.println(new Boolean("false"));
        	System.out.println(new Boolean("true"));
        	System.out.println(new Boolean("TRUE"));

        	System.out.println("=======================");
        	Integer obj1 = 1; //相当于Integer.valueOf(1)
        	Integer obj2 = Integer.valueOf(1);
        
        	System.out.println(obj1 == obj2);
        	System.out.println(obj1 != obj2);
        	System.out.println(obj1 == new Integer(1));
        
        	System.out.println(obj1 > new Integer(1));
        	System.out.println(obj1 >= new Integer(1));
        
        	System.out.println(obj1 < new Integer(1));
        	System.out.println(obj1 <= new Integer(1));
        
        	//常量赋值相当于使用Integer.valueOf(int)，该方法会缓存对象实例，
        	//相同常量的多次调用返回的是同一个封箱对象。
        	//This method will always cache values in the range -128 to 127
        	Integer obj3 = 1024;
        	Integer obj4 = 1024;
        	System.out.println(obj3 == obj4);

        	System.out.println("=======================");
        	String str = null
        	System.out.println(str instanceof String);
        	//编译错误：
        	//System.out.println(new TypeCast() instanceof String);
        	//编译通过，但运行期会抛出异常ClassCastException
        	TypeCast tc = (TypeCast) new Object();
	}
}

 输出为：

true
false
true
false
true
false
true
=======================
false
true
false
true
false
true
=======================
false
false
false
false
true
true

 =======================
true
false
false
false
true
false
true
false

 =======================

false

 

     Java语言规范规定，复合赋值(E1 op= E2)等价于简单赋值(E1 = (T) ((E1) op (E2)))，其中T是E1的类型。

    * 假若对基本数据类型执行任何算术或按位运算，只要它们“比int 小”（即char，byte 或者short），
      那么在正式执行运算之前，那些值会自动转换成int。这样一来，最终生成的值就是int 类型。
      当把一个int类型运算结果赋回较小的类型，就必须使用“造型”。
      此外，由于是将值赋回给较小的类型，所以可能出现信息丢失的情况。
    * 通常，表达式中最大的数据类型是决定了表达式最终结果大小的那个类型。
    * 若将一个float 值与一个double 值相乘，结果就是double；如将一个int 和一个long 值相加，则结果

       为long。

 

    * 逻辑运算符：== != 和 >  >=  <  <=
    * (1) 在其中一个运算项是基本数据类型时，自动拆箱。
    * (2) 运算项都是封箱对象时，==  != 比较对象引用， > >= < <= 会自动拆箱。

 

    * Java 的判等操作符（==和!=）在作用于对象引用时，执行的是引用ID 的比较，而不是值的比较。

       这是为了兼容5.0以前版本。
    * 判等操作符在其两个操作数中只有一个是被包装的数字类型，而另一个是原始类型时，执行的确实是

      数值比较。这种比较在5.0以前是非法的，所以不会出现不兼容。

 

    * 常量赋值相当于使用Integer.valueOf(int)，该方法会缓存对象实例，相同常量的多次调用返回的是

      同一个封箱对象。  

    * Boolean的构造函数Boolean(String name)  return (name != null) && name.equalsIgnoreCase("true")

 

    * instanceof运算符：

      尽管null 对于每一个引用类型来说都是其子类型，但是instanceof 操作符被定义为在其左操作数为null

      时返回false。这被证明是实践中非常有用的行为。如果instanceof 告诉你一个对象引用是某个特定类

      型的实例，那么你就可以将其转型为该类型，并调用该类型的方法，而不用担心会抛出

      ClassCastException 或NullPointerException 异常。

      instanceof 操作符有这样的要求：如果两个操作数的类型都是类，其中一个必须是另一个的子类型。

      所以，new TypeCast() instanceof String是非法的。