欢迎来到Java编程世界！本章将为你介绍Java语言的基础概念、特点和发展历程，为后续的深入学习打下坚实的基础。

1.1 Java简介

什么是Java？

Java是一种面向对象的编程语言，由Sun Microsystems公司（现为Oracle公司）于1995年发布。Java以其”一次编写，到处运行”（Write Once, Run Anywhere, WORA）的特性而闻名。

Java的核心特点

1. 平台无关性

Java程序编译后生成字节码（Bytecode），运行在Java虚拟机（JVM）上，实现了跨平台特性。

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

// 编译过程：
// HelloWorld.java → javac → HelloWorld.class (字节码)
// 运行过程：
// HelloWorld.class → JVM → 在任何支持JVM的平台上运行

2. 面向对象

Java是纯面向对象的语言，一切皆对象（除了基本数据类型）。

// 类的定义
public class Student {
    // 属性（成员变量）
    private String name;
    private int age;
    
    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 方法
    public void study() {
        System.out.println(name + " is studying.");
    }
    
    // Getter和Setter方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

// 对象的创建和使用
public class Main {
    public static void main(String[] args) {
        Student student = new Student("张三", 20);
        student.study();
        System.out.println("学生姓名：" + student.getName());
    }
}

3. 自动内存管理

Java具有自动垃圾回收（Garbage Collection, GC）机制，自动管理内存分配和释放。

public class MemoryExample {
    public static void main(String[] args) {
        // 创建对象，JVM自动分配内存
        String str1 = new String("Hello");
        String str2 = new String("World");
        
        // 当对象不再被引用时，GC会自动回收内存
        str1 = null; // str1指向的对象变为垃圾，等待回收
        
        // 手动建议进行垃圾回收（不保证立即执行）
        System.gc();
    }
}

4. 强类型系统

Java是强类型语言，所有变量必须先声明类型才能使用。

public class TypeExample {
    public static void main(String[] args) {
        // 基本数据类型
        int number = 42;
        double price = 99.99;
        boolean isActive = true;
        char grade = 'A';
        
        // 引用数据类型
        String message = "Hello Java";
        int[] numbers = {1, 2, 3, 4, 5};
        
        // 类型转换
        double result = number + price; // 自动类型提升
        int intResult = (int) price;    // 强制类型转换
        
        System.out.println("Number: " + number);
        System.out.println("Price: " + price);
        System.out.println("Result: " + result);
        System.out.println("Int Result: " + intResult);
    }
}

5. 多线程支持

Java内置了多线程支持，可以轻松创建并发程序。

// 继承Thread类
class MyThread extends Thread {
    private String threadName;
    
    public MyThread(String name) {
        this.threadName = name;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(threadName + " - Count: " + i);
            try {
                Thread.sleep(1000); // 暂停1秒
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted.");
            }
        }
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    private String threadName;
    
    public MyRunnable(String name) {
        this.threadName = name;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(threadName + " - Count: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted.");
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        // 使用Thread类
        MyThread thread1 = new MyThread("Thread-1");
        thread1.start();
        
        // 使用Runnable接口
        Thread thread2 = new Thread(new MyRunnable("Thread-2"));
        thread2.start();
        
        // 使用Lambda表达式（Java 8+）
        Thread thread3 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Lambda-Thread - Count: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread interrupted.");
                }
            }
        });
        thread3.start();
    }
}

1.2 Java发展历程

主要版本里程碑

版本 发布年份 主要特性
Java 1.0 1996 初始版本，AWT图形界面
Java 1.1 1997 内部类，JavaBeans，JDBC
Java 1.2 (J2SE) 1998 Swing，集合框架，JIT编译器
Java 1.3 2000 HotSpot JVM，JNDI
Java 1.4 2002 断言，正则表达式，NIO
Java 5 (1.5) 2004 泛型，枚举，注解，自动装箱
Java 6 2006 脚本引擎，Web服务
Java 7 2011 try-with-resources，钻石操作符
Java 8 2014 Lambda表达式，Stream API，默认方法
Java 9 2017 模块系统，JShell
Java 10 2018 局部变量类型推断（var）
Java 11 2018 HTTP Client，字符串方法增强
Java 17 2021 密封类，模式匹配增强（LTS版本）
Java 21 2023 虚拟线程，模式匹配for switch（LTS版本）

Java版本特性示例

Java 8 - Lambda表达式和Stream API

import java.util.*;
import java.util.stream.*;

public class Java8Features {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
        
        // 传统方式
        List<String> filteredNames = new ArrayList<>();
        for (String name : names) {
            if (name.length() > 3) {
                filteredNames.add(name.toUpperCase());
            }
        }
        Collections.sort(filteredNames);
        
