本文提供了Java主流技术入门的全面指南，涵盖了从环境搭建到基本语法、面向对象编程和常用库的详细介绍。文章还深入讲解了Java在Web开发、数据库操作以及高级特性中的应用，帮助读者快速掌握所需技能。

Java简介

Java是一种广泛使用的高级编程语言，由Sun Microsystems公司（现已被Oracle公司收购）于1995年推出。Java的设计初衷是“编写一次，到处运行”（Write Once, Run Anywhere），使得Java程序可以在任何支持Java的平台上运行，无需重新编译。Java语言具有简单性、面向对象、安全性、平台无关性、可移植性等特性，广泛应用于企业级应用程序、Web开发、移动应用开发、大数据处理等领域。

安装Java开发环境

安装Java开发工具包（JDK）

Java开发工具包（JDK, Java Development Kit）是Java开发环境的基础，包含Java虚拟机（JVM, Java Virtual Machine）、Java核心库以及编译、调试和运行Java程序所需的工具。

1. 访问Oracle官方网站下载JDK，选择适合的操作系统版本。
2. 安装JDK。安装过程中，确保勾选“Add JDK to PATH”选项，以便在命令行中直接使用Java命令。
3. 验证安装是否成功。打开命令行工具，输入java -version命令，如果显示Java版本信息，则表示安装成功。

安装代码编辑器

安装一款代码编辑器，如IntelliJ IDEA、Eclipse或Visual Studio Code。

1. 访问代码编辑器的官方网站，下载适合的操作系统版本。
2. 安装并启动代码编辑器。
3. 配置代码编辑器：
   • 在IntelliJ IDEA中，可以通过File -> Settings配置Java SDK。
   • 在Eclipse中，可以通过Windows -> Preferences -> Java -> Installed JREs配置Java SDK。
   • 在Visual Studio Code中，可以通过File -> Preferences -> Settings配置Java SDK。

安装构建工具（Maven或Gradle）

为了方便项目管理和依赖管理，可以安装Maven或Gradle。

1. 访问Maven或Gradle的官方网站下载相关插件。
2. 安装并配置Maven或Gradle。

第一个Java程序

创建并运行一个简单的Java程序，输出“Hello, World!”。

步骤

1. 打开代码编辑器，创建一个新项目。
2. 创建一个新的Java文件，命名为HelloWorld.java。
3. 编写Java代码如下：

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

1. 在命令行中，导航到项目目录。
2. 使用javac HelloWorld.java命令编译Java源文件。
3. 使用java HelloWorld命令运行编译后的Java程序。

输出

运行程序后，控制台上会输出：

Hello, World!

Java基本语法和数据类型

Java的基本语法涵盖了变量声明、常量定义、运算符以及流程控制语句。

变量与类型

1. 变量声明：
   • 基本类型：int, double, boolean, char
   • 引用类型：String, Object

int age = 25;
double salary = 3000.50;
boolean isStudent = true;
char grade = 'A';
String name = "John";

常量定义

使用final关键字定义常量。

final int MAX_VALUE = 100;

运算符

Java支持多种运算符，包括算术运算符、关系运算符、逻辑运算符等。

int a = 10;
int b = 5;

int sum = a + b; // 算术运算符
int difference = a - b;
int product = a * b;
int quotient = a / b;
boolean isEqual = a == b; // 关系运算符
boolean isGreater = a > b;
boolean result = isStudent && isEqual; // 逻辑运算符

数据类型转换

Java支持自动类型转换和强制类型转换。

int num = 10;
double dnum = num; // 自动类型转换

int age = (int) 25.5; // 强制类型转换

基本的控制结构和流程控制

Java提供了多种控制结构，包括条件语句、循环语句和跳转语句。

int age = 18;

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

switch (age) {
    case 18:
        System.out.println("成年人");
        break;
    default:
        System.out.println("未成年人");
}

for (int i = 0; i < 5; i++) {
    System.out.println("循环次数: " + i);
}

int count = 0;
while (count < 5) {
    System.out.println("循环次数: " + count);
    count++;
}

int num = 0;
do {
    System.out.println("循环次数: " + num);
    num++;
} while (num < 5);

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

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

数组、方法和面向对象编程基础

数组

Java中的数组分为一维数组和多维数组。

int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

方法

