Java 简介：Java 是一种面向对象的编程语言，具有跨平台性和可移植性，Java 是一种面向对象的语言，支持封装、继承和多态等特性。简单易学：Java 的语法相对简单，容易上手，适合初学者学习
1. 开发环境搭建
- 包括安装 JDK（Java Development Kit）和设置开发环境变量。可以提供参考：
好的，以下是更详细的 Java 开发环境搭建步骤，包括安装 JDK 和设置环境变量：
Windows：
-
下载 JDK：
- 访问 Oracle 官方网站或其他可信的下载源。
- 根据你的操作系统选择合适的 JDK 版本进行下载。
-
安装 JDK：
- 运行下载的安装程序。
- 按照安装向导的指示进行操作，选择安装目录。
-
设置环境变量：
- 右键点击“我的电脑”，选择“属性”。
- 在弹出的系统属性窗口中，点击“高级系统设置”。
- 在高级选项卡中，点击“环境变量”按钮。
- 在系统变量部分，找到“Path”变量，并点击“编辑”按钮。
- 在变量值的末尾添加 JDK 的安装路径，例如“;C:\Program Files\Java\jdk1.8.0_XXX\bin”（注意根据实际安装路径进行调整）。
- 点击“确定”保存设置。
-
验证安装：
- 打开命令提示符窗口。
- 输入“java -version”命令，如果显示 Java 版本信息，则说明安装成功。
Linux（以 Ubuntu 为例）：
JDK下载网址：https://www.oracle.com/cn/
Eclipse下载网址:https://www.eclipse.org/downloads
- 安装 JDK：
- 打开终端。
- 输入以下命令安装 JDK：
sudo apt-get update
sudo apt-get install default-jdk
- 设置环境变量（可选）：
-
如果你希望在任何位置都能直接运行 Java 命令，可以设置环境变量。
-
打开终端，输入以下命令：
sudo vi /etc/environment -
在文件中添加以下行：
JAVA_HOME=/usr/lib/jvm/default-java PATH="$JAVA_HOME/bin:$PATH"
-
- 保存并关闭文件。
-
验证安装：
- 输入“java -version”命令，如果显示 Java 版本信息，则说明安装成功。
视频教学链接： link
2. 基本语法
- 数据类型：包括整型、浮点型、字符型、布尔型等。
在 Java 中，数据类型主要分为两类：基本数据类型和引用数据类型。
基本数据类型：
byte：字节类型，占 8 位，取值范围是 -128 到 127。例如：byte num = 10;short：短整型，占 16 位，取值范围是 -32768 到 32767。例如：short age = 25;int：整型，占 32 位，取值范围是 -2147483648 到 2147483647。这是最常用的整数类型，比如：int count = 100;long：长整型，占 64 位，取值范围极大。例如：long bigNumber = 10000000000L;注意后面要加上L表示长整型。float：单精度浮点型，占 32 位。例如：float price = 9.99F;需加上F。double：双精度浮点型，占 64 位，精度更高。比如：double salary = 5000.5;char：字符型，占 16 位，用来表示单个字符。例如：char letter = 'A';boolean：布尔型，只有两个值，true和false。常用于条件判断，如：boolean isTrue = true;
引用数据类型：
-
类（class）：自定义的类类型。
-
接口（interface）。
-
数组（array）：例如
int[] arr = {1, 2, 3}; -
字符串（String）：例如
String str = "Hello"; -
变量和常量：声明和使用变量，以及定义常量。
变量：
变量是在程序运行期间其值可以改变的量。它具有以下特点：
- 必须先声明后使用。声明变量时需要指定其数据类型和名称。例如：
int num; - 可以在声明时进行初始化，也可以在后续的代码中进行赋值。如：
int num = 10;或者在其他位置num = 20; - 变量的作用域决定了它在程序中的可见范围。
变量根据其作用域可以分为：
- 局部变量：在方法、代码块等内部声明的变量，作用域仅限于声明它的代码块内。
- 成员变量：在类中但在方法外声明的变量。
- 静态变量：使用
static关键字修饰的成员变量。
常量：
常量是在程序运行期间其值不能被改变的量。在 Java 中，通常使用
final关键字来定义常量
例如：final int CONSTANT_NUMBER = 50; 一旦常量被初始化，就不能再对其进行重新赋值。
常量通常用于表示一些固定不变的值，比如数学常量（如圆周率）、配置参数等。这样可以增加代码的可读性和可维护性。
举个例子，如果要计算圆的面积，我们可以定义圆周率为常量：
final double PI = 3.14159;
double radius = 5.0;
double area = PI * radius * radius;
在这个例子中，PI 就是一个常量，其值在整个程序中始终保持不变。
- 运算符：算术运算符、关系运算符、逻辑运算符等
算术运算符：
+：加法运算，例如5 + 3的结果是8。-：减法运算，如5 - 3结果为2。*：乘法运算，比如5 * 3等于15。/：除法运算，需注意整数相除结果为整数，例如5 / 2结果是2。如果要得到精确的小数结果，至少有一个操作数应为浮点数，如5.0 / 2结果是2.5。%：取模（取余）运算，计算除法的余数，如5 % 3结果是2。
关系运算符：
==：判断两个操作数是否相等，返回boolean类型的值。!=：判断两个操作数是否不相等。<：小于。>：大于。<=：小于等于。>=：大于等于。
逻辑运算符：
&&：逻辑与，当两个操作数都为true时，结果为true，否则为false。||：逻辑或，只要两个操作数中有一个为true，结果为true，只有两个都为false时结果才为false。!：逻辑非，对操作数取反，如果操作数为true，则结果为false；反之亦然。
赋值运算符：
=：简单的赋值运算符，将右侧的值赋给左侧的变量。- 复合赋值运算符，如
+=、-=、*=、/=、%=等，先进行相应的运算再赋值。
例如，以下代码展示了一些运算符的使用：
int a = 5;
int b = 3;
int sum = a + b; // 加法运算
int diff = a - b; // 减法运算
boolean isEqual = (a == b); // 关系运算
int c = 10;
c += 5; // 复合赋值运算，c 的值变为 15
- 控制语句：if-else 语句、for 循环、while 循环等。
条件语句：
if语句：用于根据条件执行不同的代码块。int num = 10; if (num > 5) { System.out.println("Number is greater than 5"); }
if-else语句：在if条件不满足时执行else中的代码块。int score = 75; if (score >= 60) { System.out.println("Pass"); } else { System.out.println("Fail"); }
循环语句：
for循环：用于重复执行一段代码指定的次数。for (int i = 0; i < 5; i++) { System.out.println(i); }while循环：只要条件为真，就一直执行循环体。int count = 0; while (count < 3) { System.out.println(count); count++; }
跳转语句：
break语句：用于终止循环或switch语句。for (int i = 0; i < 10; i++) { if (i == 5) { break; } System.out.println(i); }continue语句：用于跳过当前循环的本次迭代，直接进入下一次迭代。for (int i = 0; i < 10; i++) { if (i % 2 == 0) { continue; } System.out.println(i); }
这些控制语句使得 Java 程序能够根据不同的条件和需求，灵活地控制代码的执行顺序和次数，实现各种复杂的逻辑功能。
- 数组：创建和使用数组。
在 Java 中，创建和使用数组是一项基础且重要的操作。
创建数组：
- 先声明数组变量，然后使用
new关键字创建数组并指定长度：
int[] array;
array = new int[5]; // 创建一个长度为 5 的整数数组
- 在声明数组变量时直接创建并初始化数组：
int[] array = {10, 20, 30, 40, 50};
使用数组：
- 访问数组元素：通过索引来访问数组中的元素，索引从 0 开始。例如：
int[] arr = {1, 2, 3};
System.out.println(arr[1]); // 输出 2
- 为数组元素赋值：
int[] arr = new int[3];
arr[0] = 5;
arr[1] = 10;
arr[2] = 15;
- 遍历数组：
- 使用
for循环：
int[] arr = {1, 2, 3}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }- 使用增强型
for循环（for-each循环）：
int[] arr = {1, 2, 3}; for (int num : arr) { System.out.println(num); } - 使用
下面是一个完整的示例代码，展示了数组的创建和使用：
public class ArrayCreationAndUsage {
public static void main(String[] args) {
// 创建并初始化一个整数数组
int[] numbers = {10, 20, 30, 40, 50};
// 访问并打印数组的特定元素
System.out.println("第二个元素: " + numbers[1]);
// 修改数组的元素
numbers[3] = 45;
// 遍历数组并打印所有元素
System.out.println("数组的所有元素:");
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + " ");
}
System.out.println();
// 使用增强型 for 循环遍历数组
System.out.println("使用增强型 for 循环:");
for (int num : numbers) {
System.out.print(num + " ");
}
}
}
代码运行结果：
3.面向对象编程
- 类和对象：定义类，创建对象，访问对象的属性和方法。
在 Java 中，类是对象的模板，对象是类的实例。
定义类：
public class Student {
// 成员变量（属性）
String name;
int age;
// 成员方法
public void study() {
System.out.println(name + " is studying.");
}
}
创建对象：
public class Main {
public static void main(String[] args) {
// 创建 Student 类的对象
Student student1 = new Student();
}
}
访问对象的属性和方法：
public class Main {
public static void main(String[] args) {
Student student1 = new Student();
// 为对象的属性赋值
student1.name = "Alice";
student1.age = 20;
// 调用对象的方法
student1.study();
// 访问对象的属性
System.out.println(student1.name + " is " + student1.age + " years old.");
}
}
以下是一个更完整的示例，包含多个对象和方法的使用：
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void showInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
public void celebrateBirthday() {
age++;
System.out.println(name + " had a birthday and is now " + age + " years old.");
}
}
public class Main {
public static void main(String[] args) {
Student student1 = new Student("Alice", 20);
Student student2 = new Student("Bob", 22);
student1.showInfo();
student2.showInfo();
student1.celebrateBirthday();
student2.celebrateBirthday();
student1.showInfo();
student2.showInfo();
}
}
通过类的定义、对象的创建以及对对象属性和方法的操作，我们可以实现面向对象编程中的各种功能，使代码更具组织性、可维护性和复用性。
- 封装、继承和多态：理解面向对象编程的三大特性。
封装是将数据（属性）和操作这些数据的方法（行为）包装在一个类中，并对类的成员变量进行访问控制，限制外部直接访问和修改。通过使用 private 关键字来修饰成员变量，然后提供 public 的 getter 和 setter 方法来获取和设置变量的值。
例如：
public class BankAccount {
private double balance;
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
封装的好处包括：
- 保护数据的完整性和一致性。
- 隐藏实现细节，只暴露必要的接口。
继承（Inheritance）：
继承允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展和特化父类的功能。
例如：
class Animal {
public void eat() {
System.out.println("Animal is eating.");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Dog is barking.");
}
}
继承的优点：
- 代码复用，减少重复代码的编写。
- 建立类之间的层次关系，使代码更具条理。
多态（Polymorphism）：
多态是指同一个行为具有多种不同的表现形式。主要有两种实现方式：方法重载和方法重写。
方法重载（Overloading）是在同一个类中，定义多个同名但参数不同的方法。
例如：
class Calculator {
public int add(int num1, int num2) {
return num1 + num2;
}
public double add(double num1, double num2) {
return num1 + num2;
}
}
方法重写（Overriding）是子类重写父类的方法，实现不同的功能。
例如：
class Vehicle {
public void move() {
System.out.println("Vehicle is moving.");
}
}
class Car extends Vehicle {
@Override
public void move() {
System.out.println("Car is driving.");
}
}
多态的好处：
-
增强了代码的灵活性和可扩展性。
-
使程序更易于维护和扩展。
- 接口和抽象类：定义接口和抽象类，实现接口和继承抽象类。
抽象类是使用 abstract 关键字修饰的类，它可以包含抽象方法和非抽象方法。抽象方法只有方法声明，没有方法体，其目的是为子类提供一个必须实现的方法规范。
以下是一个更综合的示例，展示了抽象类和接口的使用：
abstract class Vehicle {
public abstract void start();
public void stop() {
System.out.println("The vehicle is stopping.");
}
}
interface Movable {
void move();
}
class Car extends Vehicle implements Movable {
@Override
public void start() {
System.out.println("The car is starting.");
}
@Override
public void move() {
System.out.println("The car is moving.");
}
}
4.异常处理
- 检查型异常（Checked Exception）：在编译时被强制要求处理，如
IOException、SQLException等。 - 非检查型异常（Unchecked Exception）：又称运行时异常，编译时不强制处理，如
NullPointerException、ArrayIndexOutOfBoundsException等。
捕获异常：使用 try-catch 语句来捕获并处理异常。
try {
// 可能抛出异常的代码
int result = 10 / 0;
} catch (ArithmeticException e) {
// 处理异常的代码
System.out.println("除数不能为 0");
}
多 catch 块：可以捕获不同类型的异常并分别处理。
try {
// 可能抛出异常的代码
} catch (ArithmeticException e) {
// 处理算术异常
} catch (NullPointerException e) {
// 处理空指针异常
}
捕获多个异常：
try {
// 可能抛出异常的代码
} catch (ArithmeticException | NullPointerException e) {
// 处理这两种异常
}
自定义异常：创建自己的异常类，继承 Exception 或 RuntimeException 。
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
以下是一个完整的示例，展示了异常处理的各种情况：
public class ExceptionHandlingExample {
public static void main(String[] args) {
try {
divideNumbers(10, 0);
} catch (ArithmeticException e) {
System.out.println("除数不能为 0");
}
try {
accessNullReference();
} catch (NullPointerException e) {
System.out.println("出现空指针异常");
}
try {
throwCustomException();
} catch (CustomException e) {
System.out.println(e.getMessage());
}
}
public static int divideNumbers(int num1, int num2) {
return num1 / num2;
}
public static void accessNullReference() {
String str = null;
str.length();
}
public static void throwCustomException() throws CustomException {
throw new CustomException("这是一个自定义的异常");
}
}
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
5.常用类库
Java 提供了丰富的类库，以下是一些常用的类库：
java.lang 包：
Object类：所有类的父类。String类：用于处理字符串操作。Integer、Double等包装类：将基本数据类型封装为对象。
java.util 包：
ArrayList、LinkedList：动态数组和链表实现的集合类。HashMap、HashSet：基于哈希表的映射和集合。Stack、Queue：栈和队列数据结构的实现。Date、Calendar：处理日期和时间。
java.io 包：
File类：用于操作文件和目录。InputStream、OutputStream：字节输入输出流。Reader、Writer：字符输入输出流。
java.net 包：
Socket：用于网络套接字编程。URL：用于处理网络资源的地址。
java.text 包：
用于格式化和解析文本，如日期、数字等。
例如，使用 ArrayList 存储整数：
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
for (Integer num : numbers) {
System.out.println(num);
}
}
}
使用 File 类读取文件：
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class FileReadingExample {
public static void main(String[] args) {
File file = new File("your_file.txt");
try (Scanner scanner = new Scanner(file)) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
System.out.println(line);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
总的来说，Java 以其强大的功能、良好的可移植性和广泛的应用场景，成为了众多开发者的首选编程语言之一。无论是开发 Web 应用、移动应用还是企业级系统，Java 都展现出了卓越的性能和稳定性。
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
