【JavaSE（一）】Java语法基础（上）

原文地址：https://www.cloudcrossing.xyz/post/33/

1 JDK,JRE,JVM的作用及关系

（1）作用

• JVM：保证Java语言跨平台
• JRE：Java程序的运行环境
• JDK：Java程序的开发环境

（2）关系

• JDK：JRE+工具
• JRE：JVM+类库

---

2 第一个程序：HelloWorld案例

class Helloworld {
    public static void main(String[] agrs){
        System.out.println("Hello world!");
    }
}

运行结果：
Hello world!

程序解释：

• A：Java程序的最基本单位为类，所以我们要将代码都放进类里边，并且类名要和文件名一致
  • 格式：class 类名；例如：class Helloworld
• B：要想执行Java程序，就必须有main方法，其也是Java程序的入口方法，程序将从main方法开始执行
  • 格式：public static void main(String[] args)

编译执行程序：

• A：编写java源程序(.java)
• B：通过javac命令编译生成.class文件（字节码文件）
• C：通过java命令运行.class文件（通过JVM解释执行字节码文件）

---

3 标识符和关键字

标识符就是给程序中的变量、类、接口、方法等命名的字符序列。

组成规则：

• A：字母、数字、下划线和美元符号组成。其中数字不能打头
• B：不能为Java的关键字和保留字
• C：不能包含空格、区分大小写

常见的命名规则：

• A：包：全部小写
  • 单级包：小写；例如：daniu，com
  • 多级包：小写并用句点隔开；例如：com.daniu.love，com.baidu
• B：类或接口
  • 一个单词：首字母大写
  • 多个单词：每个单词首字母大写；例如：HelloWorld，StudentName
• C：方法或者变量
  • 一个单词：首字母小写
  • 多个单词：从第二个单词开始首字母大写；例如：studentAge，showAllNames()
• C：常量
  • 全部大写
  • 一个单词：全部大写；例如：PI；
  • 多个单词：全部大写，每个单词之间用下划线连接；例如：STUDENT_MAX_AGE

关键字是被Java语言赋予特定含义的单词。其全部小写。（注意：goto和const作为保留字存在）

---

4 注释

注释就是对程序进行解释说明的文字。

分类：

• A：单行注释 //
• B：多行注释 /* */
• C：文档注释(后面讲) /** */

注释的作用：

• A：解释说明程序，提高了代码的阅读性
• B：可以帮助我们调试程序

---

5 变量与常量

变量是在程序的执行过程中，其值在某个范围内可以发生改变的量。

其变量的定义格式：

• A：定义的时候赋初始值；数据类型 变量名 = 初始化值;
• B：先定义后赋值；数据类型 变量名; 变量名 = 初始化值;

常量就是在程序执行过程中，其值不发生改变的量。分为字面值常量以及自定义常量（后面讲）

字面值常量：

• A：字符串常量 "hello"
• B：整数常量 12,23
• C：小数常量 12.345
• D：字符常量 'a','A','0'
• E：布尔常量 true,false
• F：空常量 null(后面讲)

在Java中针对整数常量提供了四种表现形式：

• A：二进制 由0，1组成。以0b开头
• B：八进制 由0，1，...7组成。以0开头
• C：十进制 由0，1，...9组成。整数默认是十进制
• D：十六进制 由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头

---

6 进制转换与原码反码补码

（1）其他进制到十进制

（2）十进制到其他进制

（3）进制转换的快速转换法

（4）原码反码补码

---

7 数据类型

Java是一种强类型语言，针对每种数据都提供了对应的数据类型。

• 所有的变量必须先声明后使用
• 指定类型的变量只能接受类型与之匹配的值

分类：

• 基本数据类型：4类8种
• 引用数据类型：类，接口，数组。

基本数据类型：

• A：整数 byte、short、int、long 分别占用字节1、2、4、8
• B：浮点数 float、double 分别占用字节4、8
• C：字符 char 占用字节2
• D：布尔 boolean 占用字节1

注意：

• 整数默认类型为int，浮点数默认类型为double
• 长整数最后要加L或l
• 单精度的浮点数最后要加F或f
• byte，short在定义的时接收的其实是一个int类型的值。此时其本身会做一个范围检测，如果不再它们的范围内，就报错
• Java语言中的字符char可以存储一个中文汉字。因为字符占用两个字节。Java语言采用的是Unicode编码。
• java7中，可以在数值中使用下划线。比如double Pi = 3.14_15_92_65;

---

8 数据类型转换

（1）布尔类型不参与数据类型转换

（2）默认转换

• A：从小到大
• B：（byte,short,char）-->（int）-->（long） --> （float）-->（double）
• C：byte、short、char之间不相互转换，直接转成int类型参与运算。

（3）强制转换

• A：从小到大
• B：可能会有精度的损失
• C：格式：目标数据类型 变量名 = (目标数据类型) (被转换的数据);

举个例子：

• 1、float f1 = 12.345f; float f2 = (float)12.345; 有啥区别？
  • 答：前者12.345本身是一个float类型的数据，而后者12.345是个double类型的，经过强制转换为float赋值给f2。
