备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

Java基础快速入门

入门导引:Java语言全景认知

〈Java语言发展简史与技术定位〉

Java由James Gosling于1991年在Sun Microsystems(后被Oracle收购)主导开发,1995年正式发布。其设计初衷是“一次编写,到处运行”(Write Once, Run Anywhere),核心在于JVM(Java虚拟机)实现平台无关性。经过三十余年发展,Java已从桌面应用、企业级Web开发扩展至Android移动开发、大数据(Hadoop/Spark)、微服务(Spring Cloud)、云原生(Kubernetes)等主流技术领域。

根据TIOBE 2025年3月数据,Java长期稳居编程语言前三,企业级应用覆盖率超60%。其稳定性、安全性、生态成熟度使其成为金融、电信、政府系统首选语言。2024年Stack Overflow开发者调查中,Java仍位列第五,企业招聘需求持续旺盛。

〔Java技术体系三层架构〕

Java技术体系分为三大核心模块:

  • Java SE(Standard Edition):标准版,提供基础语法、集合、IO、多线程、网络等核心API,是学习Java的起点。
  • Java EE(Enterprise Edition):企业版,构建于SE之上,提供Servlet/JSP、EJB、JPA、JSF等企业级规范,现为Jakarta EE。
  • Java ME(Micro Edition):微型版,面向嵌入式设备,已逐步被Android/Kotlin替代。

本教程聚焦Java SE核心内容,为后续企业级开发打下坚实基础。掌握SE后,学习Spring Boot、MyBatis等框架将事半功倍。

〔开发环境搭建三要素〕

配置Java开发环境需完成三个关键步骤:

  1. JDK安装:推荐JDK 17(长期支持版),下载地址:https://jdk.java.net/17/。安装后配置JAVA_HOME环境变量,并将%JAVA_HOME%\bin加入PATH。
  2. 编辑器选择:初学者可用记事本+命令行;进阶推荐IntelliJ IDEA(社区版免费)或Eclipse。
  3. 验证安装:终端执行java -version与javac -version,输出版本号即成功。

常见问题:若提示'java'不是内部或外部命令,请检查环境变量配置是否正确,尤其注意路径中不能含中文或空格。

语法基础:变量、数据类型与运算符

⚡ Java程序结构规范

一个标准Java源文件包含以下组成部分:

  • 包声明(package):位于文件首行,如package com.example;
  • 导入语句(import):如import java.util.Scanner;
  • 类声明(class):每个文件至少一个public class,文件名必须与类名一致
  • 主方法(main):程序入口点public static void main(String[] args)

示例:HelloWorld.java

package com.example;
import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入姓名:");
        String name = scanner.nextLine();
        System.out.println("欢迎你," + name + "!");
    }
}

〔变量与数据类型全景图〕

Java数据类型分为两大类:

类型 关键字 字节数 取值范围 默认值
整数型 byte、short、int、long 1、2、4、8 -128~127等 0
浮点型 float、double 4、8 ±3.4E+38等 0.0
字符型 char 2 0~65535 \u0000
布尔型 boolean 1位 true/false false
引用类型 类、接口、数组 依赖JVM 对象地址 null

注意:char类型使用单引号(如'A'),String是引用类型,使用双引号(如"Hello")。

〔运算符优先级与陷阱〕

常见运算符优先级(从高到低):

  1. 括号()
  2. 单目运算符++、--、!、~
  3. 算术运算符*、/、%、+、-
  4. 关系运算符<、>、<=、>=
  5. 相等运算符==、!=
  6. 逻辑运算符&&、||
  7. 赋值运算符=

典型陷阱:整数除法自动截断小数部分,如7 / 2 = 3。需用7.0 / 2或强制类型转换(double)7 / 2。

面向对象:封装、继承、多态

⚡ 类与对象的完整定义流程

以Student类为例:

public class Student {
    // 私有属性(封装)
    private String name;
    private int age;
    // 构造方法
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Getter/Setter(封装体现)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        } else {
            System.out.println("年龄非法!");
        }
    }
    // 重写toString方法
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

使用示例:

Student s = new Student("张三", 20);
System.out.println(s); // 输出:Student{name='张三', age=20}

〔继承机制与方法重写〕

子类GraduateStudent继承Student:

public class GraduateStudent extends Student {
    private String advisor; // 导师
    public GraduateStudent(String name, int age, String advisor) {
        super(name, age); // 调用父类构造器
        this.advisor = advisor;
    }
    // 方法重写(多态基础)
    @Override
    public String toString() {
        return "GraduateStudent{name='" + getName() + "', age=" + getAge() +
               ", advisor='" + advisor + "'}";
    }
    // 新增方法
    public void doResearch() {
        System.out.println(getName() + "正在做科研项目!");
    }
}

注意:final类不能被继承,final方法不能被重写。

