2021-10-11

JDK8/11

System.out.println();

System.out.print(); //错误

bit（比特，位）：

• 指一个0或者1
• 8bits = 1 byte
• 1024bytes = 1M

操作系统处理的基本单元是字节。

Java中变量的类型：

基本类型（原始类型） byte，short，int，long，float，double，char，boolean

1.  byte 字节类型，占8个bit（比特，位），1字节：最小值Byte.MIN_VALUE：-128， 最大值Byte.MAX_VALUE：127
2.  short短整型，占16个bit（比特，位），2字节：最小值Short.MIN_VALUE：-32768， 最大值Short.MAX_VALUE：32767
3.   int整形，占32bits，4字节，最小值Integer.MIN_VALUE, 最大值是Integer.MAX_VALUE int的取值写法：100， 0， +12， -132， 1_23(_不能开头和结尾)
   1. 二进制整型的表示法： 0B或者0b开头，后面只能跟上0或者1
   2. 八进制整型的表示法： 0开头，后面跟上0-7
   3. 十六进制整型的表示法： 0x或者0X开头，后面跟上0-9，A（10）-F（15）
   4. System.out.println(Integer.toBinaryString(11)); 将十进制的11转换为2进制输出 System.out.println(Integer.toOctalString(11)); 将十进制的11转换为8进制输出 System.out.println(Integer.toHexString(11)); 将十进制的11转换为16进制输出
4.  long长整型，占64bits，8字节，最小值Long.MIN_VALUE, 最大值是Long.MAX_VALUE long的取值写法必须要添加L或者l后缀。1_23L
   1. 关于浮点数，有很多奇怪结果，这些结果并不是Java规定的，而是遵循了IEEE 754国际标准。 没有特殊理由一定要使用double，而且直接书写一个浮点数他的类型默认就是double
5. float单精度浮点数： 32bits float结尾必须加f或者F
6. double双精度浮点数： 64bits double结尾可选加D或者d
7. boolean: 只有true和false两种取值
8. char：尽量不使用char类型，而是使用String替换   计算机中每一个char都占2个字节，且取值范围是0~65535.   而且每一个char都对应一个数值。

科学计数法

数E/e次方: 当次方是正数，小数点向右侧移动若干位，次方是负数，小数点向左侧移动若干位。 3.14E3： 3140.0

31.4e-1： 3.14

3.14e+1： 31.4

'A' '\uXXXX'其中X是十六进制数，必须4位，不足4位用0补齐

System.out.println((int)'A');

char c = 66;

System.out.println(c); 

ASCII编码和Unicode编码

其余常见的特殊写法\t \n \ ' "

引用类型：除了8个基本数据类型之外的所有类型都是引用类型

2，8，10，16的互相换算

1. 2进制转10进制         比如1011
2. 10进制转2进制：辗转相除法      比如21
3. 8进制和2进制的互相换算
   1. 3位作为一个整体来换算，即421编码
   2. 比如有2进制10110111001010换成8进制
   3. 010 110 111 001 010
   4. 2 6 7 1 2
      1. 比如有8进制的721换算成2进制：
      2. 111 010 001
4. 16进制和2进制的互相换算
   1. 4位作为一个整体来换算，即8421编码
   2. 比如有2进制10110111001010换成16进制
   3. 0010 1101 1100 1010
   4. 2 D C A
5. 负数的10进制换成2进制  比如我们要计算-10的二进制
6. 先将要换算的数值当作正数换成二进制，比如int类型10的二进制是
   1. 00000000 00000000 00000000 00001010 （原码）
7. 将其按位求反，得到
   1. 11111111 11111111 11111111 11110101 （反码）
8. 再加1，得到
   1. 11111111 11111111 11111111 11110110 （补码）

注意！！！！！正数的十进制换成二进制，只要用辗转相除法求出原码就可以了。

一个二进制数开头如果是0，其对应的数一定是正数；如果开头是1，其对应的数一定是负数

运算符