定义和调用方法。

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

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result = calculator.add(3, 4);
        System.out.println("结果: " + result);
    }
}

面向对象编程基础

定义类和对象。

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 void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 25);
        person.displayInfo();
    }
}

常用库简介

Java提供了丰富的标准库，包括输入输出流、集合框架、字符串处理、日期时间处理、网络编程等。

输入输出流

Java提供了面向流的输入输出处理类，包括InputStream、OutputStream、Reader和Writer。

import java.io.*;

public class FileCopy {
    public static void copyFile(String sourcePath, String destinationPath) throws IOException {
        InputStream in = new FileInputStream(sourcePath);
        OutputStream out = new FileOutputStream(destinationPath);

        byte[] buffer = new byte[1024];
        int length;

        while ((length = in.read(buffer)) > 0) {
            out.write(buffer, 0, length);
        }

        in.close();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        copyFile("源文件路径", "目标文件路径");
    }
}

集合框架

Java集合框架提供了多种数据结构，包括List、Set、Map等。

import java.util.*;

public class CollectionExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        Set<String> set = new HashSet<>();
        set.add("数据1");
        set.add("数据2");
        set.add("数据3");

        Map<String, String> map = new HashMap<>();
        map.put("键1", "值1");
        map.put("键2", "值2");
        map.put("键3", "值3");

        for (String element : list) {
            System.out.println(element);
        }

        for (String key : map.keySet()) {
            System.out.println(key + ": " + map.get(key));
        }
    }
}

字符串处理

Java的String类提供了多种字符串处理方法。

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String substring = str.substring(7, 12); // 获取子字符串
        boolean contains = str.contains("World");
        String upperCase = str.toUpperCase();
        String lowerCase = str.toLowerCase();
        String trim = str.trim();

        System.out.println("子字符串: " + substring);
        System.out.println("是否包含: " + contains);
        System.out.println("转为大写: " + upperCase);
        System.out.println("转为小写: " + lowerCase);
        System.out.println("去除空白符: " + trim);
    }
}

异常处理机制

Java的异常处理机制包括try、catch、finally和throw。

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("结果: " + result);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } finally {
            System.out.println("finally语句块");
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        return a / b;
    }
}

Web开发基础

Web开发主要包括客户端技术和服务器端技术。客户端技术主要涉及HTML、CSS、JavaScript等，服务器端技术主要涉及Java Web开发框架、数据库等。

Servlet和JSP简介

Servlet是运行在服务器上处理客户端请求的应用程序。JSP（JavaServer Pages）是一种动态网页技术，可以嵌入Java代码生成HTML页面。

Servlet

创建并部署一个简单的Servlet。

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<head>");
        out.println("<title>Hello World Servlet</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Hello, World!</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

部署Servlet到Tomcat服务器：

1. 在web.xml文件中配置Servlet：

<web-app>
    <servlet>
        <servlet-name>HelloWorldServlet</servlet-name>
        <servlet-class>com.example.servlet.HelloWorldServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloWorldServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

1. 启动Tomcat服务器，访问http://localhost:8080/yourapp/hello。

JSP

创建并部署一个简单的JSP页面。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello World JSP</title>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html>

部署JSP页面到Tomcat服务器：

1. 将JSP文件放置在webapps/yourapp/views目录下。
2. 启动Tomcat服务器，访问http://localhost:8080/yourapp/views/hello.jsp。

Spring框架入门

Spring是一个广泛使用的Java应用框架，提供了强大的依赖注入（DI）和面向切面编程（AOP）支持。

Spring核心配置

1. 创建一个Java项目并添加Spring依赖。
2. 创建一个核心配置文件applicationContext.xml。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="helloWorld" class="com.example.service.HelloWorldService">
        <property name="message" value="Hello, World!"/>
    </bean>
</beans>

1. 创建一个服务类HelloWorldService。

public class HelloWorldService {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

1. 创建一个控制器类HelloWorldController，使用Spring容器。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorldController {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorldService service = (HelloWorldService) context.getBean("helloWorld");
        System.out.println(service.getMessage());
    }
}

MyBatis框架入门

MyBatis是一个持久层框架，提供了灵活的SQL映射和强大的事务管理能力。

MyBatis核心配置

1. 创建一个Java项目并添加MyBatis依赖。
2. 创建一个核心配置文件mybatis-config.xml。

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

1. 创建一个SQL映射文件UserMapper.xml。

<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

1. 创建一个模型类User。

public class User {
    private int id;
    private String name;
    private String email;

    // getter和setter方法
}

1. 创建一个映射接口UserMapper。

public interface UserMapper {
    User getUserById(int id);
}

1. 创建一个主类Main，使用MyBatis的SqlSessionFactory。

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(resource));

        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.getUserById(1);
            System.out.println(user.getName());
        }
    }
}

