# JAVA学习

最新推荐文章于 2025-02-11 18:02:07 发布

Jeff-Jiang

最新推荐文章于 2025-02-11 18:02:07 发布

阅读量1k

点赞数 24

文章标签： java 学习开发语言

本文链接：https://blog.youkuaiyun.com/luoma0/article/details/143676003

版权

JAVA

JAVA是什么？

定义

Java 是一种广泛使用的面向对象的编程语言，由 Sun Microsystems 在 1995 年发布，后来被 Oracle Corporation 收购。

特点

平台无关性：编写一次，到处运行（Write Once, Run Anywhere）。Java 程序可以在任何支持 Java 的平台上运行，无需重新编译。
面向对象：支持封装、继承和多态等面向对象编程的基本特性。
安全性：内置安全机制，如沙箱环境，防止恶意代码的执行。
健壮性：强制类型检查，自动垃圾回收，减少程序错误。
多线程：支持并发处理，提高程序效率。

应用领域

Web 应用开发
移动应用开发（Android）
桌面应用开发
企业级应用开发
游戏开发
大数据技术

开发工具：常用的 Java 开发工具有 Eclipse、IntelliJ IDEA 和 NetBeans 等。

JAVA能做什么？

Java 作为一种功能强大的编程语言，可以应用于多个领域和场景：

Web 应用开发

使用 Java Servlet、JSP（JavaServer Pages）、Spring Boot 等技术开发动态网站和后端服务。

移动应用开发

主要用于 Android 应用开发，Android 操作系统本身就是基于 Java 构建的。

桌面应用开发

使用 Swing 或 JavaFX 等图形用户界面库开发跨平台的桌面应用程序。

企业级应用开发

通过 Java EE（现称为 Jakarta EE）框架开发大型企业级应用，如银行系统、电子商务平台等。

游戏开发

使用 LibGDX 等框架开发 2D 和 3D 游戏。

大数据技术

Hadoop、Spark 等大数据处理框架主要使用 Java 编写，适用于大规模数据处理和分析。

云计算

开发和管理云服务，如 AWS SDK for Java、Google Cloud Java 客户端库等。

物联网 (IoT)

用于开发嵌入式系统和 IoT 设备的控制软件。

科学计算和工程应用

用于复杂的数学计算、物理模拟等科学计算任务。

金融应用

开发交易系统、风险管理软件等金融领域的应用。

教育和培训

作为教学语言，帮助学生学习编程基础和面向对象的概念。

Java 的广泛适用性和强大的生态系统使其成为许多开发者和企业的首选编程语言。

JAVA能给我带来什么好处？

1. 广泛的就业机会

需求量大：Java 是企业级应用开发中最常用的语言之一，市场需求量大。
多样化职位：可以从 Web 开发、移动应用开发、大数据处理等多个方向发展。

2. 跨平台能力

一次编写，到处运行：Java 程序可以在任何支持 Java 的平台上运行，无需重新编译，大大提高了开发效率。

3. 强大的社区支持

丰富的资源：大量的开源库、框架和工具，如 Spring、Hibernate、Maven 等，可以加速开发过程。
活跃的社区：遇到问题时，可以轻松找到解决方案和最佳实践。

4. 面向对象的编程范式

代码复用：通过类和对象的封装、继承和多态，可以提高代码的复用性和可维护性。
模块化开发：便于团队协作和项目管理。

5. 安全性

内置安全机制：Java 提供了多种安全机制，如沙箱环境、字节码验证等，可以有效防止恶意代码的执行。

6. 健壮性

强制类型检查：编译时进行严格的类型检查，减少运行时错误。
自动垃圾回收：自动管理内存，减少内存泄漏的风险。

7. 多线程支持

并发处理：Java 内置了多线程支持，可以开发高效的并发应用程序，提高性能。

8. 企业级应用开发

成熟的技术栈：Java EE（现为 Jakarta EE）提供了丰富的企业级应用开发框架，适合开发大型、复杂的系统。

