2020年7月20日 JAVA 第二章、基础语法

/*
进制：（了解）
1、进制的分类
十进制：
    数字范围：0-9
    进位规则：逢十进一
二进制：
    数字范围：0-1
    进位规则：逢二进一
八进制：
    数字范围：0-7
    进位规则：逢八进一
十六进制：
    数字范围：0-9、A-F（或者a-f）
    进位规则：逢十六进一

        十进制    二进制    八进制    十六进制
0        0        0        0        0
1        1        1        1        1
2        2        10        2        2
3        3        11        3        3
4        4        100        4        4
5        5        101        5        5
6        6        110        6        6
7        7        111        7        7
8        8        1000    10        8
9        9        1001    11        9
10        10        1010    12        A
11        11        1011    13        B
12        12        1100    14        C
13        13        1101    15        D
14        14        1110    16        E
15        15        1111    17        F
16        16        10000    20        10
。。。。

25        25        11001    

本质上，就是生活中的十进制，和计算机世界中的二进制
因为在计算机中二进制数字太长了，在代码中去表示二进制很繁琐，
那么引入了八进制和十六进制，为了快速和简短的表示二进制

（1）十进制-->二进制
（2）二进制-->八进制
把二进制从最右边开始，三位一组
（3）二进制-->十六进制
把二进制从最右边开始，四位一组

2、在程序中如何表示某个数字是十进制、二进制、八进制、十六进制
十进制，正常写
二进制，在数字前面加0B或0b
八进制，在数字前面加0
十六进制，在数字前面加0X或0x

3、为什么byte类型的范围是-128~127？
byte是1个字节，1个字节是8位
计算机中是使用“补码”的形式来存储数据的，为了理解/换算“补码”，我们在引入“原码、反码”。
规定：正数的原码、反码、补码三码合一；
      负数的原码、反码、补码是不同的。
      因为计算机中把最高位（最左边的二进制位）定为符号位，0表示正数，1表示负数。
      
25：
    原码：0001 1001
    反码：0001 1001
    补码：0001 1001
-25：
    原码：1001 1001
    反码：1110 0110   符号位不变，其余位取反（0变1,1变0）
    补码：1110 0111   在反码上加1
    
正0: 0000 0000

正数：
    0000 0001   : 1
        |
    0111 1111    : 127
负数：补码
    1000 0001    ：  补码（1000 0001）-》反码（1000 0000）--》原码（1111 1111） -127
        |
    1111 1111    ：    补码（1111 1111）-》反码（1111 1110）--》原码（1000 0001）-1
    
负0：1000 0000    如果用它表示负0，就浪费了，所以用它来表示其他的数
    -127的二进制的补码：1000 0001
    1的二进制的补码：0000 0001
    
    -127 - 1 = （补码：1000 0001）-（补码：0000 0001） = 补码（1000 0000） = -128
    计算机中用符号位来表示正、负，就是为了底层设计的简化，让符号位也参与计算。
    
*/
class Test01_JinZhi{
    public static void main(String[] args){
        System.out.println(10);//十进制，正常写
        System.out.println(0B10);//二进制，在数字前面加0B或0b
        System.out.println(010);//八进制，在数字前面加0
        System.out.println(0X10);//十六进制，在数字前面加0X或0x
    }
}

/*
了解：浮点型的float和double在底层如何存储？
计算机中只有二进制？
那么如果存储3.14？
小数涉及：（1）整数部分（2）小数部分（3）这个.（4）正负号

化繁为简：
1、小数-->二进制：
（1）整数部分：除2倒取余
（2）小数部分：乘2取整数部分
3.14==》11.00100...
2、把这个二进制用科学记数法表示
    1.1 00100.... * n的1次方
用科学计数法表示后，对于二进制的科学计数法，整数部分永远是1，那这样的话，
整数部分就不用存了，小数点也不存了

只要存三个内容：（1）正负号（2）挪完后的几次方，指数（3）二进制的小数部分（称为尾数）
float：4个字节，就被分为三个部分，最高位还是符号位，接下来的8位用来存指数部分，然后剩下的存尾数，额如果存不下的尾数，就舍去了
double：8个字节，就被分为三个部分，最高位还是符号位，接下来的11位用来存指数部分，然后剩下的存尾数，额如果存不下的尾数，就舍去了

了解：
（1）浮点类型不精确，因为十进制的小数部分转二进制会需要舍去
（2）float类型的4个字节能表示的数字范围比long类型的8个字节还要大
因为浮点型底层存的是指数
*/
class Test02_FloatDoubleSave{
}

