第 2 章 Java 基本语法（上）：变量
文章目录
-
-
- Java 基础知识图解
- 2.1 关键字与保留字
-
- 2.1.1 关键字的定义和特点
-
- 1.关键字
- 2.保留字 (reserved）
- 2.2 标识符(Identifier）
-
- 2.2.1 标识符：
- 2.2.2 定义合法标识符规则
- 2.2.3 Java 中的名称命名规范
- 2.3 变 量
-
- 2.3.1 基本数据类型
-
- 1.变量的概念：
- 2.变量的作用：
- 3.使用变量注意：
- img
- 4.**声明和赋值变量**
- 2.3.2 基本数据类型变量间转换
-
- 1.基本数据类型变量分类
- 2.按声明的位置的不同 的变量分类
- 3.整数类型： byte 、 short 、 int 、 long
- 4.浮点类型： float 、 double
- 5.字符类型： char
- 6.了解： ASCII 码
- 7.了解： Unicode 编码
- 8.了解： UTF 8
- 8.布尔类型： boolean
- 9.基本数据类型转换
- 10.强制类型转换
- 2.3.3 基本数据类型与 String 间转换
-
- 字符串类型： String
- 2.3.4 进制与进制间的转换
-
- 1.关于进制
- 2.二进制
- 为什么要使用原码、反码、补码表示形式呢？
- 3.二进制-->十进制
- 4.十进制 -->二进制：除 2 取余的逆
- 5.进制间转化
- 6.二进制 -->八进制、十六进制
- 每日一考
-
Java 基础知识图解
2.1 关键字与保留字
2.1.1 关键字的定义和特点
1.关键字
定义： 被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点： 关键字中所有字母都为 小写
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
2.保留字 (reserved）
- Java 保留字：现有 Java 版本尚未使用 但以后版本可能会作为关键字使 用。自己命名标识符时要避免使用这些保留字
- goto 、 const
2.2 标识符(Identifier）
2.2.1 标识符：
- Java 对各种 变量、方法 和 类 等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以起名字的地方都叫标识符 。
2.2.2 定义合法标识符规则
-
由 26 个英文字母大小写， 0 9 或 $ 组成
-
数字不可以开头。
-
不可以使用关键字和保留字，但能包含关键字和保留字。
-
Java 中严格区分大小写，长度无限制。
-
标识符不能包含空格。
练习： miles , Test, a++, a, 4#R, $4, #44, apps, class, public, int, x, y, radius
2.2.3 Java 中的名称命名规范
Java 中的名称命名规范：
-
包名 ：多单词组成时所有字母都小写 xxxyyyzzz
-
类名、接口名 ：多单词组成时，所有单词的首字母大写 XxxYyyZzz
-
变量名、方法名 ：多单词组成时，第一个单词首字母小写，第二个单词开始每个 单词首字母大写： xxxYyyZzz
-
常量名 ：所有字母都大写。多单词时每个单词用下划线连接 XXX_YYY_ZZZ
注意 1 ：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意 2 : java 采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用。
更多细节详见 《 代码整洁之道 .pdf 》
代码整洁之道.pdf
代码整洁之道_关于标识符.txt
2.3 变 量
2.3.1 基本数据类型
1.变量的概念：
-
内存中的一个存储区域
-
该 区域的数据可以在同一类型范围内不断变化
-
变量是程序中最基本的存储单元。包含 变量类型、变量名和存储的值
2.变量的作用：
- 用于在内存中保存数据
3.使用变量注意：
-
Java 中每个变量必须先声明，后使用（变量未被初始化，会造成编译错误）
-
使用变量名来访问这块区域的 数据
-
变量 的作用域 ：其定义所在的一对 {} 内----局部变量VS全局变量
-
变量只有在其作用域内才有效
-
同一 个作用域内，不能定义重名的变量
4.声明和赋值变量
声明变量
语法： 数据类型 > 变量名称
例如： int var;
变量的赋值
语法： 变量名称 > = 值
例如： var = 10;
声明和赋值变量
语法： 数据类型 变量名 >>= 初始化值
例如： int var = 10;
2.3.2 基本数据类型变量间转换
1.基本数据类型变量分类
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分 配了不同大小的内存空间。
2.按声明的位置的不同 的变量分类
在方法体外，类体内声明的变量称为 成员变量 。
在方法体内部声明的变量称为 局部变量 。
注意：二者在初始化值方面的异同
- 同： 都有生命周期
- 异： 局部变量除形参外，需显式初始化。
3.整数类型： byte 、 short 、 int 、 long
-
Java 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保 证 java 程序的可移植性。
-
java 的整型常量默认为 int 型，声明 long 型常量须后加‘ l’ 或‘ L’
-
java 程序中 变量 通常 声明 为 int 型，除非不足以 表示较大的数 ，才使用 long
500MB 1MB = 1024KB 1KB= 1024B B= byte ? bit?
bit: 计算机中的最小存储单位。 byte: 计算机中基本存储单元。
4.浮点类型： float 、 double
- 与整数类型类似， Java 浮点类型也有固定的表数范围和字段长度，不受具体操作 系统的影响。
- 浮点型常量有两种表示形式：
十进制数形式：如： 5.12 512.0f .512 ( 必须有小数点）
科学计数法形式 如： 5.12e2 512E2 100E 2
-
float: 单精度，尾数可以精确到 7 位有效数字。很多情况下，精度很难满足需求。
-
double: 双精度，精度是 float 的两倍。通常采用此类型。
-
Java 的浮点型常量默认为 double 型 声明 float 型常量，须后加‘ f’ 或‘ F’ 。
虽然单精度float与int同样为四个字节，但是表示的数值的范围比ong还大
5.字符类型： char
-
char 型数据用来表示通常意义上 字符 ”(2 字节
-
Java 中的所有字符都 使用 Unicode 编码，故一个字符可以存储一个字 母，一个汉字，或其他书面语的一个字符。
-
字符型变量 的三种表现形式：
1.字符常量是用单引号 ‘’ 括起来的单个字符。 例如： char c1 = ‘a’; char c2 = '中 '; char c3 = ’
2.Java 中还允许**使用转义字符‘ \’**来 将其后的字符转变为特殊字符型常量。
例如： char c3 = ‘ n’; //’\n’ 表示换行符
3.直接使用 Unicode 值来表示字符型常量：‘ uXXXX 。其中， XXXX 代表 一个十六进制整数。如： u000a 表示 n 。（资源：CodeCharts.pdf）
- char 类型是可以进行运算的。因为它都对应有 Unicode 码。
6.了解： ASCII 码
-
在计算机内部 所有数据都使用 二进制 表示 。 每一个二进制位 bit 有 0 和 1 两种状态 因此 8 个二进制位就可以组合出 256 种 状态 这被称为一个字节 byte ）。 一个字节一 共可以用来表示 256 种不同的状态 每一个状态对应一个符号 就是 256 个符号 从 0000000 到 11111111 。
-
ASCII 码 上个世纪 60 年代 美国制定了一套字符编码 对英语字符与二进制位之间的 关系 做了统一规定 。 这被称为 ASCII 码 。 ASCII 码一共规定了 128 个 字符的编码 比如 空格 SPACE” 是 32 二进制 00100000 大写的字母 A 是 65 二进制 01000001 ）。 这 128 个符号 包括 32 个不能打印出来的控制符号 只占用了一个字节的后面 7 位 最前 面的 1 位统一规定为 0 。
-
缺点
-
不能表示所有字符 。
-
相同的编码表示的字符不一样 比如 130 在法语编码中代表了 é 在希伯来语编码中却代表 了字母 Gimel ג
7.了解： Unicode 编码
-
乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因 此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读， 就会出现乱码 。
-
Unicode 一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一 无二的编码，使用 Unicode 没有乱码的问题 。
-
Unicode 的缺点： Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码 应该如何存储：无法区别Unicode 和 ASCII ：计算机无法区分三个字节表示一个符号 还是分别表示三个符号。另外， 我们知道，英文字母只用一个字节表示就够了，如果 unicode 统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有 二到三个字节是 0 ，这对于存储空间来说是极大的浪费。
8.了解： UTF 8
-
UTF 8 是在互联网上使用最广的一种 Unicode 的实现方式。
-
UTF 8 是一种变长的编码方式。它可以使用 1 6 个字节表示一个符号，根据 不同的符号而变化字节长度。
-
UTF 8 的编码规则：
-
对于单字节的 UTF 8 编码，该字节的最高位为 0 ，其余 7 位用来对字符进行编码（等同于 ASCII 码）。
-
对于多字节的 UTF 8 编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为 1 ，第一 个字节的第 n+1 位为 0 ，该字节的剩余各位用来对字符进行编码。在第一个字节之后的 所有的字节，都是最高两位为 " 10"，其余 6 位用来对字符进行编码。
-
详见 :《计算机字符编码 .docx 》
8.布尔类型： boolean
- boolean 类型用来判断逻辑条件，一般用于程序流程控制：
if 条件控制语句；
while 循环控制语句；
do while 循环控制语句；
for 循环控制语句；
- boolean 类型数据只允许取值 true 和 false ，无 null 。
不可以使用 0 或非 0 的整数替代 false 和 true ，这点和 C 语言不同。
Java 虚拟机中没有任何供 boolean 值专用的字节码指令， Java 语言表达所操作的 boolean 值，在编译之后都使用 java 虚拟机中的 int 数据类型来代替： true 用 1 表示， false 用 0 表示。 《 java 虚拟机规范 8 版 》
/*
Java定义的数据类型
一、变量按照数据类型来分：
基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：
类(class)
接口(interface)
数组(array)
二、变量在类中声明的位置：
成员变量 vs 局部变量
*/
class VariableTest1 {
public static void main(String[] args) {
//1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
//① byte范围：-128 ~ 127
//
byte b1 = 12;
byte b2 = -128;
//b2 = 128;//编译不通过
System.out.println(b1);
System.out.println(b2);
// ② 声明long型变量，必须以"l"或"L"结尾
// ③ 通常，定义整型变量时，使用int型。
short s1 = 128;
int i1 = 1234;
long l1 = 3414234324L;
System.out.println(l1);
//2. 浮点型：float(4字节) \ double(8字节)
//① 浮点型，表示带小数点的数值
//② float表示数值的范围比long还大
double d1 = 123.3;
System.out.println(d1 + 1);
//③ 定义float类型变量时，变量要以"f"或"F"结尾
float f1 = 12.3F;
System.out.println(f1);
//④ 通常，定义浮点型变量时，使用double型。
//3. 字符型：char (1字符=2字节)
//① 定义char型变量，通常使用一对'',内部只能写一个字符
char c1 = 'a';
//编译不通过
//c1 = 'AB';
System.out.println(c1);
char c2 = '1';
char c3 = '中';
char c4 = 'ス';
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
//② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
char c5 = '\n';//换行符
c5 = '\t';//制表符
System.out.print("hello" + c5);
System.out.println("world");
char c6 = '\u0043';
System.out.println(c6);
//4.布尔型：boolean
//① 只能取两个值之一：true 、 false
//② 常常在条件判断、循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried){
System.out.println("你就不能参加\"单身\"party了！\\n很遗憾");
}else{
System.out.println("你可以多谈谈女朋友！");
}
}
}
9.基本数据类型转换
- 自动类型转换 ：容量小的类型自动转换为容量大的数据类型。数据类型按容 量大小排序为：
(此时容量的大小是指数的范围的大和小，而不是占的储存量。比如)
-
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的
-
那种数据类型，然后再进行计算。
-
byte,short,char 之间不会相互转换，他们三者在计算时首先转换为 int 类型 。
-
boolean 类型不能与其它数据类型运算。
-
当把任何 基本 数据 类型 的值和字符串 ( 进行连接运算时 基本数据类 型 的值将自动转化为 字符串 ( 类型 。
/*
基本数据类型之间的运算规则：
前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
1. 自动类型提升：
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
2. 强制类型转换：见VariableTest3.java
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2 {
public static void main(String[] args) {
byte b1 = 2;
int i1 = 129;
//编译不通过
//byte b2 = b1 + i1;
int i2 = b1 + i1;
long l1 = b1 + i1;
System.out.println(i2);
float f = b1 + i1;
System.out.println(f);
short s1 = 123;
double d1 = s1;
System.out.println(d1);//123.0
//***************特别地*********************
char c1 = 'a';//97
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4);
short s2 = 10;
//char c2 = c1 + s2;//编译不通过
byte b2 = 10;
//char c3 = c1 + b2;//编译不通过
//short s3 = b2 + s2;//编译不通过
//short s4 = b1 + b2;//编译不通过
//****************************************
}
}
10.强制类型转换
- 自动类型转换的逆过程 将容量大的数据类型转换为容量小的数据类型 。 使 用时要加上强制转换符 但可能造成 精度降低或溢出 格外要注意 。
- 通常 字符串不能直接转换为基本类型 但通过基本类型对应的包装类则可 以实现把字符串转换成基本类型 。
如 String a = “ 43 ”; int i = Integer.parseInt (
boolean 类型不可以转换为其它的数据类型 。
/*
强制类型转换：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。
*/
class VariableTest3 {
public static void main(String[] args) {
double d1 = 12.9;
//精度损失举例1
int i1 = (int)d1;//截断操作
System.out.println(i1);
//没有精度损失
long l1 = 123;
short s2 = (short)l1;
//精度损失举例2
int i2 = 128;
byte b = (byte)i2;
System.out.println(b);//-128
}
}
class VariableTest4 {
public static void main(String[] args) {
//1.编码情况1：
long l = 123213;
System.out.println(l);//编译成功，原因是没有f就默认int，然后自动转换为long
//编译失败：过大的整数
//long l1 = 21332423235234123;
long l1 = 21332423235234123L;
//****************
//编译失败
//float f1 = 12.3;
float f1 = (float)12.3;
//2.编码情况2：
//整型常量，默认类型为int型
//浮点型常量，默认类型为double型
byte b = 12;
//byte b1 = b + 1;//编译失败
//float f1 = b + 12.3;//编译失败
}
}
2.3.3 基本数据类型与 String 间转换
字符串类型： String
-
String 不是基本数据类型，属于引用数据类型
-
使用方式与基本数据类型一致。例如 String str = “abcd”
-
一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str + “xyz” ;
int n = 100;
str = str + n；
/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型
*/
class StringTest {
public static void main(String[] args) {
String s1 = "Hello World!";
System.out.println(s1);
String s2 = "a";
String s3 = "";
//char c = '';//编译不通过
//***********************
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number;// +：连接运算
boolean b1 = true;
String info1 = info + b1;// +：连接运算
System.out.println(info1);
//***********************
//练习1
char c = 'a';//97 A:65
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
//练习2
//* *
System.out.println("* *");//可以实现
System.out.println('*' + '\t' + '*');//93
System.out.println('*' + "\t" + '*');//可以实现
System.out.println('*' + '\t' + "*");//53*
System.out.println('*' + ('\t' + "*"));//可以实现
//***********************
//String就是不能在数值上与八个类型进行计算和转换！！
//String str1 = 123;//编译不通过
String str1 = 123 + "";
System.out.println(str1);//"123"
//int num1 = str1;
//int num1 = (int)str1;//"123"
int num1 = Integer.parseInt(str1);
System.out.println(num1);//123
}
}
2.3.4 进制与进制间的转换
世界上有 10 种人 ，认识和不认识二进制的。
1.关于进制
- 所有 数字在 计算机 底层都以 二进制 形式存在 。
- 对于 整数，有四种表示方式：
二进制 ( 0,1 ，满 2 进 1. 以 0b 或 0B 开头。
十进制 ( 0 9 ，满 10 进 1 。
八进制 ( 0 7 ，满 8 进 1. 以数字 0 开头 表示。
十六进制 ( 0 9 及 A F ，满 16 进 1. 以 0x 或 0X 开头 表示。此处的 A F 不区分大小写。
如： 0x21AF +1= 0X21B0
2.二进制
- Java 整数常量默认是 int 类型，当用二进制定义整数时，其第 32 位是符号位； 当是 long 类型时，二进制默认占 64 位，第 64 位是 符号位
- 二进制的整数有如下三种形式：
原码 ：直接将一个数值换成二进制数。最高位是符号位
负数的反码 ：是对原码按位取反，只是最高位（符号位）确定为 1 。
负数的补码 ：其反码加 1 。
- 计算机以二进制 补码 的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码 +1
为什么要使用原码、反码、补码表示形式呢？
计算机 辨别“符号位”显然 会让计算机的基础电路设计变得十分复杂 ! 于是 人们想出了将符号位也参与运算的方法 . 我们知道 , 根据运算法则减去一个正 数等于加上一个负数 , 即 : 1 1 = 1 + ( 1) = 0 , 所以机器可以只有加法而没有 减法 , 这样计算机运算的设计就更简单 了 。
3.二进制–>十进制
4.十进制 -->二进制：除 2 取余的逆
5.进制间转化
进制的基本转换
- 十进制 二进制互转
二进制转成十进制 乘以 2 的幂 数
十进制转成二进制 除以 2 取余数
-
二进制 八进制互转
-
二进制 十六进制互转
-
十进制 八进制互转
-
十进制 十六进制互转
6.二进制 -->八进制、十六进制
每日一考
1.标识符的命名规则有哪些？不遵守，编译不通过。
-
由 26 个英文字母大小写， 0 9 或 $ 组成
-
数字不可以开头。
-
不可以使用关键字和保留字，但能包含关键字和保留字。
-
Java 中严格区分大小写，长度无限制。
-
标识符不能包含空格。
2. 标识符的命名规范有哪些？不遵守，编译运行都可以通过
包名:xxxyyyzzz
类名、接口名：XxxYyyZzz
变量名、方法名：xxxYyyZzz
常量名：XXX_YYY_ZZZ
3. Java变量按照数据类型怎么划分？并指出Java的基本数据类型有哪8种，并指出各自占用的内存空间大小
byte1 short2 int4 long8
char2
float4 double8
boolean
引用数据类型：类、接口、数组
4. 说明基本数据类型变量之间自动类型提升的运算规则。
byte、short、char -->int–>long–>float–>double
5. 说明基本数据类型变量之间强制类型转换的使用规则和强转可能出现的问题。
容量大–>容量小
使用强转符：()
精度损失。
2.4 运算符 2.5 程序流程控制 （见下节）