2.Java基础知识：语法

Last Updated on 2024年1月6日 by hangzi

1、Java中的关键字

关键字	说明
abstract	表明类或者成员方法具有抽象属性
assert	用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

2、标识符

在编程过程中,经常需要在程序中定义一些符号来标记一些名称,如包名,类名,方法名,参数名,变量名等.这些符号被称为标识符。

2.1、组成成分：

• 任意顺序的大小写字母. a_z, A_Z
• 数字. 0_9
• 下划线. _
• 美元符号. $
• 标识符不能以数字开头
• 标识符不能是Java中的关键字

2.2、规范 :

为了增加代码的可读性,在定义标识符还应该遵守以下规则 :

• 包名所有字母一律小写。例如 : com.test
• 类名和接口名每个单词的首字母都要大写。例如 : ArrayList, Iterator
• 常量名所有字母都大写.单词之间用下划线连接。例如 DAY_OF_MONTH
• 变量名和方法名的第一个单词首字母小写.从第二个单词开始每个单词的首字母大写。例如: lineNumber, getLineNumber
• 在程序中，应该尽量使用有意义的英文单词来定义标识符.使得程序便于阅读。例如使用 userName 表示用户名、password 表示密码

3、注释

3.1、特点：

1.不会被编译器去编译，编译器会忽略注释中所有的内容。

2.注释是给人看的，不是给编译器看的。

3.2、分类：

1.单行注释： // 后面的这一行内容就是注释。

2.多行注释： /* */ 里面的所有内容都会被当作注释,无论多少行,多行注释是不能嵌套的。

3.文档注释： /** */ 用于生成java开发文档的注释。

4、常量

常量就是在程序中固定不变的值,是不能改变的数据。

分类：

• 整型常量

生活中最常用的十进制,还有二进制,八进制,和十六进制

• 浮点型常量

就是在数学中用到的小数。分为float单精度浮点数和double双精度浮点数两种类型。

float单精度存储数据时保留8位有效数字，例如:将常量12345.123456789f赋值个float变量,其存储的实际值为12345.123;

double变量存储数据时,保留16位有效数字，例如:12345.123456789l,最后的字符为l,默认可以不写。double类型可以进行完整的存储.

• 字符常量

用于表示一个字符

• 字符串常量

用于表示一串连续的字符

• 布尔常量

两个值true (真) 或 false(假),该常量用于区分一个事物的真与假

• null 空常量型

空常量只有一个值，即null，表示对象的引用为空。

5、变量

变量是内存中的一个存储区域.在内存中,每一块空间都有其独一无二的地址。

该区域有自己的名称(变量名)通过名称就可以找到这块内存地址和类型(数据类型)决定了开辟空间的大小。

该区域的数据可以在同一数据类型范围内不断变化。

5.1、定义变量的格式

数据类型 变量名 = 值;

5.2、数据类型

数据类型	内存所占字节
byte	1 字节
char	2 字节
short	2 字节
int	4 字节
long	8 字节
float	4 字节
double	8 字节
boolean	1 bit. 取值 true 或者 false

5.3、使用三步骤：

1. 定义
2. 初始化
3. 使用

public class Demo {

 public static void main(String[] args) {
     // 变量

     // 变量使用的三部曲
     // 1. 定义
     int num;
     // 2. 初始化
     num = 200;
     // 3. 使用
     System.out.println("num=" + num);

     // 格式:  数据类型变量名 = 初始值;
     // 1. byte 1个字节 -128 ~ 127
     // 说明: 变量在定义的同时进行了初始化操作
     byte num1 = 127;

     // 2. short 2个字节 -32768 ~ 32767
     short num2 = 32767;

     // 3. int 4个字节 -2147483648 ~ 2147483647 (默认类型)
     int num3 = 2147483647;

     // 4. long 8个字节 -9223372036854775808 ~ 9223372036854775807
     long num4 = 9223372036854775807l;// 注意: 最后一个字符是 l,代表此数值为 long类型

     // 5. float 4个字节单精度浮点数 (8位有效位数)
     float f1 = 12345.123456789f;// f1=12345.123

     // 6. double 8个字节双精度浮点数 (16位有效数)
     double d1 = 12345.12345678988;

     // 7. char 2个字节字符类型,用于存储单个字符 ''
     char ch = '中';

     // 8. boolean 1比特位 true / false
     boolean bool = false;

     System.out.println("bool=" + bool);// + 在输出语句中代码拼接一个变量值
 }
}