〔多态的三种实现形式〕

多态是面向对象的核心特性,体现为:

  1. 方法重载:同一类中方法名相同,参数列表不同(类型/个数/顺序)
  2. 方法重写:子类重写父类方法,运行时动态绑定
  3. 接口多态:父接口引用指向子类对象

示例:接口多态

interface Animal {
    void speak();
}
class Dog implements Animal {
    public void speak() {
        System.out.println("汪汪!");
    }
}
class Cat implements Animal {
    public void speak() {
        System.out.println("喵喵!");
    }
}
public class Demo {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat()};
        for (Animal a : animals) {
            a.speak(); // 动态绑定,输出不同内容
        }
    }
}

集合框架:List、Set、Map详解

⚡ 集合体系架构图

Java集合框架核心接口:

Collection
├── List(有序、可重复)
│   ├── ArrayList(数组结构,查询快)
│   ├── LinkedList(链表结构,增删快)
│   └── Vector(线程安全,已过时)
└── Set(无序、不可重复)
    ├── HashSet(哈希表)
    ├── LinkedHashSet(链表+哈希)
    └── TreeSet(红黑树,排序)
Map(键值对)
├── HashMap(线程不安全)
├── LinkedHashMap(有序)
├── Hashtable(线程安全,已过时)
└── TreeMap(排序)

〔ArrayList与LinkedList性能对比〕

常见操作时间复杂度:

操作 ArrayList LinkedList
访问元素(get) O(1) O(n)
末尾添加(add) 均摊O(1) O(1)
中间插入/删除 O(n) O(1)
内存占用 连续内存,空间利用率高 每个节点额外存储指针

选择建议:

  • 频繁查询用ArrayList
  • 频繁增删用LinkedList
  • 需要栈/队列功能用Deque(如ArrayDeque)

〔HashMap工作原理深度解析〕

HashMap基于哈希表实现,核心机制包括:

  1. 哈希函数:通过hashCode()计算键的哈希值
  2. 数组+链表/红黑树:JDK 1.8后,链表长度>8且数组长度≥64时转为红黑树
  3. 负载因子:默认0.75,超过阈值触发扩容(2倍)

示例:使用HashMap统计单词频率

Map wordCount = new HashMap<>();
String[] words = {"java", "java", "oop", "java", "oop"};
for (String w : words) {
    wordCount.put(w, wordCount.getOrDefault(w, 0) + 1);
}
System.out.println(wordCount); // {java=3, oop=2}

异常处理:机制、分类与最佳实践

⚡ 异常体系结构

Java异常继承树:

Throwable
├── Error(严重错误,不可处理)
└── Exception
    ├── RuntimeException(运行时异常)
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   └── IllegalArgumentException
    └── Checked Exception(受检异常)
        ├── IOException
        ├── SQLException
        └── ClassNotFoundException

注意:RuntimeException及其子类无需显式捕获或声明,其他异常必须处理。

〔try-catch-finally执行流程〕

执行顺序:try → catch(异常发生时)→ finally(始终执行)

示例:文件读取异常处理

try {
    BufferedReader br = new BufferedReader(new FileReader("data.txt"));
    String line = br.readLine();
    System.out.println(line);
} catch (FileNotFoundException e) {
    System.err.println("文件未找到:" + e.getMessage());
} catch (IOException e) {
    System.err.println("读取失败:" + e.getMessage());
} finally {
    System.out.println("资源清理完成");
}

注意:finally块中避免使用return,会覆盖try中的返回值。

〔自定义异常与最佳实践〕

自定义异常示例:

public class AgeOutOfBoundsException extends Exception {
    public AgeOutOfBoundsException(String message) {
        super(message);
    }
}
// 使用
if (age < 0 || age > 150) {
    throw new AgeOutOfBoundsException("年龄超出有效范围");
}

异常处理最佳实践:

  • 精确捕获:避免使用catch (Exception e)泛化捕获
  • 及时处理:在合适层级捕获并给出用户友好提示
  • 记录日志:使用logger.error("错误详情", e)记录堆栈
  • 资源释放:使用try-with-resources自动关闭资源

输入输出:文件与流处理

⚡ Java IO流分类

按方向分:输入流(InputStream/Reader)、输出流(OutputStream/Writer)

按单位分:字节流(处理二进制)、字符流(处理文本)

常用流:

  • FileInputStream/FileOutputStream:文件字节流
  • FileReader/FileWriter:文件字符流
  • BufferedReader/BufferedWriter:缓冲字符流,支持按行读写
  • ObjectInputStream/ObjectOutputStream:对象序列化

〔文件复制完整实现〕

