Java-第二章-标示符、关键字、变量

1 注释

程序中的注释，用来说明某段代码的作用，或者说明某个类的用途、某个属性的含义、某个方法的

功能，方法参数和返回值的数据类型、意义等。

注释可以增强代码的可读性，让自己或者他人快速的理解代码含义和设计思路，同时可以便于后期的对

系统中代码的维护和迭代升级等。

Java源码代码中的注释，不会出现在字节码文件中，因为在编译的时候，编译器会忽略掉源代码中的注

释部分。因此，可以在源代码中根据需要添加任意多的注释，而不必担心字节码文件会膨胀。

源代码中，被注释掉的部分（代码、文字等），不会对代码的编译、运行产生任何影响

如果在生成API文档的时候，希望得到更新详细的信息，例如方法参数、返回值、异常的详细说明，可以

使用javadoc标记，常用的javadoc标记有：

@author：作者

@version：版本

@deprecated：不推荐使用的方法、过时的方法。

@param：方法的参数类型。

@return：方法的返回类型。

@see：用于指定参考的内容。

@exception：抛出的异常。

@throws：抛出的异常，和exception同义

2 符号

分号

java中，一句代码都是以分号（;） 来结束的。

需要使用分号的代码语句有：

• 包的声明语句

• 类的引入语句

• 属性的声明语句

• 方法中要执行的代码

3 标示符

在java中，给类、方法、变量起的名字，就是标示符，因为它可以用来标识这个类、方法、变量

3.1 命名规则

• 标示符可以由字母、数字、下划线_ 、美元符号$组成

• 标示符开头不能是数字

• 标识符中的字符大小写敏感

• 标识符的长度没有限制

• 标示符不能使用java中的关键字或保留字

合法标示符	非法标示符
try1	try#
GROUP_1	1GROUP
helloworld	hello-world
_int	int
$int	$-int

3.2 推荐规则

• 类和接口，首字母大写，如果是俩个单词，第二个单词的首字母大写

例如，public class Account{} ，public interface AccountBase{}

• 方法和变量，首字母小写，如果是俩个单词，第二个单词的首字母大写

例如，public void getStudentName(){} ， int personNum = 1；

• 常量，全部字母大写，如果是俩个单词，使用下划线分隔

例如，public static final int MAX_NUM = 10;

• 尽量使用有意义的名字，尽量做到见名知义。

例如，int numOfStudnet = 10; String userName = "tom";

4 关键字

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import

instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

注意，const 和 goto 是java中的保留字

注意，true 和 false 不是关键字，是boolean类型的字面值，但是也不能直接使用true和false来做标

示符

5 基本类型

java中有八种基本数据类型，它们是java语言中，可以表示出来的最基本数据的结构。

这八种基本数据类型是：

• byte

• short

• int

• long

• float

• double

• char

• boolean

5.1 字节

计算机中，数据传输大多是以“位”（bit，比特）为单位，一位就代表一个0或1（二进制），每8个位

（bit）组成一个字节（Byte），所以，1个字节=8位0101代码，例如 0000 0001

例如，0000 0001 ，表示二进制的数字1，它是1个字节，共8位0101代码组成

十六进制有0 1 2 3 4 5 6 7 8 9 A B C D E F ，它的范围是0~15

每4位0101代码可以表示一个十六进制的数字，因为4位表示的最小值是 0000，最大值1111 ，刚好范围是

0~15

所以8位0101代码，刚好可以使用2位十六进制的数字来表示

例如，二进制的1111 1111 就可以使用 十六进制的 FF 来表示

5.2 boolean

布尔类型占1个字节（8位），它的的值，必须是true或者false，在JVM中会转换为1（true）或者

0（false）

5.3 char

char类型占2个字节（16位），用来表示字符，是基本数据类型，String表示字符串，是类类型。一

个String是由0~n个char组成

例如，字符使用单引号表示，字符串使用双引号表示。

public void test(){
    char c1 = 'a';
    char c2 = 'b';
    char c3 = 'c';
    String str = "abc";
}

5.3.1 字符编码

Java语言对文本字符采用Unicode编码。由于计算机内存只能存取二进制数据，因此必须为各个字符进行编码。

例如:a --编码--> 0000 0000 0110 0001

5.3.2 常见编码

• ASCII

ASCII--Amecian Standard Code for Information Interchange，美国信息交换标准代码。主用于表达现

