大数据之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 == a2^b

 a>>b  ==  a/2^b

/*错误答案：System.out.println(2*8);
  正确答案：System.out.println(2<<3);
*/

                                                                                                                         *  --2022.1.4*

标签： java 开发语言后端

本文转载自: https://blog.csdn.net/m0_53997870/article/details/122288551
版权归原作者 BD white 所有，如有侵权，请联系我们删除。