大数据之Java基础(二):Java基础语法 [上]

1、关键字

        关键字 :被Java语言赋予特定含义的单词

        特点 :组成关键字的字母全部小写

        注意事项goto和const作为保留字存在,目前并不使用 ,类似IDEA这样的集成工具,针对关键字有特殊的颜色标记,非常直观。加上下列50个共有52个关键字:

2、常见命名规则

2.1、标识符

        标识符:给类,接口,方法,变量等起名字时使用的字符序列
        组成:1、英文大小写字母
                   2、数字
                   3、$和_

         注意事项:  
                1、不能以数字开头
                2、不能有除$和_以外的特殊字符出现
                3、不能是java关键字

 2.2、其他

    2.2.1、包(理解为一个文件夹/目录)

              单级文件夹(所有字母全部小写)

                 举例:bigdata

              多级文件夹(所有字母全部小写,文件夹之间用 . 分开)

                 举例:com.bigdata.rz

           2.2.2、类或者接口

               一个单词组成(首字母大写其余字母小写)

                  举例:Hello

               多个单词组成(所有单词的首字母大写,其余字母小写)

                   举例:HelloWorld

            2.2.3、方法和变量

                一个单词组成(所有字母小写)

                   举例:eat

                多个单词组成(第一个单词全部小写,从第二个单词开始,首字母大写,其余字母小写)

                   举例:playGame

             2.2.4、常量

                  一个单词组成(所有字母全部大写)

                    举例:NAME

                   多个单词组成(所有字母全部大写,单词与单词之间用下划线连接)

                     举例:FIRST_NAME

3、注释

        注释 :用于解释说明程序的文字 Java中注释分类格式

        单行注释格式: // 注释文字

        多行注释格式: /*  注释文字  */

        文档注释格式:/** 注释文字 */

                注释是一个程序员必须要具有的良好编程习惯。 初学者编写程序可以养成习惯:先写注释再写代码。 将自己的思想通过注释先整理出来,在用代码去体现。 因为代码仅仅是思想的一种体现形式而已。

// 声明一个类,类名为HelloWoeld
class HelloWorld {
    // 定义main函数,使程序能被jvm调用
    public static void main(String[] args){
        // 调用输出函数,输出:HelloWorld!
        System.out.println("HelloWorld!");
    }
}

4、常量

        常量在程序执行的过程中其值不可以发生改变 。Java中常量分为字面值常量自定义常量

4.1、常量的分类

(1)字面值常量

字符串常量    用双引号括起来的内容    "abc"

整数常量        所有整数                         12,23

小数常量        所有小数                         12.34,56.78

字符常量        用单引号括起来的内容    ‘a’,’A’,’0’

布尔常量        较为特有,只有true和false

空常量           null(数组部分讲解)

(2)自定义常量(面向对象部分讲解)

4.2、进制

4.2.1、不同进制的数据组成

二进制:由0,1组成,以0b开头

八进制:由0,1,...,7组成,以0开头

十进制:由0,...,9组成,整数默认是十进制的

十六进制:有0,1,...,9,a,b,c,d,e,f组成,以0x开头

4.2.2、进制转换 

其他进制转十进制:系数*基数^权的和

十进制转其他进制:除基取余,直到商为0,余数反转

二进制与十进制的快速转换:8421码

任意进制之间的转换:1、以十进制为桥梁   
                                    2、拆分组合法
                                          a: 八进制3位为一组
                                          b: 十六进制4位为一组

/*
        Java针对整数常量提供了4种表现形式:
            二进制
                由0,1组成。以0b开头
            八进制
                由0,1,2,3,4,5,6,7组成。以0开头
            十进制
                由0,1,2,3,4,5,6,7,8,9组成。整数默认就是十进制的
            十六进制
                由0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f组成。以0x开头

        1、求32的二进制,八进制,十六进制。
        32的二进制:
            32/2 = 16 .....  0
            16/2 = 8  .....  0
            8/2  = 4  .....  0
            4/2  = 2  .....  0
            2/2  = 1  .....  0
            1/2  = 0  .....  1

            32的二进制为:0b100000

       32的八进制:
            32/8 = 4  ..... 0
            4/8  = 0  ..... 4

            32的八进制为:040

       32的十六进制:
            32/16 = 2  ..... 0
            2/16  = 0  ..... 2

            32的十六进制为:0x20

        2、0b10010的十进制
        二进制:                                               十进制:18
        0b10010  = 1*2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 0*2^0
                 = 16 + 0 + 0 + 2 + 0
                 = 18

        3、求下面各进制对应的十进制
        0b10101 = 1*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0
                = 16 + 0 + 4 + 0 + 1
                = 21

        0123 = 1*8^2 + 2*8^1 + 3*8^0
             = 64 + 16 + 3
             = 83

        0x3c = 3*16^1 + 12*16^0
             = 48 + 12
             = 60
        4、0b100110的八进制      046
           100 110
             4   6 
        5、0b100110的十六进制    0x26
           10   0110
            2      6
 */

 4.3、有符号数据表示法

        在计算机内,有符号数有3种表示法:原码、反码和补码。所有数据的运算都是采用补码进行的。

        原码:就是二进制定点表示法,即最高位为符号位,“0”表示正,“1”表示负,其余位表示数值的大小。

        反码:正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外。

        补码:正数的补码与其原码相同;负数的补码是在其反码的末位加1。    

