9 篇笔记 写笔记

1. #0

   stinkaroo

   190***[email protected]

   108

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

   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);
    }
   }
   

   stinkaroo

   190***[email protected]

   9年前 (2017年05月09日)
2. #0

   妇芳单身骗

   lhm***@126.com

   80

   子类是父类的类型,但父类不是子类的类型。

   子类的实例可以声明为父类型,但父类的实例不能声明为子类型。

   class Vehicle {}
   public class Car extends Vehicle {
    public static void main(String args[]){
    Vehicle v1 = new Vehicle(); //父类型
    Vehicle v2 = new Car(); //子类的实例可以声明为父类型
    Car c1 = new Car(); // 子类型
    Car c2 = new Vehicle(); //这句会报错,父类型的实例不能声明为子类型
    //Car(子类)是Vehicle(父类)类型, Vehicle(父类)不是Car(子类)类型
    boolean result1 = c1 instanceof Vehicle; // true
    boolean result2 = c1 instanceof Car; // true
    boolean result3 = v1 instanceof Vehicle; // true
    boolean result4 = v1 instanceof Car; // false
    boolean result5 = v2 instanceof Vehicle; // true
    boolean result6 = v2 instanceof Car; // true
    System.out.println(result1);
    System.out.println(result2);
    System.out.println(result3);
    System.out.println(result4);
    System.out.println(result5);
    System.out.println(result6);
    }
   }

   从执行结果来看,虽然 v2 被声明为了 Vehicle(父类),但它既是 instanceof Vehicle,又是 instanceof Car,所以 v2 其实是 Car(子类),否则 v2 instanceof Car 应该为 false。

   妇芳单身骗

   lhm***@126.com

   9年前 (2017年11月17日)
3. #0

   无尘

   227***[email protected]

   39

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

   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

   无尘

   227***[email protected]

   7年前 (2019年02月14日)
4. #0

   踏平南天山

   981***[email protected]

   参考地址

   41

   Java 中的运算符的左右结合性是什么意思

   所有的数学运算符都认为是从左到右运算的,Java 语言中大部分运算符也是从左到右结合的,只有单目运算符、赋值运算符和三目运算符例外,其中,单目运算符、赋值运算符和三目运算符是从右向左结合的,也就是从右向左运算。

   乘法和加法是两个可结合的运算,也就是说,这两个运算符左右两边的操作数可以互换位置而不会影响结果。

   当有多中运算符参与运算的时候,先要考虑优先级,有相同优先级的就看结合性以决定运算顺序。

   因为这样,所以,如果没有两个相同优先级的运算,就不存在考虑结合性的问题了。一个 ?: 是体现不出来结合性的。 请看这个:

   a?b:c?d:e

   这个要怎么算?先看优先级,两个一样。再看结合性,右结合,所以先算:

   c?d:e

   再算:

    a?b:(c?d:e)

   这就是所谓右结合。如果是左结合的话 就是先算:

   a?b:c

   再算:

   (a?b:c)?d:e

   实际上,一般结合性的问题都可以用括号来解决。

   踏平南天山

   踏平南天山

   981***[email protected]

   参考地址

   7年前 (2019年06月02日)
5. #0

   _h0pe

   286***[email protected]

   参考地址

   86

   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("输出变量");
    }
   }

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

   _h0pe

   286***[email protected]

   参考地址

   7年前 (2019年08月23日)
6. #0

   _h0pe

   286***[email protected]

   28

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

   区别 1: & 和 | 可以进行位运算,后者不能。

   区别 2: && 和 || 进行运算时有短路性,前者无。

   _h0pe

   286***[email protected]

   7年前 (2019年08月28日)
7. #0

   cf

   211***[email protected]

   21

   整数运算:

   • 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; // 报错
    }
   }

   cf

   211***[email protected]

   7年前 (2019年12月05日)
8. #0

   discovery

   dis***[email protected]

   25

   Java 中关联性顺序不同指左右结合的顺序不同,对于三目运算符,关联性是从右向左的。例如:

   a ? b: c ? d : e

   根据关联性结果为 a ? b : (c ? d : e), 即将右侧运算作为一个整体来进行运算,先进行 a 条件的判断。

   int b = 2;
   int d = (b<1) ? ++b : (b>1) ? --b : 2;
   System.out.println(d) ;//结果为1, b的值为1
   int b = 2;
   int d = (b>1) ? ++b : (b>1) ? --b : 2;
   System.out.println(d) ;//结果为3, b的值为3

   discovery

   dis***[email protected]

   6年前 (2020年05月21日)
9. #0

   wen

   l.z***[email protected]

   12

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

   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。

   wen

   l.z***[email protected]

   5年前 (2021年06月13日)