代英语和其他西欧语言中的字符。它是现今最通用的单字节编码系统，它只用一个字节的7位，一

共表示128个字符。

• ISO-8859-1

又称为Latin-1, 是国际标准化组织(ISO)为西欧语言中的字符制定的编码，用一个字节(8位)来为字符

编码，与ASCII字符编码兼容。所谓兼容，是指对于相同的字符，它的ASCII字符编码和ISO-8859-1字

符编码相同。

• GB2312

包括对简体中文字符的编码，一共收录了7445个字符(6763个汉字+682个其他字符). 它与ASCII字符编

码兼容。

• GBK

对GB2312字符编码的扩展，收录了21886个字符(21003个字符+其它字符), 它与GB2312字符编码兼

容。

• Unicode

由国际Unicode协会编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。

Unicode具有两种编码方案：

用2个字节(16位)编码，被称为UCS-2, Java语言采用;

用4个字节(32位)编码，被称为UCS-4;

UCS(Universal Character Set)是指采用Unicode字符编码的通用字符集。

• UTF

有些操作系统不完全支持16位或32位的Unicode编码，UTF(UCS Transformation Format)字符编码能够把Unicode编码转换为操作系统支持的编码，常见的UTF字符编码包括UTF-8、UTF-16、UTF-32。

UTF-8，使用一至四个字节为每个字符编码，其中大部分汉字采用三个字节编码，少量不常用

汉字采用四个字节编码。因为 UTF-8 是可变长度的编码方式，相对于 Unicode 编码可以减少存储占用的空间，所以被广泛使用

UTF-16，使用二或四个字节为每个字符编码，其中大部分汉字采用两个字节编码，少量不常用

汉字采用四个字节编码。

UTF-32，使用四个字节为每个字符编码，使得 UTF-32 占用空间通常会是其它编码的二到四

倍。

5.3.3 char值

例如，字符'a'，的表示形式：

二进制数据形式为 0000 0000 0110 0001

十六进制数据形式为 0x0061

十进制数据形式为 97

//使用具体字符来表示a
char c = 'a';
//使用Unicode编码值表示字符a
char c = '\u0061';
//0x开头的数字位十六进制，使用十六进制表示字符a
char c = 0x0061;
//使用十进制数字表示字符a
char c = 97;
//0开头的数字为八进制，使用八进制表示字符a
char c = 0141;
//注意:一个中文汉字就是一个字符
char c = '中';

5.3.4 转义字符

在给字符变量赋值的时候，通常直接从键盘输入特定的字符，而不会使用Unicode字符编码，因为很难记

住各种字符的Unicode字符编码值。

但是对于有些特殊字符，比如一个单引号（'），如不知道它的Unicode字符编码，直接从键盘输入编译

错误：

常用转义字符	效果
\n	换行符，将光标定位到下一行的开头
\r	回车，把光标移动到行首(和环境有关)
\t	垂直制表符，将光标移到下一个制表符的位置
\\	反斜杠字符
\'	单引号字符
\"	双引号字符

5.4 整型

byte, short, int和long都是整数类型，并且都是有符号整数（正负）

• byte 8位、 1字节 范围:负2的7次方~2的7次方减1

• short 16位、2字节 范围:负2的15次方~2的15次方减1

• int 32位、4字节 范围:负2的31次方~2的31次方减1

• long 64位、8字节 范围:负2的63次方~2的63次方减

有符号整数把二进制数的首位作为符号数，当首位是0时，对应十进制的正整数，当首位是1时，对应十

进制的负整数。

在Java语言中，为了区分不同进制的数据，八进制数以“0”开头，十六制以“0x”开头,二进制以“0b”开头

byte b1 = 97; 十进制
byte b2 = 0141; 八进制
byte b3 = 0x61; 十六进制
byte b4 = 0b01100001; 二进制
//都是97打印出来
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);

整数类型的默认类型是int，对于给出一个字面值是99的数据，在没有指明这个数据是什么具体的类型的

情况下，那么java默认认为是int类型。