import java.io.*;
public class FileCopy {
    public static void copyFile(String src, String dest) {
        try (BufferedReader br = new BufferedReader(new FileReader(src));
             BufferedWriter bw = new BufferedWriter(new FileWriter(dest))) {
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
            System.out.println("文件复制成功!");
        } catch (IOException e) {
            System.err.println("复制失败:" + e.getMessage());
        }
    }
    public static void main(String[] args) {
        copyFile("input.txt", "output.txt");
    }
}

注意:使用try-with-resources确保资源自动关闭,避免内存泄漏。

〔对象序列化与反序列化〕

序列化用于对象持久化或网络传输:

import java.io.*;
class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    // 构造器、Getter/Setter略
}
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"));
oos.writeObject(new User("李四", 25));
oos.close();
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"));
User user = (User) ois.readObject();
ois.close();

注意:serialVersionUID需显式声明,避免类结构变更导致反序列化失败。

多线程:并发编程核心

⚡ 线程创建的三种方式

1. 继承Thread类:

class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中:" + Thread.currentThread().getName());
    }
}
new MyThread().start();

2. 实现Runnable接口:

class MyTask implements Runnable {
    public void run() {
        System.out.println("任务执行中:" + Thread.currentThread().getName());
    }
}
new Thread(new MyTask()).start();

3. 使用Callable与Future(有返回值):

Callable task = () -> {
    return 123;
};
FutureTask future = new FutureTask<>(task);
new Thread(future).start();
System.out.println("结果:" + future.get());

〔线程同步机制详解〕

线程安全问题源于共享数据竞争,解决方案:

  1. synchronized关键字
    • 同步代码块:synchronized(obj) { ... }
    • 同步方法:public synchronized void method() { ... }
  2. Lock接口(更灵活)
    • ReentrantLock支持可重入锁
    • ReadWriteLock支持读写分离

示例:使用synchronized实现计数器

public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++; // 等价于 count = count + 1(非原子操作)
    }
    public int getCount() {
        return count;
    }
}

〔线程池使用与原理〕

ExecutorService线程池示例:

ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
    pool.execute(() -> {
        System.out.println("任务执行:" + Thread.currentThread().getName());
    });
}
pool.shutdown(); // 关闭线程池

线程池核心参数:

  • corePoolSize:核心线程数
  • maximumPoolSize:最大线程数
  • keepAliveTime:空闲线程存活时间
  • workQueue:任务队列(如LinkedBlockingQueue)

生产环境推荐使用ThreadPoolExecutor自定义配置,避免Executors工厂方法的潜在风险(如无界队列导致OOM)。

数据库连接:JDBC核心操作

⚡ JDBC五步操作流程

使用JDBC访问数据库的标准步骤:

  1. 加载驱动:Class.forName("com.mysql.cj.jdbc.Driver");
  2. 建立连接:Connection conn = DriverManager.getConnection(url, user, pwd);
  3. 创建语句:PreparedStatement ps = conn.prepareStatement(sql);
  4. 执行查询:ResultSet rs = ps.executeQuery();
  5. 处理结果:遍历ResultSet获取数据

〔JDBC工具类设计〕

统一管理数据库连接与资源释放:

public class JDBCUtils {
    private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
    private static final String USER = "root";
    private static final String PASSWORD = "123456";
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("驱动加载失败", e);
        }
    }
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            throw new RuntimeException("连接数据库失败", e);
        }
    }
    public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
        if (rs != null) try { rs.close(); } catch (SQLException e) {}
        if (ps != null) try { ps.close(); } catch (SQLException e) {}
        if (conn != null) try { conn.close(); } catch (SQLException e) {}
    }
}

〔防止SQL注入的参数化查询〕

错误示例(易受SQL注入攻击):

String sql = "SELECT * FROM users WHERE name='" + name + "' AND pwd='" + pwd + "'";

正确示例(参数化查询):

String sql = "SELECT * FROM users WHERE name=? AND pwd=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, name);
ps.setString(2, pwd);
ResultSet rs = ps.executeQuery();

使用PreparedStatement可自动转义特殊字符,有效防止SQL注入攻击。

网络编程:TCP/UDP通信实现

⚡ UDP通信基本流程

UDP是无连接的轻量级协议,适合实时性要求高的场景(如视频直播):

发送端:

DatagramSocket socket = new DatagramSocket();
String msg = "Hello UDP";
byte[] data = msg.getBytes();
InetAddress addr = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(data, data.length, addr, 9999);
socket.send(packet);
socket.close();

接收端:

DatagramSocket socket = new DatagramSocket(9999);
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
socket.receive(packet);
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到:" + received);
socket.close();

〔TCP通信完整示例〕

TCP是面向连接的可靠协议,适合文件传输:

服务端:

ServerSocket server = new ServerSocket(8888);
Socket client = server.accept(); // 阻塞等待连接
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true);
String line = in.readLine();
System.out.println("收到:" + line);
out.println("服务器已收到:" + line);
in.close();
out.close();
client.close();
server.close();

客户端:

