Java第五课

Java第五课

一、逻辑运算符

• &&、||、！

• && || 和& |的区别

  &和|是位运算符，是对数字进行运算

  &&和||是逻辑运算符，是对布尔值进行运算

  &&和||有短路的现象，A&&B，如果A为false，则B不被检查

  public class C231 {
      public static void main(String[] args) {
          boolean result = A() && B();
          System.out.println("---------------------");
          result = A() || B();
      }
  ​
      private static boolean A() {
          System.out.println("enter A");
          boolean result = false;
          Random random = new Random();
          result = random.nextBoolean();
          System.out.println("result = "+ result);
          return result;
      }
      private static boolean B() {
          System.out.println("enter B");
          boolean result = false;
          Random random = new Random();
          result = random.nextBoolean();
          return result;
      }
  }

二、赋值运算符

• =、+=，-=.....

  int num = 1;
  num += 2;

• byte b = 1;
  b = b + 2;
  // 错误的，因为2是int型，会把整个表达式的数据类型提升至int型，而赋值的左边是byte型，此时会报错。b=(byte)(b+2)；（b+2）是int型，通过（byte）型强制转换为byte型
  b+=2;
  // 此处的2是byte型,不存在上述问题，一种语法糖的现象，JVM自动帮程序员做了一些处理

三、三目运算符

        byte num = 1;
        boolean b = num == 3 ? true:false;
        String msg = (num == 3) ? "yes" : "no";

System.out.println(c231 instanceof C231);
// c231是否是C231类的实例
// instanceof主要用于判断多态的情况下的对象和类的关系

四、运算符优先级

1. （） .

2. 一元：++,--,!,~

3. 乘除：*,/,%

4. 加减：+,-

5. 位移：<<,>>,>>>

6. 关系：==,!=,>,<,>=,<=

7. 与：&

8. 异：^

9. 或：|

10. 逻辑：&&，||

11. 三目：？：

12. 赋值：=,乘除，加减，位移和赋值混合

public class C233 {
    public static void main(String[] args) {
        byte n1 = 5;
        byte n2 = 6;
        // 5+6*7
        int n3 = n1++ + n1++ * n1++;
        System.out.println(n3);
         byte n1 = 5, n2 = 6;
        // 5 + 4 << 2 + 4 * 5 >> 2
        // 5 + 4 << 2 + 20 >> 2
        // 9 << 22 >> 2
        int n3 = n1-- + n1 << 2 + n1++ * --n2 >> 2;
        System.out.println(n3);
        byte b1 = 8, b2 = 3;
        // 8 - 3 * (8 * 8 << 2)
        // 8 - 3 * 256
        int num = b1-- - b2++ * (++b1 * b1 << 2);
    }
}

        byte b1 = 2;
        byte b2 = 3;
        // 关系运算符比&|^运算符的优先级高
        System.out.println(b1>b2 & b2>b1);
        System.out.println(b1>b2 | b2>b1);
        System.out.println(b1>b2 ^ b2>b1);
        System.out.println(true & false);

    public static void main(String[] args) {
        byte b1 = 7;
        byte b2 = 9;
        byte b3 = 10;
        byte b4 = 12;
        // 7 & 9 ^ 10 | 12
        // 0000 0111
        // 0000 1001
        // 0000 0001
        // 0000 1010
        // 0000 1011
        // 0000 1100
        // 0000 1111
        System.out.println(b1 & b2 ^ b3 | b4);
    }

    public static void main(String[] args) {
        byte b1 = 7;
        byte b2 = 9;
        byte b3 = 10;
        byte b4 = 12;
        // 7+(9+(9+9))
        System.out.println(b1++ + (++b1 + (b1-- + ++b1)));
    }

    public static void main(String[] args) {
       byte b1 = 5;
       byte b2 = 6;
       // 5 | 6 ^ 7 & 4 * 7 * 3
       int num = b1++ | b2-- ^ ++b1 & --b2 * b1-- * --b2;
       // 0000 0111
        // 0101 0100
        // 0000 0100
        // 0000 0110
        // 0000 0010
        // 0000 0101
        // 0000 0111
        System.out.println(num);
    }

五、动态数组

• 数组本身是固定元素个数的，但是为了储存数据，这个数组可能会满，解决这个问题。发现数组满了，就新建一个更大的数组，把原数组的数据复制过来，并销毁原数组。

• 数组就像一个仓库。一次性新建超大仓库不可取，会浪费空间。每次都比原来的大一点，也不可取，会效率低下。

• 新建仓库是原来的1.5倍比较合适。

• 比如：原数组int[] arr = new int[]{1,2,3,4}

• 4 + (4>>1) arr.length + (arr.length >> 1)

• int[] newArr = new int[6];

• for(int i = 0; i<arr.length;i++){

  newArr[i] = arr[i];

  }

public class C234 {
    /**
     * 存储数据的数组
     */
    int[] arr;
    /**
     * 当前的位置
     */
    int index = 0;
​
    /**
     * 无参的默认构造方法
     */
    public C234() {
        // 知识点，构造方法嵌套调用，直接写this，不写方法名
        // 此代码只能是第一行
        this(4);
    }
​
    /**
     * 初始化对象
     * @param capacity 数组初始值
     */
    public C234(int capacity) {
        this.arr = new int[capacity];
    }
    public static void main(String[] args) {
        C234 c234 = new C234();
        for (int i = 0; i < 10; i++) {
            c234.add(i);
        }
        System.out.println(Arrays.toString(c234.arr));
    }
​
    /**
     * 增加一个数字
     * @param num
     */
    public void add(int num) {
        if (index < arr.length) {
            arr[index++] = num;
        }else {
            int length = arr.length + (arr.length >> 1);
            arr = Arrays.copyOf(arr, length);
        }
​
    }
}