byte a = 1;
//编译报错
//a+1中a是byte类型,字面值1没有声明类型,那么默认是int
//byte是8位,int是32位,那么结果是32位的数字
//b只是一个byte类型的变量,那么只能接收8位的数字
//修改为int b = a+1;就可以编译通过
byte b = a+1;
//编译通过
//虽然1+1中的1都是默认的int类型
//但是这个俩个1都是固定的字面值
//编译器可以判断出其结果是否超出了byte表示的范围
//上面例子中a+1不能判断出结果的原因是:
//a是变量,是有可能发生变化的
byte c = 1+1;
//编译报错
//编译器判断出其结果超出了byte的表示范围(-128~127)
byte d = 1+127;
//编译报错
//原因:32位的数据赋值给byte类型的变量
//因为使用的1这些都是字面值,默认是int，注意关键点在在最左边的1，编译器不认为是符合位
//所以它默认是在前面补了24个0
byte e = 0b11111111;
//编译通过
//输出结果为255
//因为1的前面补了24个0
int e = 0b11111111;
//编译通过
//输出结果为-1
//因为这里做了类型强制转换
byte f = (byte)0b11111111;

注意，java中，正数取反在加1，就是对应的负数，负数取反再加1，就是对应的正数

注意，java中，等号（=）为赋值操作，表示把等号右边的值或计算结果，赋值给等号左边的变量

四种整型类型的声明：

byte a1 = 1; (内存中占8位) 1字节
short a2 = 1; (内存中占16位)2字节
int a3 = 1; (内存中占32位)4字节
long a4 = 1L; (内存中占64位)8字节

使用long类型数据的时候，后面要加大写L或者小写l,建议加上大写的L,因为小写的l和数字1很像

似。

5.5 浮点型

float和double都是java中的浮点型,浮点型可以用来表示小数，它们的二进制表示方式和整型不同

float是32位, 1符号位+8指数位+23尾数位

double是64位 1符号位+11指数位+52尾数位

float和double的精度是由尾数的位数来决定的。浮点数在内存中是按科学计数法来存储的.

• float的精度为7位左右有效数字

• double的精度为16位左右有效数字

俩种浮点型数据的声明：

//后面加f或者F
float f = 10.5f;
//后面加d或者D
double d = 10.5d;

浮点型的二进制形式：可以使用API提供的方法获取浮点数的二进制形式

float f = 10.5f;
int b = Float.floatToIntBits(f);
System.out.println(Integer.toBinaryString(b));

浮点型的默认类型是double,对于给出一个字面值是10.5的数据,在没有指明这个数据是什么具体的类型的情况下,那么java中默认认为是double类型。

例如，

//编译通过
//字面值1.5默认类型是double
double d = 1.5;
double d = 1.5D;
//编译报错
//字面值1.5默认类型是double
//double和float的精确度不一样
float f = 1.5;
//f2编译通过,因为字面值1的类型是int
//f3编译报错,因为字面值1.5的类型是double
float f1 = 10.5f;
float f2 = f1+1;
float f3 = f1+1.5;

Java中的浮点数类型float和double不能够进行精确运算，虽然大多数情况下是运行是正常的，但是偶尔

会出现如上所示的问题。

这个问题其实不是java语言的bug，而是因为计算机存储数据是二进制的，而浮点数实际上只是个近似

值，所以从二进制转化为十进制浮点数时，精度容易丢失，导致精度下降。

要保证运行结果的精度，可以使用BigDecimal类：

//add方法 +
//subtract方法 -
//multiply方法 *
//divide方法 /
BigDecimal d1 = BigDecimal.valueOf(1.0);
BigDecimal d2 = BigDecimal.valueOf(0.66);
double result = d1.subtract(d2).doubleValue();
System.out.println(result);
//输出结果:0.34

BigDecimal是java.math包中的类，使用时需要import导入

6 变量

java中的数据类型有八种基本类型，三种引用类型

八种基本类型：byte、short、int、long、float、double、boolean、char

三种引用类型：类类型、接口类型、数组类型

每一种类型都可以用来声明变量，而变量的作用就是用来接收、保存、传递、操作对应的数据的。

例如，有一个数字1，在程序中该如何接收、保存、操作、传递？

public void test(){
//声明int类型的变量a
int a;
//使用变量a接收数据1，其实也是把1赋值给变量a
a = 1;
//使用变量a进行操作，并把操作结果传给（赋值给）变量b
int b = a+a;
}

变量一定是要求先声明、再赋值、再使用

int a;//声明变量
a = 1;//给变量赋值
System.out.println(a);//使用变量的值
int b = 1;//声明变量的同时就进行赋值
System.out.println(b);//使用变量的值

java是强类型编程语言，要求数据的类型和变量的类型保持一致，才能使用 = 号进行赋值，就是把=号右边的数据，赋值给=号左边的变量。

