目录
Java 简介
Java是一种跨平台、面向对象的编程语言，因其易学、易用、可靠、安全等特点，成为了世界上最流行的编程语言之一。在Java编程中，基础知识是必须掌握的，本篇博客将介绍Java基础知识，包括数据类型、运算符、流程控制、类、对象、继承、多态、接口、异常处理等。
一、数据类型
Java中的数据类型分为基本数据类型和引用数据类型。基本数据类型包括byte、short、int、long、float、double、char、boolean，引用数据类型包括类、接口、数组等。
1. 基本数据类型
- byte：表示8位有符号整数，取值范围为-128~127。
- short：表示16位有符号整数，取值范围为-32768~32767。
- int：表示32位有符号整数，取值范围为-2^31~2^31-1。
- long：表示64位有符号整数，取值范围为-2^63~2^63-1。
- float：表示32位单精度浮点数，取值范围为1.4E-45~3.4E38。
- double：表示64位双精度浮点数，取值范围为4.9E-324~1.8E308。
- char：表示16位Unicode字符，取值范围为'\u0000'~'\uffff'。
- boolean：表示布尔值，取值为true或false。
2. 引用数据类型
- 类：是Java中最基本的数据类型，用于描述一类对象的属性和行为。
- 接口：是一种特殊的类，只包含常量和抽象方法，用于描述一种行为规范。
- 数组：是一种容器，用于存储同一类型的多个数据。
二、运算符
Java中的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、三目运算符等。
1. 算术运算符
算术运算符包括加、减、乘、除、取模等。
int a = 10;
int b = 3;
int c = a + b; // 加法运算，c的值为13
int d = a - b; // 减法运算，d的值为7
int e = a * b; // 乘法运算，e的值为30
int f = a / b; // 除法运算，f的值为3
int g = a % b; // 取模运算，g的值为1
2. 关系运算符
关系运算符包括等于、不等于、大于、小于、大于等于、小于等于等。
int a = 10;
int b = 3;
boolean c = a == b; // 等于运算，c的值为false
boolean d = a != b; // 不等于运算，d的值为true
boolean e = a > b; // 大于运算，e的值为true
boolean f = a < b; // 小于运算，f的值为false
boolean g = a >= b; // 大于等于运算，g的值为true
boolean h = a <= b; // 小于等于运算，h的值为false
3. 逻辑运算符
逻辑运算符包括与、或、非等。
boolean a = true;
boolean b = false;
boolean c = a && b; // 与运算，c的值为false
boolean d = a || b; // 或运算，d的值为true
boolean e = !a; // 非运算，e的值为false
4. 位运算符
位运算符包括按位与、按位或、按位异或、按位取反等。
int a = 10;
int b = 3;
int c = a & b; // 按位与运算，c的值为2
int d = a | b; // 按位或运算，d的值为11
int e = a ^ b; // 按位异或运算，e的值为9
int f = ~a; // 按位取反运算，f的值为-11
5. 赋值运算符
赋值运算符包括等于、加等、减等、乘等、除等、取模等。
int a = 10;
a += 5; // 加等于运算，a的值为15
a -= 5; // 减等于运算，a的值为10
a *= 5; // 乘等于运算，a的值为50
a /= 5; // 除等于运算，a的值为10
a %= 3; // 取模等于运算，a的值为1
6. 三目运算符
三目运算符是Java中唯一的三元运算符，格式为：条件?结果1:结果2。
int a = 10;
int b = 3;
int c = a > b ? a : b; // 如果a>b，c的值为a，否则c的值为b
三、流程控制
Java中的流程控制包括分支语句和循环语句。
1. 分支语句
分支语句包括if语句和switch语句。
1.1、if语句的格式为：
if (条件) { // 条件成立时执行的代码 } else { // 条件不成立时执行的代码 }
public class Test {
public static int max(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
public static void main(String[] args) {
int max = Test.max(10, 6);
System.out.println(max);
}
}
// 输出：10
1.2、switch语句的格式为：
switch (表达式) { case 值1: // 表达式等于值1时执行的代码 break; case 值2: // 表达式等于值2时执行的代码 break; default: // 表达式不等于任何一个值时执行的代码 break; }
public class Test {
public static String match(int code) {
switch (code){
case 1:
return "dog";
case 2:
return "cat";
default:
return "none";
}
}
public static void main(String[] args) {
String name = Test.match(1);
System.out.println(name);
}
}
// 输出：dog
2. 循环语句
循环语句包括for循环、while循环和do-while循环。
2.1、for循环的格式为：
for (初始化语句; 循环条件; 循环后操作) { // 循环体 }
for (int i = 0; i < 10; i++) {
// 输出
System.out.println(i);
}
2.2、while循环的格式为：
while (循环条件) { // 循环体 }
int a = 2;
while (a >= 0) {
a--;
System.out.println(a);
}
// 输出：1、 0、 -1
2.3、do-while循环的格式为：
do { // 循环体 } while (循环条件);
int a = 2;
do {
a--;
System.out.println(a);
} while (a >= 0);
// 输出：1、 0、 -1
在循环中可以使用break语句和continue语句来控制循环的执行流程。
2.4、break语句用于跳出循环，格式为：
break;
int a = 2;
while (a >= 0) {
a--;
System.out.println(a);
if (a < 1) {
break;
}
}
// 输出：1、0
2.5、continue语句用于跳过本次循环，进入下一次循环，格式为：
continue;
int a = 2;
while (a >= 0) {
a--;
System.out.println(a);
if (a < 1) {
continue;
}
}
// 输出：1、0、-1
四、异常处理
Java中的异常处理包括try-catch语句和throw语句。
1、try-catch语句的格式为：
try { // 可能会出现异常的代码 } catch (异常类型1 异常变量1) { // 处理异常1的代码 } catch (异常类型2 异常变量2) { // 处理异常2的代码 } finally { // 无论是否出现异常都会执行的代码 }
2、throw语句用于手动抛出异常，格式为：
throw new 异常类型("异常信息");
3、常见问题：try和finally的返回值是谁
（1）问题：你会不会遇到这种困惑，当try中执行return，finally还执行吗？
答案是在try中执行return，finally也会执行。这是因为无论try块中的代码是否执行成功，finally块中的代码都会被执行。
下面是一段示例代码：
public class Test {
public static void main(String[] args) {
System.out.println(test()); // 输出3
}
public static int test() {
try {
return 1;
} catch (Exception e) {
return 2;
} finally {
return 3;
}
}
}
在上面的示例代码中，我们定义了一个test()方法，在try块中返回1，在catch块中返回2，在finally块中返回3。在main()方法中调用test()方法并输出结果。
由于finally块中的代码一定会被执行，所以无论try块中的代码是否执行成功，最终都会返回3。因此，输出结果为3。
++需要注意的是，如果在try块中执行了return语句，那么该方法的返回值就已经确定了，不会再执行catch块中的代码和finally块中的代码。如果在finally块中也执行了return语句，那么它的返回值会覆盖try块中的返回值++。下面是一个示例代码：
public class Test {
public static void main(String[] args) {
System.out.println(test()); // 输出2
}
public static int test() {
try {
return 1;
} catch (Exception e) {
return 2;
} finally {
return 3;
}
}
}
在上面的示例代码中，我们在finally块中也执行了return语句，返回值为3。因此，最终的返回值为3，而不是try块中的返回值1或catch块中的返回值2。
（2）问题：那么在finally中抛出异常，又会是什么场景呢？ 如果finally块中抛出异常，try块中的返回值将被覆盖，因此try块中的返回值将无法正常返回。
下面是一个示例代码：
public class Test {
public static void main(String[] args) {
System.out.println(test()); // 抛出异常
}
public static int test() {
try {
return 1;
} catch (Exception e) {
return 2;
} finally {
int i = 1 / 0; // finally块中抛出异常
return 3;
}
}
}
在上面的示例代码中，我们在finally块中故意抛出了一个异常。在main()方法中调用test()方法并输出结果。
由于finally块中的代码一定会被执行，因此它会覆盖try块中的返回值。在finally块中抛出异常后，try块中的返回值将被覆盖，抛出异常。
五、面向对象编程
Java是一种面向对象的编程语言，面向对象编程的核心是类和对象。
1. 类
类是一种数据类型，用于描述一类对象的属性和行为。类由属性和方法组成，属性用于描述对象的状态，方法用于描述对象的行为。
定义类的语法为：
修饰符 class 类名 { // 属性 // 方法 }
2. 对象
对象是类的实例，是具体的实体。对象由类创建，每个对象都有自己的属性和方法。
创建对象的语法为：
类名 对象名 = new 类名();
3. 封装、继承和多态
Java面向对象编程中的三大特性是封装、继承和多态。这三个特性是面向对象编程的基石，也是Java语言的核心特性之一。
3.1. 封装
封装是指将对象的状态信息和行为细节隐藏起来，只向外界提供公共的访问接口。在Java中，封装的实现方式是通过类的访问修饰符来控制类的成员变量和方法的访问范围。
示例代码：
public class Person {
private String name; // 私有成员变量
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 公共方法，提供访问私有成员变量的接口
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
在上面的示例代码中，我们将Person类的成员变量name和age设置为私有的，这样外部的代码就不能直接访问这些成员变量，只能通过公共的方法getName()和getAge()来获取这些信息。同时，我们还提供了公共的方法setName()和setAge()，用于修改私有成员变量的值。
3.2. 继承
继承是指一个类可以派生出子类，子类继承了父类的属性和方法，同时还可以添加自己的属性和方法。通过继承，可以实现代码的复用和扩展。
示例代码：
public class Animal {
private String name;
private int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println("Animal is eating");
}
}
public class Dog extends Animal {
private String breed;
public Dog(String name, int age, String breed) {
super(name, age);
this.breed = breed;
}
public void bark() {
System.out.println("Dog is barking");
}
}
在上面的示例代码中，我们定义了一个Animal类，其中包含了两个成员变量name和age，以及一个公共方法eat()。然后我们定义了一个Dog类，它继承了Animal类，并添加了一个自己的成员变量breed和方法bark()。通过继承，Dog类可以使用Animal类中的成员变量和方法，同时还可以添加自己的属性和方法。
3.3. 多态
多态是指同一个方法可以在不同的对象上产生不同的行为。在Java中，多态的实现方式是通过方法的重载和重写来实现的。
示例代码：
public class Animal {
public void makeSound() {
System.out.println("Animal is making sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog is barking");
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat is meowing");
}
}
在上面的示例代码中，我们定义了一个Animal类，其中包含了一个公共方法makeSound()。然后我们定义了一个Dog类和一个Cat类，它们都继承了Animal类，并重写了makeSound()方法。当我们调用makeSound()方法时，它会根据实际调用的对象来产生不同的行为，这就是多态的体现。
六、常用的Java类库
Java类库是Java提供的一组常用的类和接口，包括Java SE类库、Java EE类库和Java ME类库。
常用的Java类库包括：
- java.lang：包含Java语言基本类，如Object、String、Math等。
- java.util：包含各种实用工具类，如集合类、日期类、随机数类等。
- java.io：包含输入输出相关的类，如文件读写类、网络通信类等。
- java.net：包含网络编程相关的类，如Socket类、URL类等。
- java.sql：包含数据库编程相关的类，如Connection类、Statement类等。
七、开发工具
Java开发工具包括集成开发环境（IDE）和文本编辑器。
常用的Java开发工具包括：
- Eclipse：一个Java开发IDE，支持多种编程语言。
- IntelliJ IDEA：一个Java开发IDE，具有强大的代码分析和重构功能。
- NetBeans：一个Java开发IDE，支持多种编程语言。
- Visual Studio Code：一个轻量级的文本编辑器，支持多种编程语言，可通过插件扩展功能。
- Sublime Text：一个轻量级的文本编辑器，支持多种编程语言，可通过插件扩展功能。
