适合Java期末的复习~
（Java期末复习知识点总结分为4篇，这里是第一篇，每天一篇不会太累哦~）
第二篇~
https://blog.csdn.net/qq_53869058/article/details/129475124?spm=1001.2014.3001.5501
第三篇~https://blog.csdn.net/qq_53869058/article/details/129516371?spm=1001.2014.3001.5501
第四篇~https://blog.csdn.net/qq_53869058/article/details/129569329?spm=1001.2014.3001.5501
目录
一、初识Java
1. Java语言发展简史
Java 语言源于 1991 年 4 月， Sun 公司 James Gosling 博士 领导的绿色计划 (Green Project) 开始启动，此计划最初的目标是开发一种能够在各种消费性电子产品( 如机顶盒、冰箱、收音机等 ) 上运行的程序架构。这个就是 Java 的前身： Oak ( 得名与 Java 创始人 James Gosling 办公室外的一棵橡树 ) ，但由于这些智能化家电的市场需求没有预期的高，Sun 公司放弃了该项计划。随着 1995 年代互联网的发展 ， Sun 公司看见 Oak 在互联网上应用的前景，于是改 造了 Oak ，于 1995 年 5 月以 Java 的名称正式发布，并提出 “Write once, Run anywhere" 的口号 。
2. Java语言特性
以下
Java
语言特性来自于
Java
白皮书：
（1） 简单性（2） 面向对象：在 Java 的世界里，一切皆对象。（3） 分布式 ( 微服务)（4） 健壮性（5）安全性（6）体系结构中立：Java编译器通过生成与特定计算机体系结构无关的字节码指令来实现
这一特性。（7）可移植性：基本数据类型的大小以及有关运算都做了明确的说明。
（8） 解释性（9） 高性能（10） 多线程（11）动态性
3. 初识main方法
//类
public class HelloWorld{
//方法
public static void main(String[] args){
//语句
System.out.println("Hello,world");
}
}1. 源文件（扩展名为 *.java) ：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。2. 类：类中带有一个或多个方法。方法必须在类的内部声明。3. 方法：在方法的花括号中编写方法应该执行的语句。总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。
在一个源文件中只能有一个
public
修饰的类，而且源文件名字必须与
public
修饰的类名字相同
。
4. 运行Java程序
Java
程序最终是在
JVM(Java
虚拟机
)
中运行的。
【例题】JDK
、
JRE
、
JVM
之间的关系？
JDK(Java Development Kit):Java 开发工具包，提供给 Java 程序员使用，包含了 JRE ，同时还包含了编译器javac 与自带的调试工具 Jconsole 、 jstack 等。JRE(Java Runtime Environment):Java 运行时环境，包含了 JVM ， Java 基础类库。是使用 Java 语言编写程 序运行的所需环境。JVM ： Java 虚拟机，运行 Java 代码
5. 注释
单行注释：// 注释内容（用的最多）多行注释：/* 注释内容*/（不推荐）文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档【注意】1. 多行注释不能嵌套使用2. 不论是单行还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息。
6. 标识符
【 硬性规则 】标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写 。【 软性建议 】类名：每个单词的首字母大写( 大驼峰 )方法名：首字母小写，后面每个单词的首字母大写( 小驼峰 )变量名：与方法名规则相同
【例题】
下面那些标识符是合法的？
A
：
class B
：
HelloWorld C
：
main D
：
123abc E
：
ARRAY_SIZE F: $name G: name:jim
答：BCEF
7. 关键字
关键字是由
Java
语言提前定义好的，有特殊含义的标识符，或者保留字
。
一些常见的关键字：
| 关键字 | 含义 |
| abstract | 表明类或者成员方法具有抽象属性 |
| boolean | 基本数据类型之一，声明布尔类型的关键字（只有true和false值） |
| break | 提前跳出一个块 |
| byte | 基本数据类型之一，字节类型 |
| case | 用在switch语句之中，表示其中的一个分支 |
| char | 基本数据类型之一，字符类型 |
| class | 声明一个类 |
| continue | 回到一个块的开始处 |
| default | 默认，例如，用在switch语句中，表明一个默认的分支 |
| double | 基本数据类型之一，双精度浮点数类型 |
| else | 用在条件语句中，表明当条件不成立时的分支 |
| extends | 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口 |
| float | 基本数据类型之一，单精度浮点数类型 |
| for | 一种循环结构的引导词 |
| if | 条件语句的引导词 |
| import | 表明要访问指定的类或包 |
| int | 基本数据类型之一，整数类型 |
| long | 基本数据类型之一，长整数类型 |
| new | 用来创建新实例对象 |
| private | 一种访问控制方式：私用模式 |
| protected | 一种访问控制方式：保护模式 |
| public | 一种访问控制方式：共用模式 |
| return | 从成员方法中返回数据 |
| short | 基本数据类型之一,短整数类型 |
| switch | 分支语句结void |
| void | 声明当前成员方法没有返回值 |
| while | 声明当前成员方法没有返回值 |
二、数据类型与变量
1. 数据类型
在
Java
中数据类型主要分为两类：
基本数据类型
和
引用数据类型
。
基本数据类型有八种：
【注意】整形和浮点型都是带有符号的整型默认为 int 型，浮点型默认为 double
什么是字节?
字节是计算机中表示空间大小的基本单位.计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).我们平时的计算机为 8GB 内存, 意思是 8G 个字节.其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.
2. 变量
（1）语法格式
定义变量的语法格式为：
数据类型 变量名 = 初始值;
比如：
int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
// 注意：在一行可以定义多个相同类型的变量
int a1 = 10, a2 = 20, a3 = 30;（2）整型变量
//方式一：在定义时给出初始值
int a = 10;
// 方式二：在定义时没有给初始值，但使用前必须设置初值
int b;
b = 10;
// int型变量所能表示的范围：
System.Out.println(Integer.MIN_VALUE);
System.Out.println(Integer.MAX_VALUE);【注意事项】推荐使用方式一定义，如果没有合适的初始值，可以设置为 0在给变量设置初始值时，值不能超过 int 的表示范围，否则会导致溢出变量在使用之前必须要赋初值，否则编译报错int 的包装类型为 Integer
（3）长整型变量
long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l（4）字节型变量
byte b = 10; //byte的范围是：-128 ~ 127
（5）浮点型变量
double d = 3.14;
float num = 1.0f; // 写作 1.0F 也可以神奇的代码：int a = 1; int b = 2; System.out.println(a / b); // 输出 0.5 吗？在 Java 中 , int 除以 int 的值仍然是 int( 会直接舍弃小数部分 ) 。如果想得到 0.5, 需要使用 double 类型计算
（6）字符型变量
// 单引号 + 单个字母 的形式表示字符字面值
char c1 = 'A'; // 大写字母
char c2 = '1'; // 数字字符
（7）布尔型变量
boolean b = true;
boolean c = false;【注意】1. boolean 类型的变量只有两种取值 , true 表示真 , false 表示假 .2. Java 的 boolean 类型和 int 不能相互转换 , 不存在 1 表示 true, 0 表示 false 这样的用法 .
3. 类型转换
3.1 自动类型转换
自动类型转换即：
代码不需要经过任何处理，在代码编译时，编译器会自动进行处理
。特点：
数据范围小的转为数
据范围大的时会自动进行
。
System.Out.println(1024); // 整型默认情况下是int
System.Out.println(3.14); // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
float f = 3.14F;
double d = 5.12;
d = f; // 编译器会将f转换为double，然后进行赋值
f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
3.2 强制类型转换
强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小的。
int a = 10;
long b = 100L;
b = a; // int-->long，数据范围由小到大，隐式转换
a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
float f = 3.14F;
double d = 5.12;
d = f; // float-->double，数据范围由小到大，隐式转换
f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
a = d; // 报错，类型不兼容
a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
boolean flag = true;
a = flag; // 编译失败：类型不兼容
flag = a; // 编译失败：类型不兼容【注意】如果需要把范围大的类型赋值给范围小的 , 需要强制类型转换 , 但是 可能精度丢失强制类型转换不一定能成功，不相干的类型不能互相转换
4. 类型提升
不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
(1) int与long之间：int会被提升为long
int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long
2.
byte
与
byte
的运算
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte c = a + b;结论 : byte 和 byte 都是相同类型 , 但是出现编译报错 . 原因是 , 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算 , 得到的结果也是 int, 这是赋给 c, 就会出现上述错误 .由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据 . 为了硬件上实现方便 , 诸如 byte 和 short这种低于 4 个字节的类型 , 会先提升成 int, 再参与计算
正确的写法
:
byte c = (byte)(a + b);5. 字符串类型
String s1 = "hello";
String s2 = " world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
（1）int
转成
String
int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);（2）String 转成 int
String str = "100";
int num = Integer.parseInt(str);三、运算符
1. 基本四则运算符和取模运算
//int / int 结果还是int类型，而且会向下取整
int a = 3;
int b = 2;
// 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
System.out.println(a / b);
// 如果要得到数学中的结果，可以使用如下方式
double d = a*1.0 / b;
System.out.println(d);
//两侧操作数类型不一致时，向类型大的提升
System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double,故输出1.2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数2. 增量运算符 += -= *= %=
int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a %= 3; // 相当于 a = a % 3
System.out.println(a); // 输出1
//其余同理3. 自增/自减运算符 ++ --
++
是给变量的值
+1
，
--
是给变量的值
-1
int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似【注意】
如果单独使用，【前置++】和【后置++】没有任何区别如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改
4. 关系运算符
关系运算符主要有六个
:
== != < > <= >=
，其计算结果是
true
或者
false
。
int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false
【注意】当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的
5. 逻辑运算符(重点)
逻辑运算符主要有三个
:
&& || ! ，运算结果都是
boolean
类型。
（1）
逻辑与
&&
语法规则：表达式
1 &&
表达式
2
，左右表达式必须是
boolean
类型的结果。
当两个表达式都为真时，结果为真，其余为假。
int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
（2）逻辑
||
语法规则：表达式
1 ||
表达式
2
，左右表达式必须是
boolean
类型的结果。
当两个表达式都为假时，结果为假，其余为真。
int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假
（3）逻辑非
!
语法规则：
!
表达式
真变假，假变真。
int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
（4）
短路求值
&&
和
||
遵守短路求值的规则
.
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
我们都知道
,
计算
10 / 0
会导致程序抛出异常
.
但是上面的代码却能正常运行
,
说明
10 / 0
并没有真正被求值
.
【注意】对于 && , 如果 左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式 .对于 ||, 如果 左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式 .& 和 | 如果表达式结果为 boolean 时 , 也表示逻辑运算 . 但与 && || 相比 , 它们不支持短路求值 .
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常6. 位运算符
位运算符主要有四个 : & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。位操作表示 按二进制位运算 . 计算机中都是使用二进制来表示数据的 (01 构成的序列 ), 按位运算就是在按照二进制位的每一位依次进行计算.
（1） 按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.
int a = 10;
int b = 20;
System.out.println(a & b);进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100
（2）按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.
int a = 10;
int b = 20;
System.out.println(a | b);
注意
:
当
&
和
|
的操作数为整数
(int, short, long, byte)
的时候
,
表示按位运算
,
当操作数为
boolean
的时候
,
表示逻辑运算.
（3）按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
int a = 0xf;
System.out.printf("%x\n", ~a)【注意】0x 前缀的数字为 十六进制 数字 ， 十六进制可以看成是二进制的简化表示方式 。 一个十六进制数字对应 4 个二进制位.。0xf 表示 10 进制的 15, 也就是二进制的 1111，printf 能够格式化输出内容， %x 表示按照十六进制输出 .，\n 表示换行符。
（4） 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.
int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);
注意：如果两个数相同，则异或的结果为
0
7. 条件运算符（三目运算符）
表达式 1 ? 表达式 2 : 表达式 3当 表达式 1 的值为 true 时 , 整个表达式的值为 表达式 2 的值 ;当 表达式 1 的值为 false 时 , 整个表达式的值为 表达式 3 的值 .
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
【注意】
（1）
表达式
2
和表达式
3
的结果要是同类型的，除非能发生类型隐式类型转换
int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;（2）表达式不能单独存在，其产生的结果必须要被使用
int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句
924
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