RESTful API设计

RESTful API设计是一种流行的Web服务设计风格，使用HTTP协议进行操作。

创建RESTful API

1. 创建一个Java项目并添加Spring Boot依赖。
2. 创建一个主类Application。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

1. 创建一个控制器类UserController。

import org.springframework.web.bind.annotation.*;

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

@RestController
public class UserController {
    private static final Map<Integer, User> users = new HashMap<>();

    static {
        User user1 = new User(1, "张三", "张三@example.com");
        User user2 = new User(2, "李四", "李四@example.com");
        users.put(user1.getId(), user1);
        users.put(user2.getId(), user2);
    }

    @GetMapping("/users")
    public List<User> getUsers() {
        return new ArrayList<>(users.values());
    }

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable int id) {
        return users.get(id);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        users.put(user.getId(), user);
        return user;
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User user) {
        users.put(id, user);
        return user;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable int id) {
        users.remove(id);
    }
}

1. 运行Spring Boot应用，访问http://localhost:8080/users。

使用Tomcat部署Java Web应用

部署Java Web应用

1. 创建一个Java Web项目，包含web.xml、index.jsp等文件。
2. 将项目打包为WAR文件。
3. 将WAR文件放置在Tomcat服务器的webapps目录下。
4. 启动Tomcat服务器，访问http://localhost:8080/yourapp。

数据库基础与SQL语句

数据库是一种存储和管理数据的系统，SQL（Structured Query Language）是用于操作数据库的标准语言。

创建数据库

CREATE DATABASE mydb;

创建表

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE
);

插入数据

INSERT INTO users (name, email) VALUES ('张三', '张三@example.com');
INSERT INTO users (name, email) VALUES ('李四', '李四@example.com');

查询数据

SELECT * FROM users;

更新数据

UPDATE users SET email = '张三@newexample.com' WHERE id = 1;

删除数据

DELETE FROM users WHERE id = 1;

JDBC编程入门

JDBC（Java Database Connectivity）是Java连接数据库的标准API。

连接数据库

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class JDBCExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "password";

        try {
            Connection connection = DriverManager.getConnection(url, user, password);
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");

            while (resultSet.next()) {
                System.out.println("ID: " + resultSet.getInt("id"));
                System.out.println("Name: " + resultSet.getString("name"));
                System.out.println("Email: " + resultSet.getString("email"));
            }

            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

数据库连接池和事务处理

数据库连接池

数据库连接池可以管理和复用数据库连接，提高系统性能。

import javax.sql.*;
import java.sql.Connection;
import java.sql.SQLException;

public class ConnectionPoolExample {
    public static void main(String[] args) {
        try {
            DataSource dataSource = BasicDataSourceFactory.createDataSource(
                    "driverClassName=com.mysql.jdbc.Driver",
                    "url=jdbc:mysql://localhost:3306/mydb",
                    "username=root",
                    "password=password",
                    "maxConnections=10");
            Connection connection = dataSource.getConnection();
            // 使用连接
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

事务处理

事务处理确保数据库操作的原子性、一致性、隔离性和持久性（ACID）。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class TransactionExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "password";

        try {
            Connection connection = DriverManager.getConnection(url, user, password);
            connection.setAutoCommit(false); // 开启事务

            Statement statement = connection.createStatement();
            statement.executeUpdate("INSERT INTO users (name, email) VALUES ('王五', '王五@example.com')");
            statement.executeUpdate("INSERT INTO users (name, email) VALUES ('赵六', '赵六@example.com')");

            connection.commit(); // 提交事务
            connection.setAutoCommit(true); // 设置为自动提交

            System.out.println("事务提交成功");
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                Connection connection = DriverManager.getConnection(url, user, password);
                connection.rollback(); // 回滚事务
                connection.setAutoCommit(true);
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
    }
}

ORM框架Hibernate入门

ORM（Object-Relational Mapping）框架将对象映射到关系型数据库，减少SQL编写工作。

Hibernate核心配置

1. 创建一个Java项目并添加Hibernate依赖。
2. 创建一个核心配置文件hibernate.cfg.xml。

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <mapping class="com.example.model.User"/>
    </session-factory>
</hibernate-configuration>

1. 创建一个模型类User。

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "name")
    private String name;
    @Column(name = "email")
    private String email;

    // getter和setter方法
}

1. 创建一个主类Main，使用Hibernate的Session工厂。

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Main {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        User user = new User();
        user.setName("王五");
        user.setEmail("王五@example.com");
        session.save(user);

        session.getTransaction().commit();
        session.close();
        sessionFactory.close();
    }
}