Socket socket = new Socket("localhost", 8888);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello TCP");
String response = in.readLine();
System.out.println("服务器回复:" + response);
in.close();
out.close();
socket.close();

〔HTTP请求实现〕

使用HttpURLConnection发起GET请求:

URL url = new URL("https://www.xservx.com/api/data");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);
int code = conn.getResponseCode();
if (code == 200) {
    BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
    String line;
    StringBuilder result = new StringBuilder();
    while ((line = reader.readLine()) != null) {
        result.append(line);
    }
    System.out.println("响应数据:" + result.toString());
}

注意:实际开发中推荐使用HttpClient(Java 11+)或第三方库(如OkHttp)。

实战项目:简易图书管理系统

⚡ 系统功能需求

基于控制台的图书管理系统,包含以下核心功能:

  • 用户模块:管理员/读者登录注册
  • 图书管理:增删改查(按ID/书名模糊查询)
  • 借阅管理:借书/还书记录管理
  • 数据持久化:使用JSON文件存储数据

〔核心类结构设计〕

├── Book(图书实体)
│   ├── id(编号)
│   ├── title(书名)
│   ├── author(作者)
│   └── status(状态:0-在库,1-已借出)
│
├── User(用户实体)
│   ├── username(用户名)
│   ├── password(密码)
│   └── role(角色:admin/reader)
│
├── BorrowRecord(借阅记录)
│   ├── bookId
│   ├── userId
│   ├── borrowDate
│   └── returnDate
│
├── BookManager(图书管理类)
│   ├── addBook()
│   ├── searchBook()
│   └── updateBook()
│
├── UserManager(用户管理类)
│   ├── login()
│   └── register()
│
└── Main(主程序入口)

〔关键代码片段〕

图书管理类核心方法:

public void addBook(Book book) {
    books.add(book); // books为List
    saveToFile(); // 保存到JSON文件
}
public List searchByTitle(String keyword) {
    return books.stream()
               .filter(b -> b.getTitle().contains(keyword))
               .collect(Collectors.toList());
}

借书操作逻辑:

public boolean borrowBook(String bookId, String userId) {
    Book book = findBookById(bookId);
    if (book == null) {
        System.out.println("图书不存在!");
        return false;
    }
    if (book.getStatus() == 1) {
        System.out.println("图书已被借出!");
        return false;
    }
    book.setStatus(1);
    BorrowRecord record = new BorrowRecord(bookId, userId, new Date(), null);
    records.add(record);
    saveToFile();
    return true;
}

面试指南:高频考点与答案

⚡ Java基础高频问题

Q1:==与equals的区别?

答:==比较基本类型值或引用地址;equals默认比较地址,但String/Integer等类重写了该方法,比较内容。重写equals需同时重写hashCode。

Q2:HashMap与HashTable的区别?

答:HashMap线程不安全、允许null键值、性能高;Hashtable线程安全、不允许null键值、性能低。现代开发推荐ConcurrentHashMap。

Q3:final、finally、finalize的区别?

答:final修饰类/方法/变量(不可继承/重写/修改);finally是异常处理块;finalize是Object方法,对象被GC前调用(已废弃,不推荐使用)。

〔集合与并发专项〕

Q4:ArrayList扩容机制?

答:默认容量10,扩容为原容量的1.5倍(oldCapacity + (oldCapacity >> 1))。JDK 1.8后首次添加时才初始化数组。

Q5:ConcurrentHashMap如何实现线程安全?

答:JDK 1.8使用CAS+synchronized保证线程安全。将数据分段(Segment),每段独立加锁,减少锁竞争。

Q6:线程池的核心参数有哪些?

答:核心线程数、最大线程数、空闲线程存活时间、任务队列、拒绝策略(AbortPolicy/CallerRunsPolicy等)。

〔JDBC与IO专项〕

Q7:PreparedStatement与Statement的区别?

答:PreparedStatement预编译SQL,防SQL注入;Statement直接拼接SQL,易受注入攻击。

Q8:NIO与传统IO的区别?

答:传统IO是阻塞式流式处理;NIO(New IO)基于通道(Channel)和缓冲区(Buffer),支持非阻塞模式,适合高并发场景。

资源推荐:学习资料与工具

〔开发工具推荐〕

  • IDE:IntelliJ IDEA(推荐)、Eclipse、VS Code(轻量)
  • 构建工具:Maven、Gradle
  • 版本控制:Git + GitHub/Gitee
  • 数据库:MySQL、Navicat
  • 调试工具:JProfiler(性能分析)、VisualVM

〔书籍推荐〕

  • 《Java核心技术 卷I》(Core Java):经典入门教材
  • 《Effective Java》:编写高质量Java代码的39条法则
  • 《Java编程思想》:深入理解面向对象思想
  • 《Java并发编程实战》:并发编程权威指南