• 2、下面的程序有问题吗，如果有，在哪里呢?byte b1 = 3; byte b2 = 4; byte b3 = b1 + b2; byte b4 = 3 + 4;
  • 答：第三句代码有问题，因为可能存在精度损失的情况。
• 3、字符参与运算时是查找ASCII里面的值。
  • 答：System.out.println('a');打印a；
    System.out.println('a' + 1);打印98
• 4、short s = 1; s = s + 1;和short s = 1; s += 1; 请问上面的代码哪个有问题?
  • 答：第一个有问题，因为第一个short类型的数据参与运算的时候，首先默认转换成int类型参与运算，但是又赋值给一个short类型的数据，这样可能会损失精度。而第二个运算中，扩展运算符隐含了一个强制类型转换，式子等价于s=(short)(s+1);

---

9 运算符

9.1 算术运算符

++和--的用法：

• A：单独使用。放在操作数据的前面和后面效果一样。
• B：参与操作使用
  • 放在操作数的前面：先自增或者自减，再参与操作
  • 放在操作数的后面：先参与操作，再自增或者自减

9.2 赋值运算符

其包含=,+=,-=,*=,/=,%=等。=为基本的赋值运算符，其他的为扩展的赋值运算符。

扩展的赋值运算符隐含了自动强制转换：

• short s = 1; s = s + 1;可能会损失精度
• short s = 1; s += 1;其等价于s=(short)(s+1)

9.3 比较运算符

比较运算符的结果为布尔类型，即true或者false。

9.4 逻辑运算符

逻辑运算符用于连接布尔类型的表达式。

• &：有false则false
• |：有true则true
• ^：相同则false，不同则true。例如：情侣关系。
• !：非true则false，非false则true
• &&：结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
• ||：结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

9.5 位运算符

位运算直接对二进制进行运算。

• <<：左移，左边最高位丢弃，右边补齐0
• >>：右移，最高位是0，左边补齐0；最高为是1，左边补齐1
• >>>：无符号右移，无论最高位是0还是1，左边补齐0

PS：面试题：请用最有效率的方式写出计算3乘以4的结果? 答案是 3 << 2

class Demo {
    public static void main(String[] args) {
        //<< 把<<左边的数据乘以2的移动次幂
        System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
    
        //>> 把>>左边的数据除以2的移动次幂
        System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
        System.out.println(24 >>> 2);
        
        System.out.println(-24 >> 2); 
        System.out.println(-24 >>> 2);
    }
}

计算出3的二进制：11，然后左移两位，左边最高位丢弃，右边补齐0
      00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100
        
>>的移动：  
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
右移两位，最高位是0，左边补齐0；最高为是1，左边补齐1
    11111111 11111111 11111111 11101000
        11111111 11111111 11111111 111010(00) 补码
    1111111111 11111111 11111111 111010(00) 补齐后的补码
补码：1111111111 11111111 11111111 111010
反码：1111111111 11111111 11111111 111001
原码：1000000000 00000000 00000000 000110
结果：-6
        
>>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
无论最高位是0还是1，左边补齐0
    11111111 11111111 11111111 11101000
    0011111111 11111111 11111111 111010(00)
结果：1073741818

• &位与运算：有0则0
• |位或运算：有1则1
• ^位异或运算：相同则0，不同则1
• ~按位取反运算符：0变1，1变0

3的二进制：11
00000000 00000000 00000000 00000011
4的二进制：100
00000000 00000000 00000000 00000100
    
&位与运算：有0则0。
   00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
   ---------------------------------------------
   00000000 00000000 00000000 00000000
   结果是：0
        
|位或运算：有1则1。
   00000000 00000000 00000000 00000011
 | 00000000 00000000 00000000 00000100
   ---------------------------------------------
   00000000 00000000 00000000 00000111
   结果是：7
        
^位异或运算：相同则0，不同则1。
   00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
   ---------------------------------------------
   00000000 00000000 00000000 00000111
   结果是：7
        
~按位取反运算符：0变1，1变0
   00000000 00000000 00000000 00000011
~11111111 11111111 11111111 11111100 (补码) 
   补码：11111111 11111111 11111111 11111100
   反码：11111111 11111111 11111111 11111011
   原码：10000000 00000000 00000000 00000100
   结果是：-4

^的特殊用法：一个数据针对另一个数据位异或两次，该数不变

PS：面试题：请自己实现两个整数变量的交换

方式1：使用第三方变量(开发中用的)

int c = a;
a = b;
b = c;

方式2：用位异或实现(面试用)

//左边：a,b,a
//右边：a ^ b
a = a ^ b;
b = a ^ b;   //a ^ b ^ b = a
a = a ^ b;   //a ^ b ^ a = b

方式3：用变量相加的做法

a = a + b;    //a=30
b = a - b;    //b=10
a = a - b;    //a=20

方式4：一句话搞定

b = (a+b) - (a=b);    //b=30-20=10,a=20

9.6 三元运算符

格式：比较表达式?表达式1:表达式2;

首先计算比较表达式的值，看是true还是false。如果是true，表达式1就是结果。如果是false，表达式2就是结果。

