Java SE 第一部分 语法基础篇 第2章 基本数据与运算 （2.1-2.8）关键字 标识符 注释 常量与进制 变量 数据类型 运算符

第2章 基本数据与运算

2.1 关键字/保留字（53个）

关键字（Key Word）：是指被高级编程语言赋予特殊含义的一些单词，关键字一般都是由小写字母组成。好比是汉语当中的一些专有名词：北京，天安门，兵马俑。不能乱用。

保留字（Reserve Word）：即它们在Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其它语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。

注意：关键字和保留字均不能用作变量名、方法名、类名、包名和参数。

保留字：goto、const 还有（null、true、false）

关键字（51个）：

1.访问修饰符（3个）：public、protected、private

作用：用来修饰类（接口、抽象类）、方法、属性、构造方法、常量、主函数

2.类、接口、抽象类（9个）：

• class、interface、abstract——定义
• extends——继承类
• implements——实现接口
• new——新建一个对象、
• super——调用父类方法
• this——指代当前对象
• instanceof——通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例

3.数据类型（13个）：

• void——没有返回值
• byte、short、int、long——整型数据
• float、double——浮点型数据
• char——字符型数据
• boolean——判断型数据
• enum——枚举
• null、true、false——值类型（是保留字）

4.线程（2个）：

• synchronized——线程同步（修饰方法、代码块，方法、代码块的同步）

• volatile——线程同步（修饰属性，属性的同步）

5.异常（5个）：

• throw——抛出方法代码中的异常给方法自身。使用位置：方法中间
• throws——抛出方法中的异常给调用者。使用位置：方法外部
• try——捕获{}中代码是否有发生异常
• catch——处理try捕获的异常
• finally——不管有没有异常发生都会执行的代码块

6.返回（1个）：return

7.循环、条件（10个）：if、else、switch、case、break、default、continue、while、do、for

8.包（2个）：package、import

9.瞬时的（1个）：transient

10.断言（1个）：assert

11.调用底层代码（C\C++）（1个）：native

12.不可变的——final（1个）：

• 修饰属性、常量、局部变量、参数——作用：数据是不可改变的
• 修饰类——作用：修饰的类不能被继承
• 修饰普通方法——作用：修饰的方法不能被重写

13.静态的——static（1个）：

• 修饰属性、常量
• 修饰内部类
• 修饰普通方法

作用：所有使用static关键字修饰的内容会最先执行。static修饰的内容在内存中只有唯一的一份（存储在静态内存空间中）。

14.格式规范——strictfp（1个）：修饰类、接口或方法。

2.2 标识符

标识符指的是我们在程序中对变量、函数、类、接口、常量所定义的名称，也就是说这些名称是我们自定义的。

标识符必须满足以下组成规则：

• 标识符可以由数字、字母、下划线 _ 、美元符 $ 组成
• 标识符不能以数字开头，当然下划线和美元符其实是可以开头的，但不推荐
• 标识符不能是关键字
• 标识符也不能是Java内置类的名称
• 标识符可以为任意长度，但必须是一个连续的词
• 标识符严格区分大小写

标识符是为那些抽象的数据进行的自定义起名，为了方便程序的阅读和理解，起名尽量要有含义，不要通篇都是a b c d e f g....。在一些特殊的情况下（循环里 特殊数学符号），可以使用i j k m n 之类的。

标识符命名的规范：

• 大驼峰式：主要针对类名，接口名。所有单词的首字母大写
• 小驼峰是：主要针对于变量名，函数名。除了第一个单词之外，其他单词首字母大写
• 常量规范：所有单词字母大写，单词与单词之间用下划线分隔
• 包名规范：所有单词字母小写，单词与单词之间用句号 . 分隔

myAge 变量名 
getMax() 函数名 
MyMoney 类名 接口名 
MAX_VALUE 常量名 
com.oupeng.java 包名

2.3 注释

注释是用于注解和说明程序的一些程序中的内置文本信息的，但这些内置文本不属于代码的范畴。 所以在对含有注释的源代码进行编译时，所生成的字节码中不含有注释。注释给人看的！

注释主要有三种：

• 单行注释 //注释内容 直到换行为止
• 多行注释 /* 注释内容 内部可以进行换行 */
• 文档注释 /** 注释内容 内部可以进行换行 */ ：文档注释可以被编译器识别，并生成相应的程序说明书。对某一个类进行文档生成时，该类必须是public型