5、数据类型

    5.1、基本数据类型(从小到大)

       整数类型:
        byte          1个字节         -2^7~2^7-1
        short         2个字节         -2^15~2^15-1
        int             4个字节         -2^31~2^15-1
        long          8个字节         -2^63~2^63-1

       浮点类型:
        float          4个字节         -3.403*10^38 ~ 3.403*10^38
        double      8个字节         -1.798*10^308 ~ 1.798*10^308

       字符型:
        char          2个字节

        布尔型:

        boolean    1个字节


    5.2、引用数据类型(面向对象部分讲解)

    5.3、数据类型转换

     自动类型转换:
        byte,short,char在参与运算的时候会自动提升到int类型
        由大的数据类型接收小的数据类型,会自动转换,不会报错。
    强制类型转换
        由小的数据类型接收大的数据类型,会报错,接收不了,这时候需要强制类型转换
        格式:目标数据类型 目标变量名 = (目标数据类型)要转换的数值/变量

/*
        byte b = 130;有没有问题?如果我想让赋值正确,可以怎么做?结果是多少呢?
            有问题,因为byte数据类型的范围是在-128~127之间,而130超出了范围。


 */
public class DataTypeDemo{
    public static void main(String[] args) {
//        byte b = 130;

        byte b = (byte)130;
        System.out.println(b);  // -126
        b = (byte)131;
        System.out.println(b);

        byte b1 = (byte)300;
        System.out.println(b1); // 44
    }
}

/*
        我们知道数据在计算机中运算的时候是采用补码的形式参数运算的,所以要知道130的补码
        而想要知道补码,就得知道反码,原码,所以得求出130的二进制的表示:
        130的二进制:10000010
        由于整数默认是int类型,所以扩大字节
        130的原码为:00000000 00000000 00000000 10000010
        又由于最高位是0,所以它的原码,反码,补码都一样
        130的补码:00000000 00000000 00000000 10000010
        做截取操作:10000010 这是补码

        已知补码,求原码:
               符号位   数值位
        补码:    1     0000010
        反码:    1     0000001
        原码:    1     1111110

        最终结果为:11111110
        将它换算成十进制就是我们看到的结果:-126



 */

6、运算符

6.1、算数运算符

 6.1.1、+,-,*,/,%

/*
        System.out.println(“hello”+’a’+1);
        System.out.println(‘a’+1+”hello”);
        System.out.println(“5+5=”+5+5);
        System.out.println(5+5+”=5+5”);

        +号的用法:
            1、当加号两边都是数字或者是数字和字符的时候,这时候的+号做的是加法运算
            2、当加号两边其中是字符串的时候,做的是字符串拼接,拼接后是一个新的字符串
            3、字符串与任何数值做加法,做的是字符串拼接,拼接后是一个新的字符串

 */
public class DataTypeDemo{
    public static void main(String[] args) {
        System.out.println("hello"+'a'+1); // helloa1
        System.out.println('a'+1+"hello"); // 98hello
        System.out.println("5+5="+5+5); // 5+5=55
        System.out.println(5+5+"=5+5"); // 10=5+5

        //System.out.println("5+5="+5+5); // 5+5=55 我想先计算后面的5+5怎么办?
        //小括号可以改变运算的顺序优先级
        System.out.println("5+5="+(5+5));
    }
}
/*
        运算:
            对常量和变量进行操作的过程称为运算。

        运算符:
            对常量和变量进行操作的符号称为运算符

        操作数:
            参与运算的数据

        表达式:
            用运算符把常量或者变量连接起来符号并且符合java语法的式子就可以称为表达式。
            不同运算符连接的式子体现的是不同类型的表达式。

        算术运算符:
            +,-,*,/,%,++,--
 */
public class OptArithmeticDemo{
    public static void main(String[] args) {
        //+ 加法运算
        System.out.println(1+1);    //2

        //-减法运算
        System.out.println(5-2);    //3

        //* 乘法运算
        System.out.println(2*2);    //4

        //  / 整除运算,只获取整数部分
        System.out.println(5/2);    //2
        // 我就想获取小数怎么办?将其中的某一个数的数据类型变成double
        System.out.println((5*1.0)/2); // 2.5

        // %  取余运算
        // 5/2=2 .... 1
        System.out.println(5%2);    //1

    }
}

