1. 关键字和保留字
关键字(keyword)是指被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
其特点就是关键字中所有字母都为小写
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
保留字(reserved word) 是当前Java版本尚未使用, 但以后版本可能会作为关键字使用
例如goto,const
2. 标识符
标识符: Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
标识符命名规则：
- 标识符由
字母(26个英文字母大小写)，数字(0-9)，_或$组成 - 标识符不能以数字开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中标识符严格区分大小写，长度无限制。
- 标识符最好见名知意
Java中命名规范
- 包名：多单词组成时所有字母都小写：
xxxyyyzzz - 类名、接口名：多单词组成时，采用大驼峰, 每个单词首字母都大写：
XxxYyyZzz - 变量名、属性名、方法名：多单词组成时，采用小驼峰, 除第一个单词,其他单词首字母大写：
xxxYyyZzz - 常量名：所有字母都大写。多单词时每个单词用下划线连接：
XXX_YYY_ZZZ
3. 变量
3.1 变量概念:
对于变量的理解
- 通过自定义名称(变量)来标识内存中的一个存储区域, 存储数据
- 该区域的数据可以在同一类型范围内不断变化
- 变量是 程序中最基本的存储单元, 构成包括三个要素包括类型, 变量名,和存储的值
变量的作用就是在内存中开辟一块区域, 用于保存数据
3.2 变量声明以及赋值
变量声明的语法
// 数据类型 变量名称
int count // 这里表示声明了一个int 类型的变量, 变量名称为 count
变量的赋值
// 使用 = 进行赋值
count = 20 // 表示将20赋值给变量count,
赋值可以理解为在count 变量对应的内存中存储了20这个数值
也可以在声明变量的时直接赋值
// 声明变量时直接赋值
int count = 20
java是一个强类型的语言, 每个变量必须明确类型, js是弱类型的语言,定义变量 并不需要明确变量类型
/*
变量的格式:类型 变量名 = 变量值
*/
class VariableTest{
public static void main(String[] args) {
// 变量的定义
int myAge = 13;
// 变量的使用
System.out.println(myAge);
}
}
3.3 变量使用的注意事项
- Java中每个变量必须先声明,在使用,不同类型的变量具有不同的存储范围
- 变量的作用域, 其定义所在的一对
{}中 - 变量只有在其作用域内才有效
- 同一作用域内,不能定义重名的变量
关于变量先声明再使用的注意点:
- java中变量必须先声明在使用, 否则编译错误
- 声明后变量必须先赋初始值, 在使用, 否则编译错误
class VariableTest{
public static void main(String[] args) {
// 1. 变量myNumber声明之前使用
// 编译错误: 找不到变量myNumber
// System.out.println(myNumber);
// int myNumber;
// 2.变量初始赋值前使用
// 编译报错:可能尚未初始化变量myNumber
int myNumber;
System.out.println(myNumber);
// 3. 正确使用
int myNumber;
myNumber = 40 ;
// 或者 int myNumber = 40
System.out.println(myNumber);
}
}
3.4 var 关键字
有的时候,我们不想明确变量的类型, 则可以使用var 关键字来声明变量,
此时变量的类型将会根据其赋值的数据类型来决定.
示例:
var a = 10;
var b = 3.14;
需要注意的是, 使用var 声明变量, 必须在声明变量时,立即初始化, 不能向之前一样先声明变量在赋值
// 先声明变量, 在赋值
int a;
a = 30;
// 此时无法确定 变量b的类型
var b;
b = 20;</pre>
4. 数据类型
数据类型就是对于每一种数据都定义了明确的具体类型，用于标识在内存中分配不同大小的内存空间存储数据。
4.1 数据类型的分类
基本数据类型(8种):
- 整型: byte / short / int / long
- 浮点型: float / double
- 字符型: char
- 布尔型: boolean
引用数据类型
- 类: class (注意:字符串使用类, char只是字符型, 只能存一个字符)
- 接口: interface
- 数组: array
- 枚举: enum
- 注解 annotation
- 记录 record
4.2 整数类型:
java各整数类型有固定的表数范围和字段长度, 以保证java程序的可移植性
java的整型常量默认使用int 类型, 如果声明long 类型,数字后须添加'l'或'L'
java程序中变量通常声明int 类型, 除非不足以 表示较大的数,才使用long 类型
| 类型 | 占用的存储空间 | 表数范围 |
|---|---|---|
| byte | 1字节 = 8bit位 | -128~127 |
| short | 2字节 | -215 ~215 -1 |
| int | 4字节 | -231~231 -1 |
| long | 8字节 | -263 ~ 263 -1 |
bit: 计算机中最小的存储单位, byte:计算机中最小的存储单元
class VariableTest{
public static void main(String[] args) {
// 1. 整型: byte (1字节=8bit) \ short (2字节) \ int (4字节) \ long(8字节)
// 1.1 byte 范围: -128~127
// byte num = 127;
byte num = -128;
System.out.println(num);
// 超出表数范围编译不通过
// num = 128;
// System.out.println(num);
// 1.2. 通常定义整型变量时使用int
short snum = 128;
System.out.println(snum);
int inum = 123456;
System.out.println(inum);
// 1.3 声明long型变量,必须字数字结尾添加l 或 L
// 输出是不会显示l 或 L
long lnum = 445646798797L;
System.out.println(lnum);
}
}
开发中,大家定义整型变量时, 没有特殊情况的话, 通常都声明为int类型
4.3 浮点型
与整数类型类似,java浮点类型也有固定的表数范围和长度, 不受具体操作系统的影响
浮点型常量有两种表示形式
- 十进制数形式: 如: 5.12 5.1f .58
- 科学技术法形式: 如: 5.12e2 512E2 100E-2
Java 支持两种浮点类型的小数
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度 float | 4字节 | -3.403E38 ~ 3.403E38 |
| 双精度 double | 8字节 | -1.798E308 ~ 1.798E308 |
注意: java浮点型常量默认使用double , 因为float不仅精度不高, 而且声明float类型常量时, 常量后必须加'f'或'F'
示例:
class VariableTest{
public static void main(String[] args) {
// 2.浮点型: float(4字节) \ doubl(8字节)
// 2.1 浮点型, 表示小数数字
// 2.2 float 表示数值的范围比long还大,但是精度不高
// 2.3 定义float类型变量时,变量要以f 或 F结尾(否则编译不通过)
float fnum = 123.3f;
System.out.println(fnum);
// 2.4 常用double类型 声明浮点类型变量
double dnum = 123.456789;
System.out.println(dnum);
}
}
在开发过程中, 定义浮点类型,在没有特殊情况下, 通常都声明为double类型.因为精度更高
4.4 字符类型
java采用Unicode编码的一个分支UCS-2, 每个字符采用两个字节(16个二进制位)进行编码
所以在存字符时, 无论是英文字符还是中文字符, 都占用两个字节
char 类型声明的变量只能存一个字符.
字符型变量值有三种表现形式
- 使用单引号(’ ')括起来的单个字符, 也是最常使用的,例如: char c1=‘a’
- 直接使用Unicode值来表示字符型常量: ‘\uxxxx’, xxxx 表示一个十六进制整数, 例如 \u0061 表示’a’
- java中还允许使用转义字符
'\'来将其后的字符转为特殊字符型常量, 例如: char c3=‘\n’ 表示换行符
示例:
class VariableTest{
public static void main(String[] args) {
// 3. 字符类型: char (1字符 = 2字节)
// 表示方式(即存的值写法方式):
// 3.1. 声明一个字符(字面量)
char c2 = '中';
System.out.println(c2);
// 2. 转义字符
char c3 = '\n'; //换行符
System.out.print(" hello" + c3);
System.out.println("world" );
// 3.直接使用unicode值表示字符型常量(不常用)
char c4 = '\u0043'; //unicode字符
System.out.println(c4);
}
}
char 类型是可以进行运算的, 因为都是对应的Unicode 码
char c1 = 'A';
// 字符类型 c1 参与运算
int c2 = c1 + 1;
System.out.println("c2:"+ c2);
4.5 布尔类型
布尔类型只有两个值: true ,false,通常用于逻辑判断,一般使用在流程控制语句
- if 条件控制语句
- while 循环控制语句
- for 循环控制语句
- do-while 循环控制语句
示例:
class VariableTest{
public static void main(String[] args) {
// 4. 布尔类型: boolean(true,false)
// 常用用于逻辑判断
boolean bb = true;
System.out.println(bb); // true
// 示例(判断是否成年)
boolean isAdult = true;
if(isAdult){
System.out.println("恭喜你成年了!");
}else{
System.out.println("很遗憾!你没有成年,不能上网.");
}
}
}
真正内存分配,是分配4个字节
5. 基本数据类型转换
5.1 自动类型转换
将一种数据类型的数据赋给另一个类型的变量时, 在满足以下情况下, 将执行自动类型转换
- 两种数据类型彼此兼容
- 目标类型的取值范围大于原数据类型(低级类型数据转换为高级类型)
示例:
// 将int 类型的常量值赋值给long类型的变量, 会自动类型提升
long l1 = 100;
自动类型转换(自动类型提升)的规则: 容量小的变量与容量大的变量做运算时, 结果自动转为容量大的数据类型
也就是说, 在运算过程中,由于不同的数据类型会转换成同一种数据类型，所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据, 转换的规则如下:
-
数值型数据的转换：byte→short→int→long→float→double
-
字符型转换为整型：char→int。
示例:
// 声明不同类型的变量
byte b1 = 10;
short s1 = 30;
int i1 = 40;
long l1 = 100l;
float f1 = 3.14f;
double d1 = 5.8;
char c1 = 'a';
// 计算总数
double total = b1 + s1 + i1 + l1 + f1 + d1 + c1;
System.out.println("total: " + total);
这种多种类型进行运算, 最后输出容量最大的类型数据, 这种转换一般称为"表达式类型自动提升"
不同类型数据进行运算,需要注意一下几点:
- byte与 char, short与char 之间, 不会自动类型转换, 不能直接相互赋值
- boolean 类型不能与其他数据类型进行运算
- 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)基本数据类型的值将自动转化为字符串(String)类型。
示例:
public class Example {
public static void main(String[] args){
// 示例1:
// long类型的值需要以l,或L结尾, 但不添加l/L结尾也不会错误:
// 原因在于, 此时123123 值会被理解为int类型, 然后将int类型的值赋值给long
// 即将容量小的int 类型数据复制给 容量大的long 类型, 会自动类型提升
long l1 = 123123;
// 因此如果你的值要超出int数值范围就会报错
// long l2 = 123456789123456; // 123456789123456会被理解为int类型, 但超出了int范围,所以报错
long l3 = 123456789123456L; // 123456789123456L 被理解为long类型,所以不会报错
// 示例2:
// float类型值需要使用f或F结尾, 否则报错
// flot f1 = 3.14; // 3.14 会被理解为double类型, 不满足类型提升(float ---double), 所以报错
}
}
5.2 强制类型转换
自动类型转换只能从容量低的类型变量转容量高的类型变量, 如果需要将容量高的类型赋值给容量低的类型变量, 则会报错
例如: 将3.14 赋值给 int 类型变量
int i = 3.14; // 编译失败
此时会编译失败, 如果想要赋值成功,只能通过强制类型转行, 将double类型强制转换为int类型才能赋值成功
所以当两种数据类型不兼容，或目标类型的取值范围小于源类型时，自动转换将无法进行，这时就需要进行强制类型转换。其语法格式如下：
(type)variableName
将variableName 值强制换行为type 类型
示例:
int i = (int)3.14;
将double类型的3.14 强转为int类型, 结果为3
规则:
- 将取值范围大(或容量大)的类型转行为取值范围小(或容量小)的类型,需要使用类型转换
- 强制类型转换需要使用强转符: (), 在()内指明要转换为的数据类型.
- 强制类型转换可能会导致精度损失
- boolean类型不可以转换为其它的数据类型
示例:
public class Example {
public static void main(String[] args){
// 练习1:
long l1 = 12; // 自动类型提升
// 编译失败
// int i1 = l1;
// 使用强制类型转换
int i1 = (int)l1;
System.out.println(i1); // 12
// 练习2:
double d1 = 10;
short s1 = (short)d1;
System.out.println(s1); // 10
// 练习3
int i2 = 123;
float f1 = (float)i2; // 此时会自动类型提升, 因此强类型转换(float)可以省略
System.out.println(f1); // 123.0
// 练习4
// 精度损失示例1
double d2 = 12.9;
int i3 = (int)d2;
System.out.println(i3); // 输出12, 12.9中的.9 损失了
// 精度损失示例2
int i4 = 128;
byte b1 = (byte)i4;
System.out.println(b1); // -128
}
}
6. String 字符串类型
6.1 String 类型理解
字符串理解
和char 类型不同，字符串类型String 是引用类型，我们用双引号"..." 表示字符串。一个字符串可以存储0个到任意个字符：
String s1 = ""; // 空字符串, 包含0个字符
String s2 = "A"; // 包含1个字符
String s3 = "hello"; // 包含5个字符
String s4 = "你好"; // 包含中文字符
双引号"" 是字符串类型的界定符, 因此在双引号("") 不能包含双引号("")
如果要在"" 包含"" , 必须使用转义字符, 将具有特殊意义的字符" 转为普通字符串\"
String str = "abc\"xyz";
// 字符串中包含7个字符串 a b c " x y z
此时字符串中的" 因为转义符\ 的原因, 将不再具有字符串界定符的意义, 只是表示一个普通字符
String类的理解
-
String类, 属于引用数据类型, 俗称字符串
-
String类型的变量,可以使用一对
""的方式进行赋值 -
String声明的字符串内容部, 可以包含0个或多个字符
字符串拼接
多个字符串采用+ 进行拼接, 组成一个全新的字符串
String str = "Hello" + " World";
多行字符串
可以使用+拼接多行字符串
String str = "大家好!"
+ "我是一个程序员,"
+ "工作就是打键盘";
使用+ 拼接多行字符串非常不方便, 从Java 13 开始, 可以使用"""...""",表示多行字符串, 即可以在字符串中换行
String str = """
大家好!
我是一个程序员
工作就是打键盘
""";
System.out.println(str);
需要注意的是, 这种写法最后会有一个换行符, 以及每一行前的空格会被去除.
因此其输出结果为:
大家好!
我是一个程序员
工作就是打键盘
// 这里有一个空行
字符串不可变性
Java 中的字符串是一个引用类型, 其具有不可变性
不可变性指的是字符串内容不可变
String str = "hello";
str = "world";
System.out.println(str);
这种写法看似修改了字符串, 其实不然, 修改的是变量str的指向
也就是说, 当执行str = world 时, 并不是修改原字符串hello , 而是会在新的内存中创建world 字符串, 并修改变量str 的指针,指向新的字符串, 原来的字符串还在, 只是无法通过变量来访问
空值null
引用类型变量, 声明后未初始化,不可访问, 因此可以让让引用类型变量指向一个空值null, 表示不指向任何对象
String str = null;
System.out.println(str);
注意要区分空值null和空字符串""，空字符串是一个有效的字符串对象，它不等于null。
6.3 基本数据类型和String的运算
String与基本数据类型变量之间的运算
-
String类型与基本数据类型变量之间只能做连接运算, 使用"+"表示
-
运算的结果是String类型
class Example {
public static void main(String[] args){
// String类型与基本数据类型拼接
String str1 = "Hello";
System.out.println(str1); // Hello
int age = 10;
String str2 = str1 + age ; // 字符串拼接
System.out.println(str2); // Hello10
boolean b1 = true;
String str3 = str1 + b1;
System.out.println(str3); // Hellotrue
// 注意特殊情况:
// 此种写法编译不能通过, 因为按照运算逻辑从左向右的原则
// 回先计算 int类型 age与boolean 类型 b1相加, 此时运算报错
// String str4 = age + b1 + str1;
// 换一种写法
// 此时编译通过, 因为先运算String类型 变量str1 与 int类型age的拼接, 返回依然是String类型
// 然后再与boolean类型 b1拼接, 返回依然是String
String str4 = str1 + age + b1;
System.out.println(str4); // Hello10true
}
}