/*
基本数据类型之间的转换：
（1）自动类型转换
①把存储范围小的类型的值赋值给存储范围大的类型的变量，自动可以完成升级
byte->short->int->long->float->double
        char->
②boolean不参与
③byte,short,char如果进行算术运算都会自动升级为int


（2）强制类型转换
①把存储范围大的类型的值，赋值给存储范围小的类型变量时，需要强制类型转换
double->float->long->int->short->byte
                        ->char
强制类型转换是有风险的：可能会溢出或损失精度                        
②boolean不参与    
③当需要把某个存储范围小的变量强制提升为存储范围大的类型时，也可以使用强制类型转换            
*/
class Test03_TypeChange{
    public static void main(String[] args){
        /*
        从左边看d1是double类型
        从右边看10是int类型
        int类型的值，赋值给了double类型的变量，那么它会自动升级为double
        */
        double d1 = 10;
        System.out.println("d1 = " + d1);
        
        
        /*
        从左边看i1是int类型
        从右边看10.0是double类型
        double类型的值，赋值给int类型的变量，如果直接赋值会报错：错误: 不兼容的类型: 从double转换到int可能会有损失
        */
        //int i1 = 10.3;
        int i1 = (int)10.3;
        System.out.println("i1 = " + i1);
        
        byte b1 = 127;
        byte b2 = 2;
        //byte b3 = b1 + b2;//报错：不兼容的类型: 从int转换到byte可能会有损失，因为byte+byte就自动升级为int
        byte b3 = (byte)(b1 + b2);
        System.out.println("b3 = " + b3);
        
        short s1 = 1;
        short s2 = 2;
        //short s3 = s1 + s2;//short+short会自动升级为int
        short s3 = (short)(s1 + s2);
        System.out.println("s3 = " + s3);
        
        char c1 = ‘0‘;//‘0‘的编码值是48
        char c2 = ‘1‘;//‘1‘的编码值是49
        //char c3 = c1 + c2;//char+char会自动升级为int
        char c3 = (char)(c1 + c2);
        System.out.println("c3 = " + c3);//‘a‘
        
        boolean flag = true;
        //int num = (int)flag;//不兼容的类型: boolean无法转换为int
        
        int x = 1;
        int y = 2;
        System.out.println("x / y = " + x/y);//整数/整数，结果还是整数，只保留整数部分
        System.out.println("x / y = " + (double)x/y);//把x的int类型先强制升级为double类型
        
    }
}

/*
数据类型转换的特例：字符串类型
    所有类型与字符串“+”拼接，结果都是字符串
*/
class Test04_TypeChange{
    public static void main(String[] args){
        char c1 = ‘0‘;
        char c2 = ‘1‘;
        
        /*
        c1 + c2，按照求和运算，char + char结果是int
        ""代表空字符串，
        当int的97与""进行 “+”拼接，结果还是97的字符串
        */
        System.out.println(c1 + c2 + "");//97
        
        /*
        "" + c1，按照“拼接”运算，字符串 + char，结果是字符串，结果是"0"
        "0" + c2，按照“拼接”运算，字符串 + char，结果是字符串，结果是"01"
        */
        System.out.println("" + c1 + c2 );//01
        
        /*
        c1 + ""，按照“拼接”运算，char + 字符串 ，结果是字符串，结果是"0"
        "0" + c2，按照“拼接”运算，字符串 + char，结果是字符串，结果是"01"
        */
        System.out.println(c1 + "" + c2 );//01
    }
}

/*
运算符：
1、算术运算符
加：+
减：-
乘：*
除：/    
    特殊：整数/整数，结果只保留整数部分
取模（取余）：%
    特殊：只看被模数的正负号
    被模数%模数

正号：+
负号：-    

自增：++
    对于自增变量本身来说，都会+1.
    但是++在前还是在后，对于整个表达式的计算来说是不一样的。
    ++在前，先自增，然后取自增后变量的值，
    ++在后，先取变量的值，然后变量自增。
    但是不管怎么样，自增变量的取值与自增操作一前一后一定是一起完成的。
自减：--
    类同自增

*/
class Test05_Arithmetic{
    public static void main(String[] args){
        int x = 10;
        int y = 3;
        
        //System.out.println("x + y = " + x + y);//变为拼接
        System.out.println("x + y = " + (x + y));
        System.out.println("x - y = " + (x - y));
        System.out.println("x * y = " + (x * y));
        System.out.println("x / y = " + (x / y));
        System.out.println("x % y = " + (x % y));
        
        System.out.println("----------------------------------");
        System.out.println("5%2 = " + 5%2);
        System.out.println("-5%2 = " + -5%2);
        System.out.println("5%-2 = " + 5%-2);
        System.out.println("-5%-2 = " + -5%-2);
        
        System.out.println("----------------------------------");
        int a = -3;
        System.out.println(-a);
        
        System.out.println("----------------------------------");
        int i = 2;
        i++;
        System.out.println("i = " + i);
        
        int j = 2;
        ++j;
        System.out.println("j = " + j);
        
        System.out.println("----------------------------------");
        int m = 1;
        int n = ++m;//m先自增，然后把m的值取出来赋值给n
        System.out.println("m = " + m);//2
        System.out.println("n = " + n);//2
        
        System.out.println("----------------------------------");
        int p = 1;
        int q = p++;//（1）先取出p的值"1"，先放到一个“操作数栈”，（2）然后p变量完成自增（3）把刚才放在“操作数栈”中的值赋值给q
        System.out.println("p = " + p);//2
        System.out.println("q = " + q);//1
        
        System.out.println("----------------------------------");
        int z = 1;
        z = z++;//(1)先取出z的值"1"，先放到一个“操作数栈”，（2）然后z自增，变为2（3）把刚才放在“操作数栈”中的值赋值给z
        System.out.println("z = " + z);
        
        System.out.println("----------------------------------");
        int b = 1;
        int c = 2;
        /*
        第一个：b++
        （1）先取b的值“1”，先放到一个“操作数栈”，
        （2）紧接着b就自增了，b=2
        第二步：++b
        （1）先b自增，b=3
        （2）紧接着再取b的值“3”，先放到一个“操作数栈”，
        第三步：++b
        （1）先b自增，b=4
        （2）紧接着再取b的值“4”，先放到一个“操作数栈”，
        第四步：c++
        （1）先取c的值“2”，先放到一个“操作数栈”，
        （2）紧接着c自增，c=3
        第五步：算乘 ++b和c++的乘法部分
        4*2 = 8 然后在压回“操作数栈”，
        第六步：再算 b++ + ++b + 乘的结果
            1 + 3 + 8 = 12
        */
        int d = b++ + ++b + ++b * c++;
        System.out.println("b = " + b);//4
        System.out.println("c = " + c);//3
        System.out.println("d = " + d);//12
    }
}