5.4、数据类型转换

自动类型转换 (隐式类型转换)

• 条件1: 两种类型彼此兼容。
• 条件2: 目标类型的取值范围大于源类型的取值范围。

  public class Demo {
    public static void main(String[] args) {
      byte b = 4;
      int x = 3;
      x = x + b;// 系统为 b 做了自动类型的提升
      System.out.println("x=" + x);
    }
   }

强制类型转换 (显示类型转换)

1.当两种类型彼此不兼容,或者目标类型取值范围小于源类型时,自动类型转换无法进行,这时就需要进行强制类型转换。

2.类型按照精度从低到高排列:

byte short char int long float double

当把级别高的变量的值赋值给级别低的变量时,需要使用类型转换运算.

/**
  强制类型转换：它一般容易产生有数据的丢失。
  格式：(数据类型 )( 表达式/变量);
*/
public class Demo {
    public static void main(String[] args) {
        byte b = 4;
        int x = 3;
        //强制类型转换
        b = (byte) (x + b);
        System.out.println("b=" + b);
    }
}

// float -> int
public class Demo {
    public static void main(String[] args) {
        float f = 10.88f;
        //强制类型转换
        int x = (int) f;
        System.out.println("x=" + x); // x = 10
    }
}

// int -> byte
public class Demo {
    public static void main(String[] args) {
        int num = 298;
        byte a = (byte) num;
        // 298 -> 0000 0000 0000 0000 0000 0001 0010 1010
        // byte-> 0010 1010
        System.out.println("a=" + a);// a=42
    }
}

5.5、表达式类型自动提升

所谓表达式是指由变量和运算符组成的一个算式。

变量在表达式中进行运算时，也有可能发生自动类型转换。

这就是表达式数据类型的自动提升。如一个byte型的变量在运算期间会自动提升为int型，short类型同理。

// 变量b1和b2都被自动提升为int型。表达式的运算结果也就成为int型。这时如果将该结果赋值给byte型的变量，需要进行强制类型转换。
public class Demo {
    public static void main(String[] args) {
        byte b1 = 3;
        byte b2 = 4;
        byte b3 = (byte) (b1 + b2);
        System.out.println("b3=" + b3);// b3 = 7
    }
}

public class Demo {
    public static void main(String[] args) {
        byte b1 = 3;
        byte b2 = 4;
        int b3 = b1 + b2;
        System.out.println("b3=" + b3); // b3 = 7
    }
}

6、运算符

在程序中经常出现一些特殊的符号,如+ - * / = >等。

这些特殊符号称作运算符.运算符用于对数据进行算术运算,赋值和比较操作。

在Java中,运算符可以分为算术运算符,赋值运算符,比较运算符,逻辑运算符和位运算符.

6.1、算术运算符：

• 算术运算符连接起来的式子， 就叫做算术表达式。
• 算术运算符的优先级：先乘除模(取余) 后加减. 如果同级别,，就从左到右，依次的计算，有小括弧的就先计算小括弧里面的。

6.2、赋值运算符：

public class Demo {
    public static void main(String[] args) {
        int num = 10;
        int result = num + 5;
        System.out.println("num=" + num);// num = 10
    }
}

public class Demo {
    public static void main(String[] args) {
        int num = 10;
        num = num + 5;
        System.out.println("num=" + num);// num = 15
    }
}

6.3、复合赋值运算符:

要想让一个变量的值在自身的基础上做改变, 那么还可以有另外一种写法 : += -= *= /= %=

 public class Demo {
    public static void main(String[] args) {
        int num = 10;
        num += 5;
        System.out.println("num=" + num);// 15
        num -= 5;
        System.out.println("num=" + num);// 10
        num *= 5;
        System.out.println("num=" + num);// 50
        num /= 5;
        System.out.println("num=" + num);// 10
        num %= 5;
        System.out.println("num=" + num);// 0
    }
}

6.4、自增和自减(表达式)

• 自增运算 (前自增运算 / 后自增运算)：无论是前自增还是后自增，都是将自身的值加 1。
• 自减运算.(前自减运算 / 后自减运算)：无论是前自减还是后自减，都是将自身的值减 1。
• ++i或者--i，不开辟临时空间,两值都一样。
• i++或者i--，开辟临时空间，两值不一样。