面向对象高级特性

面向对象编程的高级特性包括封装、继承、多态和抽象等。

封装

封装是将数据和操作数据的方法封装起来，通过访问修饰符限制成员的访问。

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 void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

继承

继承是类之间的一种关系，一个类可以继承另一个类的属性和方法。

public class Student extends Person {
    private String school;

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

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public void displayInfo() {
        super.displayInfo();
        System.out.println("学校: " + school);
    }
}

多态

多态是指对象可以具有多种形式，通过父类引用指向子类对象。

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 25);
        Student student = new Student("李四", 20, "清华大学");

        person.displayInfo(); // 输出 "姓名: 张三, 年龄: 25"
        student.displayInfo(); // 输出 "姓名: 李四, 年龄: 20, 学校: 清华大学"
    }
}

抽象

抽象类和接口提供了抽象方法，强制子类实现这些方法。

public abstract class AbstractClass {
    public abstract void display();

    public void commonMethod() {
        System.out.println("这是一个普通方法");
    }
}

public interface MyInterface {
    void display();
}

public class ConcreteClass extends AbstractClass implements MyInterface {
    @Override
    public void display() {
        System.out.println("这是一个抽象方法");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractClass abstractClass = new ConcreteClass();
        abstractClass.display(); // 输出 "这是一个抽象方法"
        abstractClass.commonMethod(); // 输出 "这是一个普通方法"
    }
}

设计模式基础

设计模式是一套解决常见问题的规范，常用的有Singleton、Factory、Observer等。

Singleton模式

Singleton模式确保一个类只有一个实例，并提供一个全局访问点。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Factory模式

Factory模式创建对象的方式由工厂类决定，降低了系统间的依赖。

public interface Product {}

public class ConcreteProduct implements Product {}

public class ProductFactory {
    public static Product createProduct() {
        return new ConcreteProduct();
    }
}

public class Main {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct();
    }
}

Observer模式

Observer模式定义对象之间的一对多依赖关系，当一个对象的状态改变时，所有依赖它的对象都会收到通知。

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

public interface Observer {
    void update();
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name + " 收到通知");
    }
}

public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();
        subject.addObserver(new ConcreteObserver("观察者1"));
        subject.addObserver(new ConcreteObserver("观察者2"));

        subject.notifyObservers(); // 输出 "观察者1 收到通知" 和 "观察者2 收到通知"
    }
}

并发编程基础

并发编程处理多线程和多任务的执行，提高程序效率。

线程创建

通过继承Thread类或实现Runnable接口创建线程。

public class ThreadExample extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程1: " + i);
        }
    }
}

public class RunnableExample implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程2: " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadExample threadExample = new ThreadExample();
        threadExample.start();

        Thread thread = new Thread(new RunnableExample());
        thread.start();
    }
}

同步与互斥

通过synchronized关键字实现线程同步和互斥访问。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("计数器值: " + counter.count); // 输出计数器值
    }
}

守护线程与线程池

守护线程在所有非守护线程都结束时自动退出，线程池管理线程的创建、销毁和复用。

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        daemonThread.setDaemon(true);
        daemonThread.start();

        System.out.println("主线程结束"); // 主线程结束时，守护线程也结束
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int taskNum = i;
            executorService.submit(() -> {
                System.out.println("任务 " + taskNum + " 正在执行");
            });
        }

        executorService.shutdown();
    }
}

Java虚拟机(JVM)概述

Java虚拟机（JVM, Java Virtual Machine）是Java运行环境的核心组件，负责解释和运行Java字节码。

JVM内存模型

JVM内存分为堆、栈、方法区、程序计数器和本地方法栈。