9. 持续更新和发展

定期更新：Oracle 不断发布新版本，引入新的特性和改进，保持语言的竞争力。
向后兼容：新版本通常保持与旧版本的兼容性，保护现有投资。

10. 学习资源丰富

教程和文档：大量的在线教程、书籍和官方文档，适合初学者和进阶开发者。
培训课程：许多培训机构和在线平台提供 Java 培训课程，帮助快速上手。
通过学习和使用 Java，你不仅可以提升自己的编程技能，还能在职业生涯中获得更多的机会和发展空间。

JAVA如何使用？

使用 Java 进行开发涉及多个步骤，从安装 JDK 到编写、编译和运行代码。以下是一个详细的指南：

1. 安装 JDK

下载 JDK：
访问 Oracle 官方网站或 OpenJDK 下载最新版本的 JDK。
安装 JDK：
根据操作系统的不同，选择合适的安装包并按照提示进行安装。
配置环境变量 JAVA_HOME 和 PATH：

Windows：

set JAVA_HOME=C:\Program Files\Java\jdk-17
set PATH=%JAVA_HOME%\bin;%PATH%
Linux/Mac：

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk
export PATH=$JAVA_HOME/bin:$PATH

2. 验证安装

打开命令行或终端，输入以下命令验证 JDK 是否安装成功：

java -version
javac -version

3. 编写 Java 程序

创建一个简单的 Java 文件，例如 HelloWorld.java：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

4. 编译 Java 程序

打开命令行或终端，导航到包含 HelloWorld.java 的目录，然后运行以下命令编译程序：

javac HelloWorld.java
成功编译后，会生成一个 HelloWorld.class 文件。

5. 运行 Java 程序

在命令行或终端中运行编译后的程序：

java HelloWorld
输出应为：
Hello, World!

6. 使用集成开发环境 (IDE)

Eclipse：
下载并安装 Eclipse
创建一个新的 Java 项目，编写和运行代码。
IntelliJ IDEA：
下载并安装 IntelliJ IDEA
创建一个新的 Java 项目，编写和运行代码。
NetBeans：
下载并安装 NetBeans
创建一个新的 Java 项目，编写和运行代码。

7. 学习和参考

官方文档：
访问 Oracle Java 文档获取详细的 API 文档和教程。
在线教程：
参考 Java 教程、Java 入门等在线资源。
书籍：
推荐《Head First Java》、《Effective Java》等经典书籍。

8. 实践项目

小项目：
从简单的项目开始，如计算器、待办事项列表等。
参与开源项目：
加入 GitHub 上的开源项目，贡献代码，提升实战经验。

9.JAVA常用内容

1.Java 基础

1.1 基本语法

注释

单行注释：

// 这是一个单行注释

多行注释：

/*
这是一个
多行注释
*/

文档注释：

/**
 * 这是一个文档注释
 * @param param1 参数1
 * @return 返回值
 */

数据类型

基本数据类型：
- 整数类型：byte, short, int, long
- 浮点类型：float, double
- 字符类型：char
- 布尔类型：boolean
引用数据类型：
- 类：String, ArrayList, HashMap 等
- 数组：int[], String[] 等

变量声明和初始化

声明变量：

int age;
double salary;
String name;

初始化变量：

int age = 25;
double salary = 5000.0;
String name = "John Doe";

1.2 控制结构

条件语句
if 语句：

if (age > 18) {
    System.out.println("成年");
} else {
    System.out.println("未成年");
}

switch 语句：

switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Invalid day");
}

循环语句

for 循环：

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

while 循环：

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

do-while 循环：

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

1.3 方法

方法声明：

public void greet(String name) {
    System.out.println("Hello, " + name);
}

带返回值的方法：

public int add(int a, int b) {
    return a + b;
}

1.4 类和对象

类的定义：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

创建对象：

Person person = new Person("Alice", 30);
person.introduce();

1.5 继承和多态

继承：

public class Student extends Person {
    private String studentId;