6.5、比较运算符：

由比较运算符连接起来的表达式就是比较表达式。用于对两个数值或变量进行比较。其结果是一个布尔值.即true或false。

运算符	运算	范例	结果
==	相等于	4 == 3	false
!=	不等于	4 != 3	true
<	小于	4 < 3	false
>	大于	4 > 3	true
<=	小于等于	4 <= 3	false
>=	大于等于	4 >= 3	true

6.6、逻辑运算符

• 逻辑表达式 : 由逻辑运算符连接起来的表达式就是逻辑表达式.
• 作用 : 判断多个条件的, 使用逻辑运算符来指定多个条件之间的关系.
• 逻辑运算符用于对布尔型的数据进行操作。其结果仍是一个布尔型数据

运算符	运算	范例	结果
&	AND (与)	false & true	false
|	OR (或)	false | true	true
^	XOR (异或)	true ^ false	true
!	NOT (非)	!true	false
&&	AND (短路)	false && true	false
||	OR (短路)	false || true	true

• 逻辑与 (&) 口诀： 一假即假
• 逻辑与短路的问题 : (&&) 口诀：一假即假
• 逻辑或 (|) 口诀：一真即真
• 逻辑或短路的问题 : (||) 口诀： 一真即真
• 逻辑非 ( ! ) 口诀： 真变假，假变真
• 逻辑异或 ( ^ ) 口诀：相同为假，不同为真

true	^	true	false
false	^	true	true
true	^	false	true
false	^	false	false

6.7、位运算符

注：位运算符是针对二进制数的每一位进行运算的符号。它是专门针对数字0和1进行操作的。(运算效率最高)

运算符	运算	范例
<<	左移	3 << 2 = 12; 相当于 3 2 2 = 12;
>>	右移	3 >> 1 = 1; 相当于 3 / 2 = 1;
>>>	无符号右移	3 >>> 1 = 1; 相当于 3 / 2 = 1;
&	与运算	6 & 3 = 2;
|	或运算	6 | 3 = 7;
^	异或运算	6 ^ 3 = 5;

6.8、& 按位与 口诀: 全1才1, 否则0

19 & 1
    00000000 00000000 00000000 00100011
    00000000 00000000 00000000 00000001
    ------------------------------------
    00000000 00000000 00000000 00000001 == 奇数 (1)

30 & 1
    00000000 00000000 00000000 00011110
    00000000 00000000 00000000 00000001
    ------------------------------------
    00000000 00000000 00000000 00000000 == 偶数 (0)

6.9、|按位或 口诀: 有1就1

9 | 12
        00000000 00000000 00000000 00001001
        00000000 00000000 00000000 00001100
        --------------------------------------
        00000000 00000000 00000000 00001101

6.10、^按位异或 口诀: 相同为0, 不同为1

交互两个变量的值:

       int a = 10;
       int b = 20;

       a = a ^ b;
       b = a ^ b;
       a = a ^ b;

10       :  00000000 00000000 00000000 00001010
20       :  00000000 00000000 00000000 00010100
-------------------------------------------------
异或运算 :  00000000 00000000 00000000 00011110 == 30  a = a ^ b;

           00000000 00000000 00000000 00011110
           00000000 00000000 00000000 00010100
-------------------------------------------------
           00000000 00000000 00000000 00001010 == 10  b = a ^ b;

           00000000 00000000 00000000 00011110
           00000000 00000000 00000000 00001010
-------------------------------------------------
           00000000 00000000 00000000 00010100 == 20  a = a ^ b;

6.11、<<左移 口诀: 相当于乘法

# 意义 : 将一个二进制的数据向左移动指定的位数, 高位溢出的部分丢弃, 低位补0
# 注意点 : 
    有可能改变这个数的正负性.
    将一个数按位左移n位, 就相当于这个数乘以2的n次方

8 << 2
    |00000000 00000000 00000000 00001000| 8
    |000000 00000000 00000000 0000100000| 32 --> 8 * 2的2次方

40 << 3
    |00000000 00000000 00000000 00101000| 40
    |00000 00000000 00000000 00101000000| 320 --> 40 * 2的3次方

6.12、>>右移 口诀: 相当于除法

# 意义 : 将一个二进制的数据, 向右移动指定的位数, 低位溢出的部分丢弃, 高位不足的以符号位补齐.
# 注意点 : 
 向右移动不会改变这个数的正负性.
 一个数向右移动n位, 就相当于这个数除以2的n次方.