        // Java 8 Stream API方式
        List<String> result = names.stream()
            .filter(name -> name.length() > 3)  // Lambda表达式
            .map(String::toUpperCase)           // 方法引用
            .sorted()                           // 排序
            .collect(Collectors.toList());      // 收集结果
        
        System.out.println("传统方式结果: " + filteredNames);
        System.out.println("Stream API结果: " + result);
        
        // 函数式接口
        Runnable task = () -> System.out.println("Hello from Lambda!");
        task.run();
    }
}

Java 10 - var关键字

import java.util.*;

public class Java10Features {
    public static void main(String[] args) {
        // 局部变量类型推断
        var message = "Hello Java 10!";  // 推断为String
        var number = 42;                  // 推断为int
        var list = new ArrayList<String>(); // 推断为ArrayList<String>
        var map = Map.of("key1", "value1", "key2", "value2"); // 推断为Map<String, String>
        
        list.add("Item 1");
        list.add("Item 2");
        
        System.out.println("Message: " + message);
        System.out.println("Number: " + number);
        System.out.println("List: " + list);
        System.out.println("Map: " + map);
    }
}

Java 17 - 密封类

// 密封类定义
public sealed class Shape permits Circle, Rectangle, Triangle {
    protected final String name;
    
    protected Shape(String name) {
        this.name = name;
    }
    
    public abstract double area();
}

// 允许的子类
final class Circle extends Shape {
    private final double radius;
    
    public Circle(double radius) {
        super("Circle");
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

final class Rectangle extends Shape {
    private final double width, height;
    
    public Rectangle(double width, double height) {
        super("Rectangle");
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double area() {
        return width * height;
    }
}

non-sealed class Triangle extends Shape {
    private final double base, height;
    
    public Triangle(double base, double height) {
        super("Triangle");
        this.base = base;
        this.height = height;
    }
    
    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

// 使用密封类
public class SealedClassExample {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);
        Shape triangle = new Triangle(3.0, 4.0);
        
        System.out.println("Circle area: " + circle.area());
        System.out.println("Rectangle area: " + rectangle.area());
        System.out.println("Triangle area: " + triangle.area());
        
        // 模式匹配（Java 17预览特性）
        printShapeInfo(circle);
        printShapeInfo(rectangle);
    }
    
    public static void printShapeInfo(Shape shape) {
        switch (shape) {
            case Circle c -> System.out.println("这是一个圆形");
            case Rectangle r -> System.out.println("这是一个矩形");
            case Triangle t -> System.out.println("这是一个三角形");
        }
    }
}

1.3 Java生态系统

核心组件

1. Java虚拟机（JVM）

// JVM内存区域示例
public class JVMExample {
    // 方法区（元空间）- 存储类信息
    private static final String CONSTANT = "Hello";
    
    // 堆内存 - 存储对象实例
    private String instanceVariable;
    
    public static void main(String[] args) {
        // 栈内存 - 存储局部变量和方法调用
        int localVariable = 10;
        
        // 创建对象（在堆中分配内存）
        JVMExample example = new JVMExample();
        example.instanceVariable = "Instance";
        
        // 方法调用（在栈中创建栈帧）
        example.methodCall(localVariable);
    }
    
    private void methodCall(int parameter) {
        // 局部变量（在当前栈帧中）
        String localString = "Local";
        System.out.println("Parameter: " + parameter);
        System.out.println("Local: " + localString);
        System.out.println("Instance: " + instanceVariable);
        System.out.println("Constant: " + CONSTANT);
    }
}

2. Java开发工具包（JDK）

# JDK主要工具
javac    # Java编译器
java     # Java运行时
javadoc  # 文档生成工具
jar      # 打包工具
jdb      # 调试器
jps      # 进程状态工具
jstat    # 统计信息工具
jmap     # 内存映射工具
jstack   # 线程堆栈工具

3. Java运行时环境（JRE）

// 运行时信息获取
public class RuntimeExample {
    public static void main(String[] args) {
        // 获取运行时信息
        Runtime runtime = Runtime.getRuntime();
        
        System.out.println("可用处理器数量: " + runtime.availableProcessors());
        System.out.println("JVM最大内存: " + runtime.maxMemory() / 1024 / 1024 + " MB");
        System.out.println("JVM总内存: " + runtime.totalMemory() / 1024 / 1024 + " MB");
        System.out.println("JVM空闲内存: " + runtime.freeMemory() / 1024 / 1024 + " MB");
        
        // 获取系统属性
        System.out.println("Java版本: " + System.getProperty("java.version"));
        System.out.println("操作系统: " + System.getProperty("os.name"));
        System.out.println("用户目录: " + System.getProperty("user.home"));
        System.out.println("工作目录: " + System.getProperty("user.dir"));
    }
}

主要框架和库

1. Spring框架

// Spring Boot示例
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SpringBootExample {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot!";
    }
    
    public static void main(String[] args) {
        SpringApplication.run(SpringBootExample.class, args);
    }
}

2. 数据库访问

// JDBC示例
import java.sql.*;

public class JDBCExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/testdb";
        String username = "root";
        String password = "password";
        
        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 创建表
            String createTable = "CREATE TABLE IF NOT EXISTS users (" +
                "id INT PRIMARY KEY AUTO_INCREMENT, " +
                "name VARCHAR(50), " +
                "email VARCHAR(100))";
            