1. 堆：存储对象实例。
2. 栈：存储局部变量和方法调用记录。
3. 方法区：存储类信息、常量和静态变量。
4. 程序计数器：当前执行的字节码行号。
5. 本地方法栈：为本地方法服务。

JVM垃圾回收

垃圾回收机制自动管理内存释放和垃圾回收。

JVM调优

通过JVM参数调整内存大小、垃圾回收策略等。

java -Xms512m -Xmx1024m -XX:MaxPermSize=256m -XX:+UseG1GC Main

项目选型与项目搭建

选型

选择适合的框架和技术栈，如Spring Boot、Spring MVC、MyBatis等。

搭建环境

安装Java环境、IDE和构建工具（Maven或Gradle）。

1. 创建一个Java项目并添加相关依赖。
2. 配置Maven或Gradle文件。
3. 创建项目结构，如src/main/java、src/main/resources等。

初始化代码

编写初始化代码，如配置文件、常量定义等。

<!-- pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>yourapp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
    </dependencies>
</project>

开发流程与常见工具介绍

开发流程

1. 需求分析。
2. 设计数据库和表结构。
3. 编写核心业务逻辑。
4. 编写测试代码。
5. 部署到服务器。

常见工具

• IDE：IntelliJ IDEA、Eclipse、Visual Studio Code。
• 版本控制：Git。
• 构建工具：Maven、Gradle。
• 调试工具：JDB、IDE自带调试工具。
• 单元测试：JUnit。
• 性能分析：JProfiler、VisualVM。
• 数据库管理：MySQL Workbench、Navicat。

实践项目案例解析与代码解析

案例：在线考试系统

设计一个在线考试系统，包含试题管理、考试管理、成绩管理等功能。

项目结构

项目结构如下：

src/main/java
|-- com/example/controller
|-- com/example/service
|-- com/example/repository
|-- com/example/model
|-- Application.java
|-- config.properties
src/main/resources
|-- application.properties

主类

主类启动Spring Boot应用。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Controller

控制器处理HTTP请求。

import org.springframework.web.bind.annotation.*;

@RestController
public class ExamController {
    @Autowired
    private ExamService examService;

    @GetMapping("/exams")
    public List<Exam> getExams() {
        return examService.getExams();
    }

    @PostMapping("/exams")
    public Exam createExam(@RequestBody Exam exam) {
        return examService.createExam(exam);
    }

    @GetMapping("/exams/{id}")
    public Exam getExam(@PathVariable int id) {
        return examService.getExam(id);
    }

    @PutMapping("/exams/{id}")
    public Exam updateExam(@PathVariable int id, @RequestBody Exam exam) {
        return examService.updateExam(id, exam);
    }

    @DeleteMapping("/exams/{id}")
    public void deleteExam(@PathVariable int id) {
        examService.deleteExam(id);
    }
}

Service

服务类处理核心业务逻辑。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ExamService {
    @Autowired
    private ExamRepository examRepository;

    public List<Exam> getExams() {
        return examRepository.findAll();
    }

    public Exam createExam(Exam exam) {
        return examRepository.save(exam);
    }

    public Exam getExam(int id) {
        return examRepository.findById(id).orElse(null);
    }

    public Exam updateExam(int id, Exam exam) {
        Exam existingExam = examRepository.findById(id).orElse(null);
        if (existingExam != null) {
            existingExam.setTitle(exam.getTitle());
            existingExam.setDescription(exam.getDescription());
            return examRepository.save(existingExam);
        }
        return null;
    }

    public void deleteExam(int id) {
        examRepository.deleteById(id);
    }
}

Repository

仓库层与数据库交互。

import org.springframework.data.jpa.repository.JpaRepository;

public interface ExamRepository extends JpaRepository<Exam, Integer> {
}

Model

定义模型类。

import javax.persistence.*;

@Entity
@Table(name = "exams")
public class Exam {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String title;
    private String description;

    // getter和setter方法
}

配置文件

配置文件设置数据库连接信息。

spring.datasource.url=jdbc:mysql://localhost:3306/examdb
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

运行项目

运行主类，启动Spring Boot应用。

mvn spring-boot:run

访问http://localhost:8080/exams查看考试列表。

通过以上步骤，可以构建一个简单的在线考试系统，涵盖基本的CRUD操作。