举个例子，求三个数最大值：max = (a > b)? ((a > c)? a: c): ((b > c)? b: c);

---

10 键盘录入

步骤：

• A：在class上面导包。格式：import java.util.Scanner;
• B：创建键盘录入对象。格式：Scanner sc = new Scanner(System.in);
• C：通过对象获取数据。格式：int x = sc.nextInt();

import java.util.Scanner
class ScannerDemo {
    public static void main(String[] args) {
        //创建键盘录入数据对象
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请你输入一个数据：");
        int x = sc.nextInt();
        
        System.out.println("你输入的数据是："+x);
    }
}

后续详细补充其他类型。

---

11 流程控制语句

11.1 顺序结构

按照代码的先后顺序，从上往下，依次执行。

class Demo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        
        System.out.println("我爱Java");
        
        System.out.println("程序结束了");
    }
}

//运行结果：
程序开始了
我爱Java
程序结束了

11.2 选择结构-if语句

其有三种格式：

格式1：

if (比较表达式) {
    语句体;
}

执行流程：

• 判断比较表达式的值，看是true还是false
• 如果是true，就执行语句体
• 如果是false，就不执行语句体

格式2：

if (比较表达式) {
    语句体1;
}else {
    语句体2;
}

执行流程：

• 判断比较表达式的值，看是true还是false
• 如果是true，就执行语句体1
• 如果是false，就执行语句体2

格式2：

if(比较表达式1) {
    语句体1;
}else if (比较表达式2){
    语句体2;
}
...
else {
    语句体n+1;
}

执行流程：

• 判断比较表达式1的值，看是true还是false
• 如果是true，就执行语句体1；
• 如果是false，就继续判断比较表达式2的值，看是true还是false
• 如果是true，就执行语句体2
• 如果是false，就继续判断比较表达式3的值，看是true还是false
• ...
• 如果都不满足，就执行语句体n+1

注意：

• 比较表达式的值一定为布尔类型不能为1或者0
• 所有的三元运算符能够实现的，if语句的第二种格式都能实现，反之不成立。（如果if语句第二种格式控制的语句体是输出语句，就不可以。因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。）

11.3 选择结构-switch语句

格式：

switch(表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

格式解释说明：

• switch：说明这是switch语句。
• 表达式：可以是byte、short、int、char（JDK5以后可以是枚举，JDK7以后可以是字符串）
• case：后面的值就是要和表达式进行比较的值
• break：表示程序到这里中断，跳出switch语句
• default：如果所有的情况都不匹配,就执行这里,相当于if语句中的else

执行流程：

• A：首先计算表达式的值
• B：和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束
• C：如果没有匹配，就执行default的语句体n+1

注意事项：

• A：case后面只能是常量，不能是变量，而且，多个case后面不能出现相同的值
• B：default可以省略，但是不建议，因为它的作用是对不正确的情况给出提示
• C：break可以省略，会出现一个现象：case穿透
• D：default不一定要在最后，可以在任意位置。但是建议在最后
• E：switch语句的结束条件
  • a：遇到break就结束了
  • b：执行到末尾就结束了

11.3 循环语句-for语句

格式：

for (初始化语句;判断条件语句;控制条件语句){
    循环体语句;
}

执行流程：

• a：执行初始化语句
• b：执行判断条件语句
  • 如果这里是true，就继续
  • 如果这里是false，循环就结束
• c：执行循环体语句
• d：执行控制条件语句
• e：回到b

11.4 循环语句-while语句

格式：

while(判断条件语句) {
    循环体语句;
}

或

初始化语句;
while(判断条件语句){
    循环体语句;
    控制条件语句;
}

while循环可以和for循环等价转换。

for和while的区别：

• 使用上的区别：for语句的那个控制条件变量,在循环结束后不能在使用了，而while的可以继续使用
• 理解上的区别：for适合于一个范围的判断。while适合次数不明确的

11.5 循环语句-do...while语句

格式：

do {
    循环体语句;
}while(判断条件语句);

或

初始化语句;
do {
    循环体语句;
    控制条件语句;
}while(判断条件语句);

while循环可以和for循环等价转换。

三种循环的区别：

• do...while循环至少执行一次循环体
• for和while必须先判断条件是否是true，然后后才能决定是否执行循环体

11.6 控制跳转语句

（1）break：中断的意思

• A：用在循环和switch语句中，离开此应用场景无意义。
• B：作用
  • a：跳出单层循环
  • b：跳出多层循环，需要标签语句的配合（标签语句的格式：标签名: 语句）

class BreakDemo {
    public static void main(String[] args) {
        //跳出单层循环
        for(int x=0; x<10; x++) {
            if(x == 3) {
                break;
            }
            System.out.println("HelloWorld");
        }
        
        System.out.println("over");
        System.out.println("-------------");
        
        wc:for(int x=0; x<3; x++) {
            nc:for(int y=0; y<4; y++) {
                if(y == 2) {
                    //break nc;
                    break wc;
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

（2）continue：继续

• A：用在循环中，离开此应用场景无意义。
• B：作用：跳出单层循环的一次，可以继续下一次，也可以带标签的使用

（3）return：返回

return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。