1. 算数运算符
   1. / 整除，不带小数
   2. % 求余数，结果的符号位永远和第一个数的符号是相同的。
      1. -10 % -3 = -1
      2. -10 % 3 = -1
      3. 10 % -3 = 1
      4. 10 % 3 = 1
      5. ++/--
2. 逻辑运算符：&& || 短路
3. 比较运算符： > < >= == <= !=
4. 位运算符
   1. &按位与： 将数值都换成二进制数按位进行运算，规则是有0就是0
      1. 3 & 4
      2. 3是00000000000....011
      3. 4是00000000000....100
      4. &——————————————————————
      5. 00000000000....000
   2. |按位或：将数值都换成二进制数按位进行运算，规则是有1就是1
      1. 3 | 4
      2. 3是00000000000....011
      3. 4是00000000000....100
      4. |——————————————————————
      5. 00000000000....111
   3. ^按位异或：
   4. 将数值都换成二进制数按位进行运算，规则是两位相同就是0，不同就是1
      1. 3 ^ 4
      2. 3是00000000000....011
      3. 4是00000000000....100
      4. |——————————————————————
      5. 00000000000....111
   5. ~按位求反：将数值都换成二进制数按位进行运算，规则是0变1，1变0
      1. ~3结果是：
      2. 3的二进制是是00000000 00000000 00000000 00000011
      3. 按位求反得到
      4. 11111111 11111111 11111111 11111100
      5. 这个就是最终结果，
      6. 如果结果是0开头，直接换成十进制即可，
      7. 如果结果是1开头，要想知道这个结果对应的十进制数需要按位求反再+1
      8. << 左移，高位抛弃，低位补0
      9. 12<<2
      10. 00000000000000000000000000110000

      11. 带符号右移： 将一个数值的低位抛弃，高位补0（正数)或者1(负数） 12>>2 00000000 00000000 00000000 00001100>>2

      12. 无符号右移： 将一个数的低位抛弃，高位补0

5. 条件运算符， 三元运算符 ?:
   1. 条件?结果1：结果2
   2. 如果条件是true，则这个运算符最终的结果就是结果1，否则就是结果2
   3. int i = 1>2 ? "abc" : 5; 错误
   4. var i = 1>2 ? "abc" : 5; 正确

语句

1. 空语句;

2. 单条语句

System.out.println();
int i = 1;
i = i + 1;

if(条件) if也是单条语句

语句

for while do-while 尽量不要用

switch语句： 条件处可以放1.置byte， short， int， char， String, enum

public static void main(String... args) { 
    enum Sex{ 
        F,M 
    } 

    Sex sex = Sex.F; 

    switch (sex) {

    }
}

public class Test { 
    public static void main(String... args) { 
        exit: //标签和它标记的循环之间不能有任何其他语句 
        for (int i = 0; i < 100; i++) 
            for (int j = 0; j < 100; j++) 
                for (int k = 0; k < 100; k++) 
                    for (int l = 0; l < 100; l++) 
                        if(i + j + k + k > 30) break exit; //跳出或终止一个深层嵌套的循环                                                              
        System.out.println(); 
    } 
}

保留字： Java中不会发生作用，但是又不允许我们使用的名字。只有goto和const两个

3. 复合语句： 用{}包含起来的语句集合 { var i = 1;, System.out.println(i); }

{ 
    var i = 100; 
    System.out.println(i); 
}

数组：

public class Test {

    public static void main(String... args) {
        int[] nums = {1,2,3,4,};
    
        int nums1[] = {5,6,7,8,};
    
        int[] num2 = new int[10];
    
        int num3[] = new int[]{1,2,3,4};
    
        //二维数组是一个一维数组，其中的每一个元素又是一个一维数组
        int[][] nums3 = new int[3][];
        int[][] nums4 = new int[3][4];
        int[][] nums5 = new int[][4]; //错误
    }

}

命令行参数

public class Test { 
    public static void main(String[] args) { //命令行参数 
        for (String arg : args) 
            System.out.println(arg); 
    } 
}

为了编译和运行带包的java程序，需要先进入这个包的上一层文件夹去执行命令

javac com/domain/Test.java

java com.domain.Test