在判断一个实例引用的类型时，使用的是实际类型，而不是声明的类型。在下面的代码中，

Vehicle v2 = new Car();    // v2 是 Car 类型

v2 是 Car 类型，而不是 Vehicle 类型。

class Vehicle {}

public class Car extends Vehicle {
    public static void main(String args[]){
        Car c1 = new Car();

        Vehicle v2 = new Car();    // v2 是 Car 类型
        Vehicle v3 = new Vehicle();

        //Car 是 Vehicle类型, Vehicle 不是 Car 类型
        boolean result1 =  c1 instanceof Vehicle;    // true
        boolean result2 =  v2 instanceof Car;        // true
        boolean result3 =  v2 instanceof Vehicle;    // true
        boolean result4 =  v3 instanceof Car;          // false

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
   }
}

加法的结合顺序 左->右 所以左侧计算完毕后才会计算右侧 因此结果不同:

public static void main(String[] args) {   
  int a=2;   
  System.out.println(--a/2+(++a*2));  
  System.out.println(++a*2+--a/2);
}

结果：

4
7

C + = A 与 C = C + A 是有区别的一句话总结： += 运算符既可以实现运算，又不会更改 s 的数据类型；而后者，C 和 A 必须是同一类型，否则无法直接运算。

public class Student{
    public static void main(String[] args){
        short s = 10;

        //s = s + 3; 编译不通过
        s = (short)(s + 1); //不建议如此实现
        s += 1;    //既可以实现运算，又不会更改s的数据类型
        System.out.println("输出变量");
    }
}

另外， -= ， *= ， /= 也应同理。

整数运算：

• 1、如果两个操作数有一个为 long，则结果也为 long。
• 2、没有 long 时，结果为 int。即使操作数全为 short、byte，结果也是 int。

public class Main {
    public static void main(String[] args) {
        byte a = 1;
        int b = 2;
        long b2 = 3;
        byte c = a + b;  // 报错
        int c2 = b2 + b;  // 报错
    }
}

以下对两个右移操作符>>和>>>进行测试：

public class Opetator {
    public static void main(String[] args) {
        byte b = -1;
        short s = -1;
        int i = -1;
        long l = -1;
        System.out.println("byte b = " + b);
        System.out.println("(b >> 1) = " + (b >> 1));
        System.out.println("(b >>> 1) = " + (b >>> 1));
        System.out.println(String.format("hexof (b >> 1) = %x", (b >> 1)));
        System.out.println(String.format("hexof (b >>> 1) = %x", (b >>> 1)));
        System.out.println("short s = " + s);
        System.out.println("(s >> 1) = " + (s >> 1));
        System.out.println("(s >>> 1) = " + (s >>> 1));
        System.out.println(String.format("hexof (s >> 1) = %x", (s >> 1)));
        System.out.println(String.format("hexof (s >>> 1) = %x", (s >>> 1)));
        System.out.println("int i = " + i);
        System.out.println("(i >> 1) = " + (i >> 1));
        System.out.println("(i >>> 1) = " + (i >>> 1));
        System.out.println(String.format("hexof (i >> 1) = %x", (i >> 1)));
        System.out.println(String.format("hexof (i >>> 1) = %x", (i >>> 1)));
        System.out.println("long l = " + l);
        System.out.println("(l >> 1) = " + (l >> 1));
        System.out.println("(l >>> 1) = " + (l >>> 1));
        System.out.println(String.format("hexof (l >> 1) = %x", (l >> 1)));
        System.out.println(String.format("hexof (l >>> 1) = %x", (l >>> 1)));
    }
}

输出：

byte b = -1
(b >> 1) = -1
(b >>> 1) = 2147483647
hexof (b >> 1) = ffffffff
hexof (b >>> 1) = 7fffffff
short s = -1
(s >> 1) = -1
(s >>> 1) = 2147483647
hexof (s >> 1) = ffffffff
hexof (s >>> 1) = 7fffffff
int i = -1
(i >> 1) = -1
(i >>> 1) = 2147483647
hexof (i >> 1) = ffffffff
hexof (i >>> 1) = 7fffffff
long l = -1
(l >> 1) = -1
(l >>> 1) = 9223372036854775807
hexof (l >> 1) = ffffffffffffffff
hexof (l >>> 1) = 7fffffffffffffff

可得出以下结论：

1. byte、short、int 类型的右移操作都是先将左操作数转换为int类型，然后执行右移操作，结果也是int类型。

2. long 类型的右移操作并没有对左操作数进行类型转换，结果也是long类型。

3. >>操作对左边空位补符号位，>>>对左边空位补0。