            try (Statement statement = connection.createStatement()) {
                statement.execute(createTable);
            }
            
            // 插入数据
            String insertSQL = "INSERT INTO users (name, email) VALUES (?, ?)";
            try (PreparedStatement pstmt = connection.prepareStatement(insertSQL)) {
                pstmt.setString(1, "张三");
                pstmt.setString(2, "zhangsan@example.com");
                pstmt.executeUpdate();
            }
            
            // 查询数据
            String selectSQL = "SELECT * FROM users";
            try (Statement statement = connection.createStatement();
                 ResultSet resultSet = statement.executeQuery(selectSQL)) {
                
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");
                    String email = resultSet.getString("email");
                    System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
                }
            }
            
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

1.4 Java应用领域

1. 企业级应用开发

// 企业级应用示例 - 简单的订单管理系统
import java.time.LocalDateTime;
import java.util.*;

// 实体类
class Order {
    private String orderId;
    private String customerId;
    private List<OrderItem> items;
    private LocalDateTime orderDate;
    private OrderStatus status;
    
    public Order(String orderId, String customerId) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.items = new ArrayList<>();
        this.orderDate = LocalDateTime.now();
        this.status = OrderStatus.PENDING;
    }
    
    // Getters and Setters
    public String getOrderId() { return orderId; }
    public String getCustomerId() { return customerId; }
    public List<OrderItem> getItems() { return items; }
    public LocalDateTime getOrderDate() { return orderDate; }
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
    
    public void addItem(OrderItem item) {
        items.add(item);
    }
    
    public double getTotalAmount() {
        return items.stream().mapToDouble(OrderItem::getTotalPrice).sum();
    }
}

class OrderItem {
    private String productId;
    private String productName;
    private int quantity;
    private double unitPrice;
    
    public OrderItem(String productId, String productName, int quantity, double unitPrice) {
        this.productId = productId;
        this.productName = productName;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }
    
    public double getTotalPrice() {
        return quantity * unitPrice;
    }
    
    // Getters
    public String getProductId() { return productId; }
    public String getProductName() { return productName; }
    public int getQuantity() { return quantity; }
    public double getUnitPrice() { return unitPrice; }
}

enum OrderStatus {
    PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED
}

// 服务类
class OrderService {
    private Map<String, Order> orders = new HashMap<>();
    
    public Order createOrder(String customerId) {
        String orderId = "ORD" + System.currentTimeMillis();
        Order order = new Order(orderId, customerId);
        orders.put(orderId, order);
        return order;
    }
    
    public Order getOrder(String orderId) {
        return orders.get(orderId);
    }
    
    public void updateOrderStatus(String orderId, OrderStatus status) {
        Order order = orders.get(orderId);
        if (order != null) {
            order.setStatus(status);
        }
    }
    
    public List<Order> getOrdersByCustomer(String customerId) {
        return orders.values().stream()
            .filter(order -> order.getCustomerId().equals(customerId))
            .toList();
    }
}

// 主类
public class EnterpriseExample {
    public static void main(String[] args) {
        OrderService orderService = new OrderService();
        
        // 创建订单
        Order order = orderService.createOrder("CUST001");
        order.addItem(new OrderItem("PROD001", "笔记本电脑", 1, 5999.99));
        order.addItem(new OrderItem("PROD002", "鼠标", 2, 99.99));
        
        System.out.println("订单ID: " + order.getOrderId());
        System.out.println("客户ID: " + order.getCustomerId());
        System.out.println("订单总额: " + order.getTotalAmount());
        System.out.println("订单状态: " + order.getStatus());
        
        // 更新订单状态
        orderService.updateOrderStatus(order.getOrderId(), OrderStatus.CONFIRMED);
        System.out.println("更新后状态: " + order.getStatus());
    }
}

2. Android移动应用开发

// Android Activity示例
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {
    private TextView textView;
    private Button button;
    private int clickCount = 0;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // 初始化视图组件
        textView = findViewById(R.id.textView);
        button = findViewById(R.id.button);
        
        // 设置点击事件监听器
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                clickCount++;
                textView.setText("点击次数: " + clickCount);
            }
        });
        
        // 使用Lambda表达式（Android支持Java 8特性）
        // button.setOnClickListener(v -> {
        //     clickCount++;
        //     textView.setText("点击次数: " + clickCount);
        // });
    }
}

3. Web开发