如果=号右边的数据，和=号左边的变量类型不一致，那么只能做类型转换，把数据的类型转为变量的类

型，然后才能完成=号赋值操作。

只是类型转换的过程，分为手动转换和自动转换：

1. 手动转换

int a = 1;
byte b = (byte)a;

2. 自动转换

int a = 1;
long b = a;

7 理解对象

java是面向对象的编程语言，在面向对象的思想中，万事万物皆为对象。

对象无处不在，在描述一个场景的时候，大多数情况下，里面的名词表示的就是对象：

对象一般都会具有一些属性和方法

• 属性表示对象本身的一些特点

• 方法表示对象本身的一些行为

例如，

• 学生有身高、体重等属性，学生还有学习、运动等方法

• 老师有年龄、专业等属性，老师还有上课、布置作业等方法

• 教室有位置、大小等属性，教室还有添加学生、添加老师等方法

代码中如何获得对象？

第一步：抽象一种事物，来定义出需要的类

例如，定义一个类，用来描述学生对象应该具有的属性和方法

其实就是 根据学生的特点和行为 --抽象--》 Student类

package com.briup.day03;
/**
* 学生类，描述学生应该具有的属性和方法
*/
public class Student {
//学生编码
public long id;
//学生姓名
public String name;
//学生年龄
public int age;
//学生要说的话
public String msg;
//构造方法，用来创建一个具体的学生对象
public Student(long id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
} /
**
* 来吧，展示
* 先介绍自己的名字、学号和年龄
* 再说出自己想说的话
*/
public void show(){
System.out.println("I am "+name);
System.out.println("My studentNum is "+id);
System.out.println("I am "+age);
System.out.println(msg);
}
}

第二步：使用类中的构造方法，创建出这个类的对象

package com.briup.day03;
/**
* 学生类，描述学生应该具有的属性和方法
*/
public class Student {
//... 这里的代码和上面一样，这里省去不写了
//比上面代码多了一个main方法
public static void main(String[] args) {
//什么一个Student类型的变量
Student stu;
//new+构造器的方式，创建一个Student类具体对象
//并且把这个新创建出来的对象，赋值给了stu变量
stu = new Student(1L,"tom",20);
}
}

上面代码也可以这样写：Student stu = new Student();

Student类中的构造，和new关键字一起使用，就可以创建出一个Student类的对象

第三步：使用对象访问它的属性并赋值，使用对象调用类中定义的方法

package com.briup.day03;
/**
* 学生类，描述学生应该具有的属性和方法
*/
public class Student {
//... 这里的代码和上面一样，这里省去不写了
//main方法
public static void main(String[] args) {
//声明一个Student类型的变量
Student stu;
//new+构造器的方式，创建一个Student类具体对象
//并且把这个新创建出来的对象，赋值给了stu变量
stu = new Student(1L,"tom",20);
stu.msg = "可爱的朋友们，你们好么~";
stu.show();
}
}

这时候就完成了：

分析事物--》定义类--》声明属性/方法/构造器--》编写main方法--》创建对象--》使用对象访问属

性、调用方法 --》完成功能（来吧，展示）

8 引用类型变量

使用八种基本类型中的任意一种类型，声明出的变量，就是基本类型变量，例如 int a;

使用三种引用类型中的任意一种类型，声明出的变量，就是引用类型变量，例如 Student stu;

基本类型变量和引用类型变量的区别：

• 基本类型变量只能接收基本类型数据，它是一种比较简单的数据，没有属性，也没有方法

• 引用类型变量只能接收引用类型数据（也就是对象），但对象是一种比较复杂的数据，它里面可以

有很多属性，也可以有很多方法

引用类型变量，简称为引用，它可以用来接收对象，也叫做引用指向对象。

//a中没有任何属性和方法，它在这只是表示了一个很简单的数据1
int a = 1;
//stu接收了一个对象，它里面有属性和方法
Student stu = new Student(1L,"tom",20);
//使用stu可以访问属性并赋值
stu.msg = "hello world";
//使用stu可以调用方法
stu.show();

可以看出：

基本类型变量只能接收基本类型数据，只能表示最简单数字（8/16/32/64位）

引用类型变量只能接收引用类型数据（对象），可以访问属性、调用方法，完成比较复杂的功能

基本类型变量和引用类型的变量核心区别：是否可以指向对象