8 >> 2
    |00000000 00000000 00000000 00001000| 8
    |0000000000 00000000 00000000 000010| 2 --> 8 / 2的2次方

40 >> 3
    |00000000 00000000 00000000 00101000| 40
    |00000000000 00000000 00000000 00101| 5 --> 40 / 2的3次方

6.13、按位无符号右移 : >>>口诀: 相当于除法

6.14、位运算符和逻辑运算符的区别:

Q:如果在程序中 出现了  &   |  ^ 这时他们到底是逻辑运算还是位运算? 

判断运算符两侧的数据类型。如果是boolean类型，就是逻辑运算，如果是数值类型，他们都是位运算。

7、编码表

Unicode字符集:

Java语言使用Unicode标准字符集,该字符集由Unicode协会管理并接受其技术上的修改,最多可识别65536个字符。

Unicode字符集前128个字符刚好是ASCII码,大部分国家的“字母表” 的字母都是Unicode 字符集中的一个字符。

Java所谓的字母包括了世界上大部分语言中的“字母表”,因此,Java所使用的字母不仅包括通常的拉丁字母a, b, c等,也包括汉语中的汉字,日文,朝鲜文,俄文,希腊字母以及其他许多语言中的文字。

对于char型变量,分配2个字节内存,占16位, char型变量的取值范围是0~65535。

我们需要重点关注的是Unicode字符集中的ASCII表。

8、逗号表达式

逗号在Java语言中，是一个运算符， 由逗号连接起来的式子就叫做逗号表达式。

• 语法 : 表达式1, 表达式2, 表达式3, ......表达式n;

public class Demo {
    public static void main(String[] args) {
        char ch1 = 97, ch2 = 65, ch3 = 48;
        int i1 = 'a', i2 = 'A', i3 = '0';
        System.out.println("ch1=" + ch1 + ", ch2=" + ch2 + ", ch3=" + ch3);
        System.out.println("i1=" + i1 + ", i2=" + i2 + ", i3=" + i3);
    }
}

9、三元运算符

• 三元运算的语法 : 表达式 ? 值1 : 值2;

public class Demo {
    public static void main(String[] args) {
        // 三元运算符 
        // 格式:  表达式 ? 值1 : 值2;
        // 如果表达式的条件成立,为true,则返回值1
        // 如果表达式的条件不成立,为false,则返回值2
        int num = -10;
        int result = (num > 0) ? 100 : -100;
        System.out.println("result=" + result);
    }
}

10.条件语句

10.1、If 语法 :

 if (条件表达式) {  
    执行代码
 }

• 图示：
  

10.2、if - else 语法

if (条件表达式) {  
    执行代码1
}else{
    执行代码2
}

• 图示：
  

10.3、if – else if – else 语法

if (条件表达式1) {  
    执行代码1
}else if(条件表达式2){
    执行代码2
}else{
    执行代码3
}

• 图示：
  

10.4、switch 语法：

 switch (表达式) { 
    case 常量1: 
        执行代码1
        break;
    case 常量2: 
        执行代码2 
        break;
     ...
    default: // 默认执行
        // 没有满足case条件后,执行该语句
        break;
}

• 图示：
  

11、循环结构

11.1、while 循环结构

• while 语法

while (条件表达式) {     
    执行代码    
}

• 图示：
  

11.2、do - while 循环结构

• do - while 语法

do {
   // 语句 (循环体) 
} while (条件表达式);

• 图示：
  

11.3、for 循环结构

• for 语法

  for (初始化变量; 循环条件; 增量 (循环后的操作表达式)) {
  // 语句 (循环体)
  }

• 图示：

  

12、流程控制(break,continue)

12.1、break

在switch条件语句和循环语句中都可以使用break语句。

当它出现在switch条件语句中，作用是终止某个case并跳出switch结构。

当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。

while(true){
  System.out.println("我喜欢你!");
  break;
  }

12.2、continue

continue 语句用在循环语句中，它的作用是终止本次循环,继续下一次循环。

public class Demo {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            i++;
            if (i == 5) {
                continue;
            }
            System.out.println("i=" + i); // 输出的结果没有 5
        }

    }
}

注：break 用来结束这个循环，continue 只能用来结束当前循环，无论是break还是continue，只要遇到了，循环体后面的代码是不会执行的