• 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
        }
    }
  • 相关阅读:
    20100320 ~ 20100420 小结与本月计划
    datamining的思考
    谈谈网络蜘蛛 爬开心网001的一些体会
    将 ASP.NET MVC3 Razor 项目部署到虚拟主机中
    Eclipse代码中中文字显示很小的解决办法
    U8800一键ROOT删除定制软件 安装新版Docment to go
    Android(安卓) U8800 长按 搜索键、返回键 锁屏或解锁的设置方法
    JDK5.0新特性系列3.枚举类型
    JDK5.0新特性系列1.自动装箱和拆箱
    网游运营基本概念及专业术语
  • 原文地址:https://www.cnblogs.com/douyunpeng/p/13350965.html
Copyright © 2020-2023  润新知