6.1.2、++,--

/*
        1:基本小题目
	        int a = 10;
	        int b = 10;
	        int c = 10;

	        a = b++;
	        c = --a;
	        b = ++a;
	        a = c--;
	请分别计算出a,b,c的值

 */
public class OptArithmeticDemo{
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 10;

        a = b++; // a=10  ,b=11  ,c=10
        c = --a; // a=9  ,b=11  ,c=9
        b = ++a; // a=10  ,b=10  ,c=9
        a = c--; // a=9  ,b=10  ,c=8

        System.out.println(a); // 9
        System.out.println(b); // 10
        System.out.println(c); // 8
    }
}
/*
                int a = 4;
                int b = (a++)+(++a)+(a*10);

 */
public class OptArithmeticDemo{
    public static void main(String[] args) {
        int a = 4;
        int b = (a++)+(++a)+(a*10);
        //        4     6      60
        //       a=5   a=6    a=6

        System.out.println(a);//6
        System.out.println(b);//70
    }
}

6.2、赋值运算符

    short s=1, s = s+1;
    short s=1, s += 1;
    上面两个代码有没有问题,如果有,那里有问题?
            第一个有问题,因为变量参与运算,首先会提升数据类型,然后做运算。所以 s = s+1;s会提升到int类型然后再做加法运算,最终的结果是int类型,所以拿short类型接收会报错,所以要想成功赋值,就得强制类型转换。

            第二个代码没有问题,是因为内部自动包含了强制类型转换,s+=1 ===>  s = (s的数据类型)(s+1)

/*
        赋值运算符:  = , +=, -=, *=, /=, %=
        其中我们一直在使用的也是最常用的:=
 */
public class OptFuZhiDemo{
    public static void main(String[] args) {
//        int a = 10;
//        int b = a;
//        System.out.println(a);
//        System.out.println(b);

        // +=
//        int a += 10;
        int a = 10;
        a += 20; //这里实际上可以看作为a的值加上了一个20再赋值给a
                 //但是不能完全等于 a = a + 20
                 //因为a += 20等价于a = (int)(a + 20)
        System.out.println(a);

        //-=
        a-=10;
        System.out.println(a); //20

        //*=
        a*=2;
        System.out.println(a); //40

        // /=
        a/=2;
        System.out.println(a); //20

        // %=
        a%=3;
        System.out.println(a); //2


    }
}

6.3、关系运算符

关系运算符: ==,!=,>,<,>=,<=

       注意事项:
            1、关系运算符的表达式的结果是一个boolean类型,要么是true,要么是false
            2、==不能少写,一个=是赋值运算符,==才是关系运算符
            3、赋值的时候要注意类型问题,关系运算符表达式的结果是boolean类型,所以接收的时候只能是boolean类型的变量接收。

public class OptGuanXiDemo{
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        boolean flag = (a == b);
        System.out.println(flag);    //false

        //!=
        System.out.println(a != b);    //true

        //>
        System.out.println(a>b);    //false

        //<
        System.out.println(a<b);    //true

        //>=
        a = 4;
        System.out.println(a>=b);    //true

        //<=
        System.out.println(a<=b);    //true

        System.out.println(a==b);    //true
        System.out.println(a=b);     //4
    }
}

6.4、逻辑运算符

逻辑运算符: &,|,^,!,&&,||

       逻辑运算符的两边放的是boolean类型的值,计算的结果也是一个boolean类型的值

       &: 参与运算的时候,有false,则false,两边都做运算
       |: 参与运算的时候,有true,则true,两边都做运算
       ^: 参与运算的时候,相同为false,不同为true,两边都做运算
       !: 将true变成false,false变成true

      &&: 短路与,结果和单个与结果一样,有false则false,但是执行的东西不一样,
            当&&左边的表达式结果为false的时候,结果是false,右边不执行
       ||: 短路或,结果和单个或结果一样,有true则true,但是执行的东西不一样,
            当||左边是true的时候,右边不执行,结果是true.

        逻辑运算符用于连接布尔型表达式,在Java中不可以写成3<x<6,应该写成x>3 & x<6

6.5、三目运算符

三目运算符:又称之为三元运算符
     格式:(关系表达式)?表达式1:表达式2;
        如果关系表达式的结果为true,运算后的结果是表达式1;
        如果关系表达式的结果为false,运算后的结果是表达式2;

    注意事项:
        1、三目运算符表达式的结果数据类型由三目运算符表达式1和表达式2中最大的数据类型决定的。
        2、关系表达式一定只能是boolean类型