    public Student(String name, int age, String studentId) {
        super(name, age);
        this.studentId = studentId;
    }

    public void study() {
        System.out.println("Studying...");
    }
}

多态：

Person person = new Student("Bob", 20, "12345");
person.introduce(); // 调用的是 Student 类中的 introduce 方法

1.6 异常处理

try-catch 语句：

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("除零错误: " + e.getMessage());
} finally {
    System.out.println("finally 块总是会被执行");
}

1.7 输入输出

标准输入输出：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入您的名字: ");
        String name = scanner.nextLine();
        System.out.println("你好, " + name);
    }
}

1.8 数组

一维数组：

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println(number);
}

二维数组：

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
for (int[] row : matrix) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

1.9 字符串

字符串操作：

String str = "Hello, World!";
System.out.println(str.length()); // 13
System.out.println(str.toUpperCase()); // HELLO, WORLD!
System.out.println(str.contains("World")); // true

1.10 集合

List：

import java.util.ArrayList;
import java.util.List;

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
for (String fruit : list) {
    System.out.println(fruit);
}

Set：

import java.util.HashSet;
import java.util.Set;

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
for (String fruit : set) {
    System.out.println(fruit);
}

Map：

import java.util.HashMap;
import java.util.Map;

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

2.常用类和接口

2.1 基本数据类型的包装类

Integer：

包装 int 类型。
常用方法：parseInt(), valueOf(), toString()

int num = Integer.parseInt("123");
Integer obj = Integer.valueOf(123);
String str = Integer.toString(123);

Double：

包装 double 类型。
常用方法：parseDouble(), valueOf(), toString()

double d = Double.parseDouble("123.45");
Double obj = Double.valueOf(123.45);
String str = Double.toString(123.45);

Boolean：

包装 boolean 类型。
常用方法：parseBoolean(), valueOf(), toString()

boolean b = Boolean.parseBoolean("true");
Boolean obj = Boolean.valueOf(true);
String str = Boolean.toString(true);

2.2 字符串处理

String：

表示不可变的字符串。
常用方法：length(), charAt(), substring(), split(), trim(), toUpperCase(), toLowerCase(), equals(), equalsIgnoreCase(), contains(), startsWith(), endsWith()

String str = "Hello, World!";
int len = str.length();
char ch = str.charAt(0);
String sub = str.substring(0, 5);
String[] parts = str.split(",");
String trimmed = str.trim();
String upper = str.toUpperCase();
String lower = str.toLowerCase();
boolean eq = str.equals("Hello, World!");
boolean eqIgnoreCase = str.equalsIgnoreCase("hello, world!");
boolean contains = str.contains("World");
boolean startsWith = str.startsWith("Hello");
boolean endsWith = str.endsWith("!");

StringBuilder 和 StringBuffer：

用于可变字符串的构建。
StringBuilder 是线程不安全的，但性能更高；StringBuffer 是线程安全的。
常用方法：append(), insert(), delete(), reverse(), toString()

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(", ");
sb.append("World!");
sb.insert(0, "Start: ");
sb.delete(6, 8);
sb.reverse();
String result = sb.toString();

2.3 数学运算

Math：

提供数学运算的静态方法。
常用方法：abs(), ceil(), floor(), max(), min(), pow(), random(), round(), sqrt()

int absValue = Math.abs(-10); // 绝对值
double ceilValue = Math.ceil(3.14); //向上取整，返回大于或等于给定数字的最小整数（返回：4）
double floorValue = Math.floor(3.14); // 向下取整，返回小于或等于给定数字的最大整数。（返回3）
int maxValue = Math.max(10, 20); // 返回给定参数中的最大值。可以比较两个或多个值。
int minValue = Math.min(10, 20); // 返回给定参数中的最小值。可以比较两个或多个值。
double powValue = Math.pow(2, 3); // 返回第一个参数的第二个参数次幂。即，计算x的y次幂。（返回8）
double randomValue = Math.random(); // 生成一个伪随机数。
long roundValue = Math.round(3.14); // 四舍五入到最接近的整数或指定的小数位数。（返回3）
double sqrtValue = Math.sqrt(16); // 返回给定数字的平方根。（返回4）