// Servlet示例
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class HelloServlet extends HttpServlet {
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        
        response.setContentType("text/html;charset=UTF-8");
        
        try (PrintWriter out = response.getWriter()) {
            out.println("<!DOCTYPE html>");
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Hello Servlet</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<h1>Hello from Java Servlet!</h1>");
            out.println("<p>当前时间: " + new java.util.Date() + "</p>");
            out.println("</body>");
            out.println("</html>");
        }
    }
    
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

1.5 Java与其他语言对比

Java vs Python

// Java版本 - 计算斐波那契数列
public class FibonacciJava {
    public static long fibonacci(int n) {
        if (n <= 1) return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    public static void main(String[] args) {
        int n = 10;
        System.out.println("斐波那契数列前" + n + "项:");
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }
}

# Python版本 - 计算斐波那契数列
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

n = 10
print(f"斐波那契数列前{n}项:")
for i in range(n):
    print(fibonacci(i), end=" ")

Java vs C++

特性 Java C++
内存管理 自动垃圾回收 手动管理
平台依赖 跨平台（JVM） 平台相关
多重继承 不支持（接口多实现） 支持
指针 无指针概念 支持指针
编译方式 编译为字节码 编译为机器码
性能 相对较慢 更快
安全性 更安全 需要小心处理

1.6 学习路径规划

初学者路径（0-3个月）

// 学习目标检查清单
public class LearningPath {
    public static void main(String[] args) {
        System.out.println("=== Java初学者学习路径 ===");
        
        // 第1阶段：基础语法（1个月）
        String[] basicTopics = {
            "变量和数据类型",
            "运算符和表达式",
            "控制结构（if, for, while）",
            "数组和字符串",
            "方法定义和调用"
        };
        
        System.out.println("第1阶段 - 基础语法:");
        for (String topic : basicTopics) {
            System.out.println("  ☐ " + topic);
        }
        
        // 第2阶段：面向对象（1个月）
        String[] oopTopics = {
            "类和对象",
            "封装、继承、多态",
            "构造方法和方法重载",
            "接口和抽象类",
            "异常处理"
        };
        
        System.out.println("\n第2阶段 - 面向对象:");
        for (String topic : oopTopics) {
            System.out.println("  ☐ " + topic);
        }
        
        // 第3阶段：核心API（1个月）
        String[] apiTopics = {
            "集合框架（List, Set, Map）",
            "文件I/O操作",
            "多线程基础",
            "网络编程基础",
            "数据库连接（JDBC）"
        };
        
        System.out.println("\n第3阶段 - 核心API:");
        for (String topic : apiTopics) {
            System.out.println("  ☐ " + topic);
        }
    }
}

进阶路径（3-6个月）

// 进阶学习目标
public class AdvancedLearningPath {
    public static void main(String[] args) {
        System.out.println("=== Java进阶学习路径 ===");
        
        // 框架学习
        String[] frameworks = {
            "Spring Framework",
            "Spring Boot",
            "Spring MVC",
            "MyBatis/Hibernate",
            "Maven/Gradle构建工具"
        };
        
        System.out.println("框架技术:");
        for (String framework : frameworks) {
            System.out.println("  ☐ " + framework);
        }
        
        // 高级特性
        String[] advanced = {
            "Lambda表达式和Stream API",
            "反射和注解",
            "泛型深入",
            "并发编程",
            "JVM调优"
        };
        
        System.out.println("\n高级特性:");
        for (String topic : advanced) {
            System.out.println("  ☐ " + topic);
        }
    }
}

本章小结

本章我们学习了Java的基础概念：

  1. Java特点：平台无关性、面向对象、自动内存管理、强类型系统、多线程支持
  2. 发展历程：从Java 1.0到Java 21的主要版本和特性
  3. 生态系统：JVM、JDK、JRE以及主要框架
  4. 应用领域：企业级应用、Android开发、Web开发等
  5. 学习路径：从基础语法到高级特性的系统学习计划

下一章预告

下一章我们将学习Java环境搭建与开发工具，包括： - JDK安装和配置 - IDE选择和配置 - 项目构建工具 - 调试和性能分析工具

练习题

基础练习

  1. 环境检查：

    • 查看你的系统Java版本
    • 了解JDK和JRE的区别
    • 尝试编译和运行第一个Java程序

  2. 概念理解：

    • 解释”一次编写，到处运行”的含义
    • 说明Java的主要特点
    • 比较Java与其他编程语言的优缺点

进阶练习

  1. 代码分析：

    • 分析本章中的多线程示例
    • 理解密封类的使用场景
    • 探索Stream API的其他用法

  2. 实践项目：

    • 创建一个简单的学生管理系统
    • 实现基本的增删改查功能
    • 使用面向对象的设计原则

提示：Java学习需要大量的实践，建议每学完一个概念就立即编写代码验证理解。

📂 分类导航

📰 最新文章