/** 这是一个演示类 名字叫Sample 
@author HENG 
@version 1.0 
*/
public class Sample { 
    /** 
    这是一个主函数，是程序的入口 @param args 在运行主函数是 所传入的一些指令的 @return 该主函数       
    没有返回值
    */
    public static void main(String[] args) { 

    } 
}

C:\Users\HENG\Desktop\JavaDay02>javadoc Sample.java

额外的，注释除了有解释说明程序的功能之外，还可以用来调试程序。

多行注释中，不能再出现多行注释

今后，在写代码时，一定要先写注释，并且，注释最好详细一些

2.4 常量与进制

常量就是指在程序中直接出现的一些数据，也叫字面量

常量都有哪些：

• 整数常量
• 小数常量
• 字符常量：由一个字母、数字、符号被单引号( '' )标识的数据
• 字符串常量：由若干个字母、数字、符号被双引号( "" )标识的数据
• 布尔类型常量
• null常量

public class Sample { 
    public static void main(String[] args) { 
        //整数常量 
        System.out.println(10); //十进制整数 
        System.out.println(0b1001); //二进制整数 打印出来是十进制 
        System.out.println(0123); //八进制整数 
        System.out.println(0xAF3); //十六进制整数 
        //小数常量 
        System.out.println(3.14); 
        System.out.println(5.234e3); 
        System.out.println(1.2e-3); 
        //字符常量
        System.out.println('a'); 
        //System.out.println('ab'); ERROR 
        System.out.println('9'); 
        //System.out.println('12'); ERROR         
        System.out.println('我'); 
        System.out.println(' '); 
        //System.out.println(''); ERROR 
        //System.out.println('''); ERROR 
        System.out.println('\''); //打印 ' 
        System.out.println('\n'); //打印 换行 
        System.out.println('\t'); //打印 缩进 
        //字符串常量 
        System.out.println("abcd"); 
        System.out.println("a"); 
        System.out.println(""); //字符串空串 vs null真空 
        System.out.println("\""); 
        //布尔常量 
        System.out.println(true);
        System.out.println(false); 
    } 
}

二进制转十进制

十进制	二进制数
0	0
1	1
2	10
3	11
4	100
5	101
6	110
7	111
8	1000

规律就是：1 1 1 1 1 1 1 1 - 128 64 32 16 8 4 2 1  

10010101 十进制是 128 + 16 + 4 + 1 = 149

十进制149 = 9 * 100 + 4 * 101 + 1 * 102

二进制1011 = 1 * 20 + 1 * 21 + 0 * 22 + 1 * 23 = 1 + 2 + 0 + 8 = 11

一个二进制位称之为是一个比特 bit；八个比特称之为一个字节 byte；字节是计算机当中的最小计数单元。

• 1 byte = 8 bit
• 1 kb = 1024 byte
• 1 mk = 1024 kb
• 1 gb = 1024 mb
• 1 tb = 1024 gb

十进制转二进制

• 53 ÷ 2 = 26 ~ 1
• 26 ÷ 2 = 13 ~ 0
• 13 ÷ 2 = 6 ~ 1
• 6 ÷ 2 = 3 ~ 0
• 3 ÷ 2 = 1 ~ 1
• 1 ÷ 2 = 0 ~ 1

余数从下到上 110101 = 1 + 4 + 16 + 32 = 53

二进制转八进制

10010101 => 010-010-101 => 0225 = 5 * 80 + 2 * 81 + 2 * 82 =5 + 16 + 128 = 149

二进制转十六进制

10010101 => 1001-0101 => 0x95 = 5 * 160 + 9 ^ 161 = 5 + 144 = 149

二进制转六进制

10010101 => 149

• 149 ÷ 6 = 24 ~ 5
• 24 ÷ 6 = 4 ~ 0
• 4 ÷ 6 = 0 ~ 4

所以六进制为405 => 5 * 60 + 0 * 61 + 4 * 62 = 5 + 0 + 144 = 149

负数的二进制

-29的二进制 将正数部分的二进制先取反 再加1 即为负数的二进制

00011101 =>取反 11100010 =>加1 11100011

2.5 变量

指的是变化的量