class Test06_Exer1{
    public static void main(String[] args){
        int i = 1;
        /*
        第一步：i++
        （1）先取i的值“1”，放起来
        （2）i自增，i=2
        第二步：++i
        （1）先自增，i=3
        （2）再取i的值“3”，放起来
        第三步：计算求和 1 + 3 = 4
        
        */
        System.out.println(i++ + ++i);//4
        System.out.println(i);//3
    }
}

class Test06_Exer2{
    public static void main(String[] args){
        int i = 1;
        int j = 2;
        /*
        第一步：i++
        （1）先取i的值“1”，放起来
        （2）i自增,i=2
        第二步：j
        （1）取j的值，放起来
        第三步：
        求乘积，1*2 = 2，再把结果放起来
        第四步：++j
        （1）先自增，j=3
        （2）再取j的值“3”，放起来
        第五步：求和  2 + 3 = 5
        
        
        */
        System.out.println(i++ * j + ++j);//5
    }
}

class Test06_Exer3{
    public static void main(String[] args){
        int i = 1;
        int j = 2;
        /*
        第一步：++i
        (1)先自增,i=2
        (2)在取i的值“2”，放起来
        第二步：j
        (1)取j的值“2”，放起来
        第三步：++i
        (1)先自增，i=3
        (2)在取i的值"3"，放起来
        第四步：求乘积
        2 * 3 = 6，结果放起来
        第五步：求和
        2 + 6 = 8
        */
        System.out.println(++i + j * ++i);
    }
}

/*
已知一个三位数，例如：483，如何用代码求出它的百位、十位、个位数
*/
class Test07_Exer4{
    public static void main(String[] args){
        int num = 483;
        
        int bai = num / 100;
        //int shi = num/10%10;
        int shi = num%100/10;
        int ge = num % 10;
        
        System.out.println(num + "的百位：" + bai + "，十位：" + shi +"，个位：" + ge);
    }
}

//判断运行结果
class Test08_Exer5{
    public static void main(String[] args){
        int number1 = 10;  
        int number2 = 20;  
        int number3 = number1 + number2;
        System.out.println("Number3 = " + number3);//30
 
        int number4 = 50;
        int number5 = number4 - number3;
        System.out.println("Number5 = " + number5);//20
    }
}

class Test08_Exer6{
    public static void main(String[] args){
        int no = 10;
        String str = "abcdef";
        String str1 = str + "xyz" + no;//abcdefxyz10
  
        str1 = str1 + "123";//abcdefxyz10123
        char c = ‘国‘;
  
        double pi = 3.1416;
        str1 = str1 + pi;//abcdefxyz101233.1416
        
        boolean b = false;
        str1 = str1 + b;//abcdefxyz101233.1416false
        str1 = str1 + c;//abcdefxyz101233.1416false国
 
         System.out.println("str1 = " + str1);        
    }
}

class Test08_Exer7{
    public static void main(String[] args){
        /*
        String str1 = 4;
        左边是String字符串类型，右边是4int类型，它们之间无法自动类型转换        
        */
        //String str1 = 4;            
        String str2 = 3.5f + "";        
        System.out.println(str2);   //3.5    
        System.out .println(3+4+"Hello!");  //7Hello!  
        System.out.println("Hello!"+3+4); // Hello!34    
        System.out.println(‘a‘+1+"Hello!");   // 98Hello!
        System.out.println("Hello"+‘a‘+1);  //Helloa1
    }
}

class Test08_Exer8{
    public static void main(String[] args){
        short s = 5;
        //s = s-2;   //short - int，结果是int     
        
        byte b = 3;
      //  b = b + 4;    //byte + int，结果是int         
        b = (byte)(b+4);   //可以 
        
        char c = ‘a‘;
        int  i = 5;
        float d = .314F;//非标准写法，如果整数部分是0，可以省略0，但不能省略小数点
        double result = c+i+d;   //char + int + float，结果是float，然后自动升级为double  
        
        
        byte b = 5;
        short s = 3;
        short t = s + b;  //short + byte，结果是int
    }
}