2.4 日期和时间

LocalDate, LocalTime, LocalDateTime：

用于表示日期和时间。
常用方法：now(), of(), plusDays(), minusDays(), format(), parse()

LocalDate date = LocalDate.now();
LocalTime time = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.now();
LocalDate date2 = LocalDate.of(2023, 10, 1);
LocalDate date3 = date.plusDays(10);
LocalDate date4 = date.minusDays(5);
String formattedDate = date.format(DateTimeFormatter.ISO_LOCAL_DATE);
LocalDate parsedDate = LocalDate.parse("2023-10-01", DateTimeFormatter.ISO_LOCAL_DATE);

2.5 集合框架

List：

有序集合，允许重复元素。
常用实现：ArrayList, LinkedList

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Apple");
String first = list.get(0);
list.remove(0);
boolean contains = list.contains("Banana");

Set：

无序集合，不允许重复元素。
常用实现：HashSet, TreeSet

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple");
boolean contains = set.contains("Banana");

Map：

键值对集合，键唯一。
常用实现：HashMap, TreeMap

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
int value = map.get("Apple");
boolean containsKey = map.containsKey("Banana");
boolean containsValue = map.containsValue(1);

2.6 输入输出

File：

表示文件和目录路径。
常用方法：exists(), isDirectory(), isFile(), createNewFile(), delete(), listFiles()

File file = new File("example.txt");
boolean exists = file.exists();
boolean isDir = file.isDirectory();
boolean isFile = file.isFile();
boolean created = file.createNewFile();
boolean deleted = file.delete();
File[] files = file.listFiles();

FileReader 和 FileWriter：

用于读写字符文件。

try (FileReader reader = new FileReader("input.txt")) {
    int ch;
    while ((ch = reader.read()) != -1) {
        System.out.print((char) ch);
    }
} catch (IOException e) {
    e.printStackTrace();
}

try (FileWriter writer = new FileWriter("output.txt")) {
    writer.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

BufferedReader 和 BufferedWriter：

提供缓冲功能，提高读写效率。

try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

2.7 异常处理

Exception：

b所有异常的基类。
常用子类：IOException, NumberFormatException, NullPointerException, ArrayIndexOutOfBoundsException

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("除零错误: " + e.getMessage());
} finally {
    System.out.println("finally 块总是会被执行");
}

RuntimeException：

未检查异常，编译器不要求必须捕获。
常用子类：IllegalArgumentException, IllegalStateException, UnsupportedOperationException

if (name == null) {
    throw new IllegalArgumentException("名称不能为空");
}

2.8 线程

Thread：

用于创建和管理线程。
常用方法：start(), run(), join(), sleep()

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行中...");
    }
}

MyThread thread = new MyThread();
thread.start();
thread.join(); // 等待线程结束

Runnable：

用于实现多线程的接口。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程运行中...");
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

2.9 文件和目录操作

Path 和 Paths：

用于表示文件路径。
常用方法：get(), resolve(), toAbsolutePath(), toRealPath()

Path path = Paths.get("example.txt");
Path absolutePath = path.toAbsolutePath();
Path resolvedPath = path.resolve("subdir/file.txt");
Path realPath = path.toRealPath();

Files：

提供文件操作的静态方法。
常用方法：readAllLines(), write(), copy(), move(), delete(), exists(), createDirectories()

Path path = Paths.get("example.txt");
List<String> lines = Files.readAllLines(path);
Files.write(path, lines);
Files.copy(path, Paths.get("backup.txt"), StandardCopyOption.REPLACE_EXISTING);
Files.move(path, Paths.get("new_example.txt"), StandardCopyOption.REPLACE_EXISTING);
Files.delete(path);
boolean exists = Files.exists(path);
Files.createDirectories(Paths.get("new_dir/subdir"));