• 变量的本质就是在内存中程序所处的进程中的一个临时存储区域
• 该区域的存储值有限制的
• 该区域值的变化必须是同类型的或向下兼容的
• 该区域有其自身的物理内存地址-指针

该区域中 存储值的限制 和 数据的变化类型 由 数据类型 来决定

该区域中 其空间的分配 和 空间的物理内存地址 由计算机底层来决定

回顾一下指针

#include<stdio.h> 
void main() { 
    int a = 3; //创建一个普通的整型变量 存3这个常量 
    int* b; //创建一个一重指针变量 存的是a变量的地址 
    b = &a; 
    int** c; //创建一个二重指针变量 存的是b变量的地址 
    c = &b; 
    printf("a的地址：%d\n",&a); //打印a的地址 0x123 
    printf("a的内容：%d\n",a); //打印a空间的内容 3 
    printf("b的地址：%d\n",&b); //0x456 
    printf("b的内容：%d\n",b); //0x123 
    printf("拿着b的内容去找变量a：%d\n",*b); //3 
    printf("c的地址：%d\n",&c); //0x789 
    printf("拿着c的内容去找变量b：%d\n",*c); //0x123 
    printf("拿着c的内容去找变量b，拿着b的内容去找变量a：%d\n",**c); //3 
    //printf("%d\n",*a); 
    printf("%d\n",*&*c); //0x123 
    printf("%d\n",&*&**&c); //0x456 
}

结果如下：

a的地址：6422300 
a的内容：3 
b的地址：6422296 
b的内容：6422300 
拿着b的内容去找变量a：3 
c的地址：6422292 
拿着c的内容去找变量b：6422300 
拿着c的内容去找变量b，拿着b的内容去找变量a：3 
6422300 
6422296

2.6 数据类型

在Java当中，数据类型主要分为两大类：

• 基本数据类型：在变量的空间中存储数据

1.整型

• byte 1字节 2^8 256 -128~127 -2^7 ~ 2^7 - 1
• short 2字节 2^16 65536 -32768~32767 -2^15 ~ 2^15 - 1
• int 4字节
• long 8字节

2.浮点型

• float 4字节
• double 8字节

3.字符型

• char 2字节

4.布尔型

• boolean 不确定

在常量中，整型常量默认int类型，小数常量默认是double类型

布尔类型，如果是单一变量的话，在JVM中true被认为是1 false被认为是0 所以是4字节存

如果是布尔类型数组的话，在JVM中true和false被认为是byte类型 1字节

引用数据类型：数据是在堆内存中存储，变量仅仅存放的是数据在堆内存中的地址

• 字符串
• 数组
• 对象

在Java中，但凡存储在堆内存中的数据，统称为对象

2.7 运算符

算术运算符

算术运算符	含义	备注
+	加法	1+2=3 如果加号左右有字符串 则加号为连接符
-	减法	3-2=1
*	乘法	3*2=6
/	除法	3/2=1 3.0/2=1.5 如果除号两边都是整数 结果为整数；有小数结果为小数
%	取余	9%5=4 注意一点，如果前或后为负数怎办？
a++	后置自增	a自身加一，使用原来的值
++a	前置自增	a 自身加一，使用加之后的值
a--	后置自减	a 自身减一，使用原来的值
--a	前置自减	a 自身减一，使用加之后的值

public class Sample { 
    public static void main(String[] args) { 
        /*
        a++ 
        1.先开辟临时存储区 将a的值赋值进去 
        2.a自身加一 
        3.临时存储区的值等待被调用 输出 赋值 参与运算 
        */
        int i = 0; i++; 
        System.out.println(i++); //1    
        System.out.println(i); //2 
        int j = i++; 
        System.out.println(i); //3 
        System.out.println(j); //2 
        i = i++; 
        System.out.println(i); //3 
        i = i++; 
        System.out.println(i); //3 
        int a = 1; 
        System.out.println(a++ + ++a + a++ + a++ + ++a); 
        //                  1     3     3     4     6    
    } 
}

赋值运算符

赋值运算符	含义	备注
+=	加法赋值	a+=3 a=a+3 赋值运算符只能用在变量身
-=	减法赋值	a-=3 a=a-3  赋值运算符只能用在变量身
*=	乘法赋值	a*=3 a=a*3 赋值运算符只能用在变量身
/=	除法赋值	a/=3 a=a/3 赋值运算符只能用在变量身
%=	取余法赋值	a%=3 a=a%3 赋值运算符只能用在变量身