public class OptSanMuDemo{
    public static void main(String[] args) {
        //求出a,b中的最大值
        int a = 10;
        int b = 30;
        //三目运算符解决
        int c = (a>b)?a:b;
        System.out.println(c);    //30


      /*面试题:
        int a1 = 20;
        double b1 = 30.0;
        double c1 = (a1>b1)?a1:b1;
        System.out.println(c1);    //30.0,数据类型取决于a1,b1最大的数据类型
      */

    }

6.6、位运算符

/*
        位运算符:
            <<,>>,>>>,&,|,^,~
 */
public class OptWeiDemo{
    public static void main(String[] args) {
        byte a = 3;
        byte b = 4;
        System.out.println(a&b);
        System.out.println(a|b);
        System.out.println(a^b);
        System.out.println(~a); //-4
    }
}
/*
        由于数据在计算机中参与运算的都是补码,而想要知道补码,就得知道反码,原码,就得求出二进制
        3的二进制:00000011
        4的二进制:00000100
        又由于3和4都是正数
        3的补码:00000011
        4的补码:00000100

        & 运算:有0则0
            00000011
         &
            00000100
        ---------------
            00000000

        结果是 : 0

        ====================================

        | 运算:有1则1
            00000011
         |
            00000100
        --------------
            00000111

        结果是:7

        ====================================

        ^ 运算:相同则0,不同则1
            00000011
         ^
            00000100
        --------------
            00000111

        结果是:7

        ====================================

        ~ 运算:1变成0,0变成1
            00000011
        ~
        -------------
        补码:     11111100
        已知补码求原码:
        反码:     11111011
        原码:     10000100

        结果是:-4

 */
/*
        位运算符:
        <<: 左移,二进制左移,右边用0补齐,多出来的丢弃
        >>: 右移,最左边最高位是0用0补齐,最高位是1就用1补齐,多出来的丢弃。
        >>>: 无符号右移,无论左边最高是0还是1,都用0补齐,多出来的丢弃。

 */
public class OptWeiDemo2 {
    public static void main(String[] args) {
        System.out.println(3<<2); //12 = 3*4 = 3*2^2
        System.out.println(24>>2); //6 = 24/(2*2)
        System.out.println(-24>>2);// -6
        System.out.println(-24>>>2);//1073741818

        System.out.println(3<<3); // 3*2^3

    }
}

/*
       <<: 左移,二进制左移,右边用0补齐
       3的二进制:00000000 00000000 00000000 00000011
       由于3是正数,所以原码,反码,补码都一样
       3的补码:00000000 00000000 00000000 00000011
       左移:
            00000000 00000000 00000000 00000011
        (00)00000000 00000000 00000000 00001100   (补码)
      由于最高位是0,既是补码也是原码,所以结果是:  12

      ================================================================
      >>: 右移,最左边最高位是0用0补齐,最高位是1就用1补齐,多出来的丢弃。
      24的二进制:00000000 00000000 00000000 00011000
      由于24是正数,所以原码,反码,补码都一样
      24的补码:00000000 00000000 00000000 00011000
      右移:
              00000000 00000000 00000000 00011000
              0000000000 00000000 00000000 000110(00)  (补码)
      由于最高位是0,既是补码也是原码,所以结果是:6

      ================================================================
      >>: 右移,最左边最高位是0用0补齐,最高位是1就用1补齐,多出来的丢弃。
      -24的二进制:10000000 00000000 00000000 00011000
      已知原码求补码:
        原码:10000000 00000000 00000000 00011000
        反码:11111111 11111111 11111111 11100111
        补码:11111111 11111111 11111111 11101000
      右移:
            11111111 11111111 11111111 11101000
            1111111111 11111111 11111111 111010(00)  (补码)
      已知补码求原码:
        补码:11111111 11111111 11111111 11111010
        反码:11111111 11111111 11111111 11111001
        原码:10000000 00000000 00000000 00000110
        最终结果是:-6

        ==============================================================
        >>>: 无符号右移,无论左边最高是0还是1,都用0补齐,多出来的丢弃。
        -24的二进制:10000000 00000000 00000000 00011000
      已知原码求补码:
        原码:10000000 00000000 00000000 00011000
        反码:11111111 11111111 11111111 11100111
        补码:11111111 11111111 11111111 11101000
        无符号右移2位:
             11111111 11111111 11111111 11101000
             0011111111 11111111 11111111 111010(00)   (补码)
        由于最高位是0,所以它的原码,反码,补码都是一样的。
        最终结果位:0011111111 11111111 11111111 111010 = 1073741818


 */

 面试题: 请用最有效率的方式写出计算2乘以8的结果
     a<<b  ==  a*2^b

     a>>b  ==  a/2^b

/*错误答案:System.out.println(2*8);

  正确答案:System.out.println(2<<3);
*/

                                                                                                                               --2022.1.4

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>