比较运算符

• 运算的结果为布尔类型
• > 大于
• < 小于
• >= 大于等于
• <= 小于等于
• != 不等于

逻辑运算符

• & 单与
• | 单或
• ^ 异或
• ! 非
• && 双与
• || 双或

 

public class Sample { 
    public static void main(String[] args) { 
        int x = 0; 
        int y = 0; 
        System.out.println(x++ > 0 & y++ > 0); 
        System.out.println(x); 
        System.out.println(y); 

        x = 0; 
        y = 0; 
        System.out.println(x++ > 0 && y++ > 0); 
        System.out.println(x); 
        System.out.println(y); 
        //&& 如果左边为假 则右边不用执行 
        //|| 如果左边为真 则右边不用执行 

        //相同为假 不同为真 
        System.out.println(true ^ true); 
        System.out.println(true ^ false); 
        System.out.println(false ^ false); 
        System.out.println(false ^ true); 
    } 
}

位运算符

• & 位与
• | 位或
• ^ 位异或
• >> 右移
• << 左移

public class Sample { 
    public static void main(String[] args) { 
        int x = 7; 
        int y = 12; 
        System.out.println(x & y); 
        /*
        0111 
        1100 & 
        0100 4 
        */
        System.out.println(x | y); 
        /*
        0111 
        1100 | 
        1111 15 
        */
        System.out.println(x ^ y); 
        /*
        0111 
        1100 ^ 
        1011 11 
        */
        System.out.println(x << 3); 
        /*
        0111 
        0111000 
        x * 2^3 
        */
        System.out.println(56 >> 2); 
        /*
        111000 
        1110 
        56 / 2^2 
        */ 
    } 
}

三目运算符

数据类型 变量名 = 布尔表达式?值1:值2; 
int number = 10 % 2 == 0? 10 : 2;

补充：变量的交换问题

int a = 3; 
int b = 7;

方法一（插入一个参数）：

int c = a; 
a = b; 
b = c; 
System.out.println(a); 
System.out.println(b);

方法二（运用算数运算）：

a = a + b; 
b = a - b; 
a = a - b; 
System.out.println(a); 
System.out.println(b);

方法三（利用异或）：

a = a ^ b; 
b = a ^ b; 
a = a ^ b; 
System.out.println(a); 
System.out.println(b);

2.8 常见错误

未声明变量，未初始化变量而使用变量

public class Sample { 
    public static void main(String[] args) { 
        int a = 3; 
        int c = a + b; 
    } 
}
Sample.java:4: 错误: 找不到符号 
        int c = a + b;
                    ^ 
    符号: 变量 b 
    位置: 类 Sample 
1 个错误

public class Sample { 
    public static void main(String[] args) { 
        int a = 3; 
        int b; 
        int c = a + b; 
    } 
}
Sample.java:5: 错误: 可能尚未初始化变量b 
        int c = a + b;
                    ^ 
1 个错误

整型溢出问题

public class Sample { 
    public static void main(String[] args) { 
        int a = 3000000 * 3000000; 
        int b = 3000000 * 3000000; 
        int c = a + b; System.out.println(c);//-207937536 
    } 
}

取整错误

一个是小数的问题，小数主要去的是近似值 想要得到一个0.5这个值的话 有可能会得到0.4999999

一个是整数的问题，1/3 = 0.3333 * 3 = 0.99999 数学上1

超出预期的除法问题

/左右两边是整数，结果为整数，如果出现小数则结果为小数

额外冗余的输入对象

import java.util.Scanner; 
public class Sample { 
    public static void main(String[] args) { 
        Scanner scanner1 = new Scanner(System.in); 
        System.out.print("请输入整数："); 
        int num1 = scanner1.nextInt(); 

        //下面scanner2对象就是一个多余的 
        Scanner scanner2 = new Scanner(System.in); 
        System.out.print("请输入小数："); 
        double num2 = scanner2.nextDouble(); 
        /*
        Sample.java:3: 错误: 找不到符号 
        Scanner scanner = new Scanner(System.in); 
        ^
        符号: 类 Scanner 
        位置: 类 Sample 
        */ 
    } 
}