Java面向对象编程进阶与AI应用实践

引言

在上一篇教程中，我们学习了Java的基础语法，包括数据类型、控制流语句、数组、集合以及面向对象编程的基本概念。从零基础学习Java，深入理解面向对象编程是提升编程能力的关键一步。2025年，Java与AI的结合已经不再局限于简单的应用，而是深入到了编程范式中。本教程将带你学习Java面向对象编程的进阶知识，并通过AI应用实践，帮助你巩固所学并掌握实用技能。

目录

1. 抽象类与接口

1.1 抽象类

抽象类是不能被实例化的类，它可以包含抽象方法（没有方法体的方法）和普通方法：

// 抽象类的定义
public abstract class AbstractShape {
    // 抽象方法（没有方法体）
    public abstract double calculateArea();
    
    // 普通方法（有方法体）
    public void display() {
        System.out.println("Area: " + calculateArea());
    }
}

// 具体子类实现抽象方法
public class Circle extends AbstractShape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// 使用抽象类
AbstractShape shape = new Circle(5.0);
shape.display();  // 输出：Area: 78.53981633974483

1.2 接口

接口定义了一组方法规范，但不提供任何实现（Java 8以后可以有默认实现和静态方法）：

// 接口定义
public interface Drawable {
    // 抽象方法
    void draw();
    
    // Java 8+ 默认方法
    default void setup() {
        System.out.println("Setting up for drawing...");
    }
    
    // Java 8+ 静态方法
    static void prepareCanvas() {
        System.out.println("Preparing canvas...");
    }
}

// 实现接口
public class Rectangle implements Drawable {
    private double width;
    private double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle with width " + width + " and height " + height);
    }
}

// 使用接口
Drawable.prepareCanvas();  // 调用静态方法
Drawable rectangle = new Rectangle(4.0, 6.0);
rectangle.setup();  // 调用默认方法
rectangle.draw();  // 调用实现的方法

1.3 抽象类与接口的区别

2. 内部类与匿名类

2.1 内部类

内部类是定义在另一个类内部的类，它可以访问外部类的成员变量和方法：

// 外部类
public class OuterClass {
    private int outerVar = 10;
    
    // 内部类
    public class InnerClass {
        private int innerVar = 20;
        
        public void display() {
            System.out.println("Outer variable: " + outerVar);
            System.out.println("Inner variable: " + innerVar);
        }
    }
    
    // 外部类方法
    public void createInner() {
        InnerClass inner = new InnerClass();
        inner.display();
    }
}

// 使用内部类
OuterClass outer = new OuterClass();
outer.createInner();

// 直接创建内部类实例
OuterClass.InnerClass inner = outer.new InnerClass();
inner.display();

2.2 静态内部类

静态内部类使用static修饰，它不依赖于外部类的实例：

public class OuterClass {
    private static int staticOuterVar = 30;
    private int instanceVar = 40;
    
    // 静态内部类
    public static class StaticInnerClass {
        private int innerVar = 50;
        
        public void display() {
            System.out.println("Static outer variable: " + staticOuterVar);
            // 无法访问instanceVar，因为它是实例变量
            System.out.println("Inner variable: " + innerVar);
        }
    }
}

// 使用静态内部类（不需要先创建外部类实例）
OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
staticInner.display();

2.3 匿名类

匿名类是没有名字的内部类，通常用于实现接口或扩展类的一次性使用场景：

// 定义接口
interface Greeting {
    void greet();
}

// 使用匿名类实现接口
Greeting greeting = new Greeting() {
    @Override
    public void greet() {
        System.out.println("Hello from anonymous class!");
    }
};

greeting.greet();

// 匿名类作为方法参数
public void processGreeting(Greeting greeting) {
    greeting.greet();
}

// 调用方法时使用匿名类
processGreeting(new Greeting() {
    @Override
    public void greet() {
        System.out.println("Hello as method parameter!");
    }
});

3. 泛型编程

3.1 泛型的基本概念

泛型允许在定义类、接口和方法时使用类型参数，提高代码的重用性和类型安全性：

// 泛型类定义
public class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// 使用泛型类
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello, Generics!");
String content = stringBox.getContent();

Box<Integer> intBox = new Box<>();
intBox.setContent(100);
Integer number = intBox.getContent();

3.2 泛型方法

泛型方法是在方法中使用泛型参数的方法，可以在普通类或泛型类中定义：

// 泛型方法示例
public class GenericMethodExample {
    // 泛型方法
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    
    // 有返回值的泛型方法
    public static <T> T getFirstElement(T[] array) {
        if (array != null && array.length > 0) {
            return array[0];
        }
        return null;
    }
}

// 使用泛型方法
Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"Hello", "World", "Generics"};

GenericMethodExample.printArray(intArray);
GenericMethodExample.printArray(stringArray);

Integer firstInt = GenericMethodExample.getFirstElement(intArray);
String firstString = GenericMethodExample.getFirstElement(stringArray);

3.3 泛型边界

泛型边界用于限制类型参数的范围：

// 上界通配符：? extends T（只能读取，不能写入）
public static double sumOfList(List<? extends Number> list) {
    double sum = 0.0;
    for (Number n : list) {
        sum += n.doubleValue();
    }
    return sum;
}

// 下界通配符：? super T（只能写入，读取时为Object类型）
public static void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) {
        list.add(i);
    }
}

// 使用泛型边界
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.5, 2.5, 3.5);

double intSum = sumOfList(integers);
double doubleSum = sumOfList(doubles);

List<Number> numbers = new ArrayList<>();
addNumbers(numbers);

4. 异常处理机制

4.1 异常的分类

Java中的异常分为两大类：

• CheckedException（受检异常）：编译时检查的异常，必须显式处理
• UncheckedException（非受检异常）：运行时异常，不需要显式处理

Java异常体系结构的主要类：

• Throwable：所有异常和错误的父类

• Error：代表严重错误，程序一般无法恢复
• Exception：代表可能恢复的异常情况

• RuntimeException：非受检异常
• 其他Exception子类：受检异常

4.2 异常的处理

Java提供了try-catch-finally和throws关键字来处理异常：

// try-catch-finally处理异常
public void readFile(String filePath) {
    FileInputStream file = null;
    try {
        file = new FileInputStream(filePath);
        // 读取文件内容
    } catch (FileNotFoundException e) {
        System.out.println("文件未找到：" + filePath);
        e.printStackTrace();
    } catch (IOException e) {
        System.out.println("读取文件时出错");
        e.printStackTrace();
    } finally {
        // 无论是否发生异常，finally块都会执行
        try {
            if (file != null) {
                file.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 使用throws声明方法可能抛出的异常
public void readFileWithThrows(String filePath) throws FileNotFoundException, IOException {
    FileInputStream file = new FileInputStream(filePath);
    // 读取文件内容
    file.close();
}

// 调用带throws的方法
public void process() {
    try {
        readFileWithThrows("example.txt");
    } catch (FileNotFoundException e) {
        System.out.println("文件未找到");
    } catch (IOException e) {
        System.out.println("IO异常");
    }
}

4.3 Java 7的try-with-resources语句

Java 7引入了try-with-resources语句，可以自动关闭实现了AutoCloseable接口的资源：

// try-with-resources语句
public void readFileWithResources(String filePath) {
    try (FileInputStream file = new FileInputStream(filePath)) {
        // 读取文件内容
    } catch (FileNotFoundException e) {
        System.out.println("文件未找到：" + filePath);
    } catch (IOException e) {
        System.out.println("读取文件时出错");
    }
    // 不需要finally块来关闭资源，try-with-resources会自动关闭
}

4.4 自定义异常

可以通过继承Exception类或RuntimeException类来创建自定义异常：

// 自定义受检异常
public class InsufficientFundsException extends Exception {
    private double amount;
    
    public InsufficientFundsException(double amount) {
        this.amount = amount;
    }
    
    public double getAmount() {
        return amount;
    }
}

// 自定义非受检异常
public class InvalidDataException extends RuntimeException {
    public InvalidDataException(String message) {
        super(message);
    }
}

// 使用自定义异常
public class Account {
    private double balance;
    
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException(amount - balance);
        }
        balance -= amount;
    }
    
    public void setData(String data) {
        if (data == null || data.isEmpty()) {
            throw new InvalidDataException("数据不能为空");
        }
        // 处理数据
    }
}

5. Java 8+ 函数式编程特性

5.1 Lambda表达式

Lambda表达式是Java 8引入的一种新的语法，允许将函数作为参数传递：

// 使用匿名类
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in a thread");
    }
};

// 使用Lambda表达式
Runnable runnable2 = () -> System.out.println("Running with Lambda");

// Lambda表达式与集合
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// 排序（匿名类方式）
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

// 排序（Lambda表达式方式）
Collections.sort(names, (s1, s2) -> s1.compareTo(s2));

// 甚至更简洁
names.sort((s1, s2) -> s1.compareTo(s2));

// 方法引用
names.sort(String::compareTo);

// 遍历集合（Lambda表达式）
names.forEach(name -> System.out.println(name));

// 方法引用
names.forEach(System.out::println);

5.2 函数式接口

函数式接口是只包含一个抽象方法的接口，可以使用@FunctionalInterface注解标记：

// 自定义函数式接口
@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

// 使用Lambda表达式实现函数式接口
Calculator addition = (a, b) -> a + b;
Calculator subtraction = (a, b) -> a - b;
Calculator multiplication = (a, b) -> a * b;
Calculator division = (a, b) -> a / b;

// 调用接口方法
int sum = addition.calculate(5, 3);
int difference = subtraction.calculate(5, 3);

5.3 Java 8内置函数式接口

Java 8提供了一些常用的函数式接口，位于java.util.function包中：

使用示例：

// Predicate示例
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 过滤偶数
List<Integer> evenNumbers = numbers.stream()
                                  .filter(n -> n % 2 == 0)
                                  .collect(Collectors.toList());

// Function示例
List<String> numberStrings = numbers.stream()
                                   .map(n -> "Number: " + n)
                                   .collect(Collectors.toList());

// Consumer示例
numbers.forEach(n -> System.out.println(n));

// Supplier示例
Supplier<Double> randomValue = () -> Math.random();
Double value = randomValue.get();

6. 使用AI助手进行面向对象设计

2025年，AI助手已经成为Java面向对象设计的得力助手。通过AI助手，你可以获得设计模式建议、代码优化和重构指导等。

6.1 使用AI助手进行类设计

IntelliJ IDEA的AI助手可以帮助你：

• 根据需求分析生成类图和类结构
• 提供设计模式应用建议
• 优化类的继承关系和接口设计
• 识别潜在的设计问题

6.2 AI助手在代码重构中的应用

AI助手可以帮助你进行以下重构操作：

• 提取方法：将重复代码提取为独立的方法
• 提取接口：从类中提取公共接口
• 移动方法/字段：优化类的职责分配
• 重命名：改进命名以提高代码可读性
• 封装字段：自动生成getter和setter方法

6.3 实践：使用AI助手设计图书管理系统

1. 在IntelliJ IDEA中创建一个新的Java项目
2. 向AI助手描述你想要创建的图书管理系统的需求
3. 请求AI助手提供类图和类结构建议
4. 根据AI助手的建议，实现图书管理系统的基本框架
5. 请求AI助手检查代码并提供优化建议
6. 根据AI助手的建议，改进和完善你的设计

7. 实战项目：AI辅助的图书管理系统

现在，让我们结合所学的Java面向对象编程进阶知识，创建一个AI辅助的图书管理系统。

7.1 项目概述

这个图书管理系统将实现以下功能：

1. 添加图书
2. 查找图书
3. 借阅图书
4. 归还图书
5. 显示所有图书
6. 使用AI助手生成图书推荐

7.2 系统设计

我们将使用以下类和接口来设计这个系统：

• Book：图书类，包含图书的基本信息
• User：用户类，包含用户的基本信息
• Library：图书馆类，管理图书和用户
• LibraryService：图书馆服务接口，定义系统的核心功能
• DefaultLibraryService：实现LibraryService接口
• AILibraryAssistant：AI图书馆助手类，提供图书推荐功能
• LibraryManagementSystem：系统入口类

7.3 代码实现

首先，我们定义Book类：

public class Book {
    private String id;
    private String title;
    private String author;
    private String category;
    private boolean isAvailable;
    
    public Book(String id, String title, String author, String category) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.category = category;
        this.isAvailable = true;
    }
    
    // Getters and setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    
    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }
    
    public String getCategory() { return category; }
    public void setCategory(String category) { this.category = category; }
    
    public boolean isAvailable() { return isAvailable; }
    public void setAvailable(boolean available) { isAvailable = available; }
    
    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ", title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", category='" + category + '\'' +
                ", available=" + isAvailable +
                '}';
    }
}

接下来，定义User类：

public class User {
    private String id;
    private String name;
    private List<Book> borrowedBooks;
    
    public User(String id, String name) {
        this.id = id;
        this.name = name;
        this.borrowedBooks = new ArrayList<>();
    }
    
    // Getters and setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public List<Book> getBorrowedBooks() { return borrowedBooks; }
    
    public void borrowBook(Book book) {
        if (book.isAvailable()) {
            borrowedBooks.add(book);
            book.setAvailable(false);
        }
    }
    
    public boolean returnBook(Book book) {
        if (borrowedBooks.contains(book)) {
            borrowedBooks.remove(book);
            book.setAvailable(true);
            return true;
        }
        return false;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", borrowedBooksCount=" + borrowedBooks.size() +
                '}';
    }
}

然后，定义LibraryService接口：

public interface LibraryService {
    void addBook(Book book);
    Book findBookById(String id);
    List<Book> findBooksByTitle(String title);
    List<Book> findBooksByAuthor(String author);
    boolean borrowBook(String userId, String bookId);
    boolean returnBook(String userId, String bookId);
    List<Book> getAllBooks();
    List<User> getAllUsers();
    void addUser(User user);
    User findUserById(String id);
}

接下来，实现Library类：

public class Library {
    private List<Book> books;
    private List<User> users;
    
    public Library() {
        this.books = new ArrayList<>();
        this.users = new ArrayList<>();
    }
    
    // Getters
    public List<Book> getBooks() { return books; }
    public List<User> getUsers() { return users; }
    
    // Methods to manage books
    public void addBook(Book book) {
        books.add(book);
    }
    
    public Book findBookById(String id) {
        for (Book book : books) {
            if (book.getId().equals(id)) {
                return book;
            }
        }
        return null;
    }
    
    public List<Book> findBooksByTitle(String title) {
        List<Book> result = new ArrayList<>();
        for (Book book : books) {
            if (book.getTitle().toLowerCase().contains(title.toLowerCase())) {
                result.add(book);
            }
        }
        return result;
    }
    
    public List<Book> findBooksByAuthor(String author) {
        List<Book> result = new ArrayList<>();
        for (Book book : books) {
            if (book.getAuthor().toLowerCase().contains(author.toLowerCase())) {
                result.add(book);
            }
        }
        return result;
    }
    
    // Methods to manage users
    public void addUser(User user) {
        users.add(user);
    }
    
    public User findUserById(String id) {
        for (User user : users) {
            if (user.getId().equals(id)) {
                return user;
            }
        }
        return null;
    }
}

然后，实现DefaultLibraryService类：

public class DefaultLibraryService implements LibraryService {
    private Library library;
    
    public DefaultLibraryService(Library library) {
        this.library = library;
    }
    
    @Override
    public void addBook(Book book) {
        library.addBook(book);
    }
    
    @Override
    public Book findBookById(String id) {
        return library.findBookById(id);
    }
    
    @Override
    public List<Book> findBooksByTitle(String title) {
        return library.findBooksByTitle(title);
    }
    
    @Override
    public List<Book> findBooksByAuthor(String author) {
        return library.findBooksByAuthor(author);
    }
    
    @Override
    public boolean borrowBook(String userId, String bookId) {
        User user = library.findUserById(userId);
        Book book = library.findBookById(bookId);
        
        if (user != null && book != null && book.isAvailable()) {
            user.borrowBook(book);
            return true;
        }
        return false;
    }
    
    @Override
    public boolean returnBook(String userId, String bookId) {
        User user = library.findUserById(userId);
        Book book = library.findBookById(bookId);
        
        if (user != null && book != null) {
            return user.returnBook(book);
        }
        return false;
    }
    
    @Override
    public List<Book> getAllBooks() {
        return library.getBooks();
    }
    
    @Override
    public List<User> getAllUsers() {
        return library.getUsers();
    }
    
    @Override
    public void addUser(User user) {
        library.addUser(user);
    }
    
    @Override
    public User findUserById(String id) {
        return library.findUserById(id);
    }
}

接下来，实现AILibraryAssistant类：

public class AILibraryAssistant {
    private LibraryService libraryService;
    
    public AILibraryAssistant(LibraryService libraryService) {
        this.libraryService = libraryService;
    }
    
    /**
     * 根据用户的借阅历史推荐图书
     * @param userId 用户ID
     * @return 推荐的图书列表
     */
    public List<Book> recommendBooks(String userId) {
        User user = libraryService.findUserById(userId);
        if (user == null) {
            return new ArrayList<>();
        }
        
        // 获取用户的借阅历史
        List<Book> borrowedBooks = user.getBorrowedBooks();
        if (borrowedBooks.isEmpty()) {
            // 如果用户没有借阅历史，推荐热门图书
            return getPopularBooks();
        }
        
        // 分析用户喜欢的图书类别
        Map<String, Integer> categoryCount = new HashMap<>();
        for (Book book : borrowedBooks) {
            String category = book.getCategory();
            categoryCount.put(category, categoryCount.getOrDefault(category, 0) + 1);
        }
        
        // 找出用户最喜欢的类别
        String favoriteCategory = Collections.max(categoryCount.entrySet(), Map.Entry.comparingByValue()).getKey();
        
        // 推荐该类别中用户未借阅过的图书
        List<Book> recommendedBooks = new ArrayList<>();
        List<Book> allBooks = libraryService.getAllBooks();
        
        for (Book book : allBooks) {
            if (book.getCategory().equals(favoriteCategory) && book.isAvailable() && 
                !borrowedBooks.contains(book)) {
                recommendedBooks.add(book);
                // 只推荐5本图书
                if (recommendedBooks.size() >= 5) {
                    break;
                }
            }
        }
        
        return recommendedBooks;
    }
    
    /**
     * 获取热门图书
     * @return 热门图书列表
     */
    private List<Book> getPopularBooks() {
        // 在实际应用中，这可能基于借阅次数、评分等
        // 这里简单返回前5本可用的图书
        List<Book> popularBooks = new ArrayList<>();
        List<Book> allBooks = libraryService.getAllBooks();
        
        for (Book book : allBooks) {
            if (book.isAvailable()) {
                popularBooks.add(book);
                if (popularBooks.size() >= 5) {
                    break;
                }
            }
        }
        
        return popularBooks;
    }
    
    /**
     * 使用AI生成图书摘要
     * @param book 图书对象
     * @return 图书摘要
     */
    public String generateBookSummary(Book book) {
        // 在实际应用中，这里可能会调用真正的AI API
        // 这里使用简单的模板生成摘要
        return "《" + book.getTitle() + "》是" + book.getAuthor() + "创作的一部" + 
               book.getCategory() + "作品。这本书主要讲述了...（AI生成的详细摘要）";
    }
}

最后，实现LibraryManagementSystem类作为系统入口：

public class LibraryManagementSystem {
    private static Scanner scanner = new Scanner(System.in);
    
    public static void main(String[] args) {
        // 初始化系统
        Library library = new Library();
        LibraryService libraryService = new DefaultLibraryService(library);
        AILibraryAssistant aiAssistant = new AILibraryAssistant(libraryService);
        
        // 添加一些初始数据
        initializeData(libraryService);
        
        boolean exit = false;
        
        while (!exit) {
            // 显示菜单
            System.out.println("\n===== AI辅助图书管理系统 =====");
            System.out.println("1. 添加图书");
            System.out.println("2. 查找图书");
            System.out.println("3. 借阅图书");
            System.out.println("4. 归还图书");
            System.out.println("5. 显示所有图书");
            System.out.println("6. 添加用户");
            System.out.println("7. 显示所有用户");
            System.out.println("8. AI图书推荐");
            System.out.println("9. 生成图书摘要");
            System.out.println(0 + ". 退出");
            System.out.print("请选择操作：");
            
            // 获取用户输入
            int choice = scanner.nextInt();
            scanner.nextLine();  // 消费换行符
            
            // 根据用户选择执行相应操作
            switch (choice) {
                case 1:
                    addBook(libraryService);
                    break;
                case 2:
                    findBook(libraryService);
                    break;
                case 3:
                    borrowBook(libraryService);
                    break;
                case 4:
                    returnBook(libraryService);
                    break;
                case 5:
                    displayAllBooks(libraryService);
                    break;
                case 6:
                    addUser(libraryService);
                    break;
                case 7:
                    displayAllUsers(libraryService);
                    break;
                case 8:
                    recommendBooks(aiAssistant);
                    break;
                case 9:
                    generateBookSummary(aiAssistant, libraryService);
                    break;
                case 0:
                    exit = true;
                    System.out.println("感谢使用AI辅助图书管理系统！");
                    break;
                default:
                    System.out.println("无效的选择，请重新输入！");
            }
        }
        
        scanner.close();
    }
    
    // 初始化数据
    private static void initializeData(LibraryService libraryService) {
        // 添加一些图书
        libraryService.addBook(new Book("B001", "Java编程思想", "Bruce Eckel", "计算机科学"));
        libraryService.addBook(new Book("B002", "深入理解Java虚拟机", "周志明", "计算机科学"));
        libraryService.addBook(new Book("B003", "算法导论", "Thomas H. Cormen", "计算机科学"));
        libraryService.addBook(new Book("B004", "人工智能：现代方法", "Stuart Russell", "人工智能"));
        libraryService.addBook(new Book("B005", "机器学习实战", "Peter Harrington", "人工智能"));
        
        // 添加一些用户
        libraryService.addUser(new User("U001", "张三"));
        libraryService.addUser(new User("U002", "李四"));
    }
    
    // 添加图书
    private static void addBook(LibraryService libraryService) {
        System.out.print("请输入图书ID：");
        String id = scanner.nextLine();
        
        System.out.print("请输入图书标题：");
        String title = scanner.nextLine();
        
        System.out.print("请输入图书作者：");
        String author = scanner.nextLine();
        
        System.out.print("请输入图书类别：");
        String category = scanner.nextLine();
        
        Book book = new Book(id, title, author, category);
        libraryService.addBook(book);
        
        System.out.println("图书添加成功！");
    }
    
    // 查找图书
    private static void findBook(LibraryService libraryService) {
        System.out.println("1. 按ID查找");
        System.out.println("2. 按标题查找");
        System.out.println("3. 按作者查找");
        System.out.print("请选择查找方式：");
        
        int searchType = scanner.nextInt();
        scanner.nextLine();  // 消费换行符
        
        switch (searchType) {
            case 1:
                System.out.print("请输入图书ID：");
                String id = scanner.nextLine();
                Book book = libraryService.findBookById(id);
                if (book != null) {
                    System.out.println("找到图书：" + book);
                } else {
                    System.out.println("未找到该图书！");
                }
                break;
            case 2:
                System.out.print("请输入图书标题：");
                String title = scanner.nextLine();
                List<Book> booksByTitle = libraryService.findBooksByTitle(title);
                if (!booksByTitle.isEmpty()) {
                    System.out.println("找到以下图书：");
                    for (Book b : booksByTitle) {
                        System.out.println(b);
                    }
                } else {
                    System.out.println("未找到相关图书！");
                }
                break;
            case 3:
                System.out.print("请输入图书作者：");
                String author = scanner.nextLine();
                List<Book> booksByAuthor = libraryService.findBooksByAuthor(author);
                if (!booksByAuthor.isEmpty()) {
                    System.out.println("找到以下图书：");
                    for (Book b : booksByAuthor) {
                        System.out.println(b);
                    }
                } else {
                    System.out.println("未找到相关图书！");
                }
                break;
            default:
                System.out.println("无效的选择！");
        }
    }
    
    // 借阅图书
    private static void borrowBook(LibraryService libraryService) {
        System.out.print("请输入用户ID：");
        String userId = scanner.nextLine();
        
        System.out.print("请输入图书ID：");
        String bookId = scanner.nextLine();
        
        if (libraryService.borrowBook(userId, bookId)) {
            System.out.println("图书借阅成功！");
        } else {
            System.out.println("图书借阅失败！用户不存在或图书不可用。");
        }
    }
    
    // 归还图书
    private static void returnBook(LibraryService libraryService) {
        System.out.print("请输入用户ID：");
        String userId = scanner.nextLine();
        
        System.out.print("请输入图书ID：");
        String bookId = scanner.nextLine();
        
        if (libraryService.returnBook(userId, bookId)) {
            System.out.println("图书归还成功！");
        } else {
            System.out.println("图书归还失败！用户不存在或该用户未借阅此图书。");
        }
    }
    
    // 显示所有图书
    private static void displayAllBooks(LibraryService libraryService) {
        List<Book> books = libraryService.getAllBooks();
        if (books.isEmpty()) {
            System.out.println("暂无图书信息！");
        } else {
            System.out.println("\n===== 图书列表 =====");
            for (Book book : books) {
                System.out.println(book);
            }
        }
    }
    
    // 添加用户
    private static void addUser(LibraryService libraryService) {
        System.out.print("请输入用户ID：");
        String id = scanner.nextLine();
        
        System.out.print("请输入用户姓名：");
        String name = scanner.nextLine();
        
        User user = new User(id, name);
        libraryService.addUser(user);
        
        System.out.println("用户添加成功！");
    }
    
    // 显示所有用户
    private static void displayAllUsers(LibraryService libraryService) {
        List<User> users = libraryService.getAllUsers();
        if (users.isEmpty()) {
            System.out.println("暂无用户信息！");
        } else {
            System.out.println("\n===== 用户列表 =====");
            for (User user : users) {
                System.out.println(user);
            }
        }
    }
    
    // AI图书推荐
    private static void recommendBooks(AILibraryAssistant aiAssistant) {
        System.out.print("请输入用户ID：");
        String userId = scanner.nextLine();
        
        List<Book> recommendedBooks = aiAssistant.recommendBooks(userId);
        if (recommendedBooks.isEmpty()) {
            System.out.println("无法生成推荐！");
        } else {
            System.out.println("\n===== AI推荐图书 =====");
            for (Book book : recommendedBooks) {
                System.out.println(book);
            }
        }
    }
    
    // 生成图书摘要
    private static void generateBookSummary(AILibraryAssistant aiAssistant, LibraryService libraryService) {
        System.out.print("请输入图书ID：");
        String bookId = scanner.nextLine();
        
        Book book = libraryService.findBookById(bookId);
        if (book != null) {
            String summary = aiAssistant.generateBookSummary(book);
            System.out.println("\n===== AI生成的图书摘要 =====");
            System.out.println(summary);
        } else {
            System.out.println("未找到该图书！");
        }
    }
}

8. AI技术在Java面向对象编程中的应用趋势

2025年，AI技术在Java面向对象编程中的应用已经非常广泛，主要体现在以下几个方面：

8.1 代码生成与补全

AI助手可以根据开发者的意图和上下文，自动生成代码片段，提供智能代码补全，大大提高开发效率。

8.2 代码优化与重构

AI助手可以分析代码结构，识别潜在的性能问题和设计缺陷，并提供重构建议，帮助开发者编写更高效、更易维护的代码。

8.3 设计模式应用

AI助手可以根据项目需求，推荐合适的设计模式，并提供实现指导，帮助开发者应用最佳实践。

8.4 智能文档生成

AI助手可以自动生成代码注释和API文档，根据代码功能生成清晰、准确的文档，提高代码可读性。

8.5 自动化测试

AI助手可以自动生成测试用例，执行测试并分析测试结果，帮助开发者发现和修复代码中的问题。

8.6 预测性编程

AI助手可以分析开发者的编程习惯和项目需求，预测下一步可能需要编写的代码，并提供建议，实现预测性编程。

结论

通过本教程，你已经学习了Java面向对象编程的进阶知识，包括抽象类、接口、内部类、泛型、异常处理和函数式编程特性等。同时，你还通过实战项目，了解了如何将这些知识应用到实际开发中，并结合AI技术增强应用功能。

Java面向对象编程是Java开发的核心，掌握这些进阶知识将帮助你设计和开发更复杂、更灵活的应用程序。2025年，AI技术与Java的结合已经成为趋势，掌握AI辅助编程的技能将使你在竞争中脱颖而出。

在下一篇教程中，我们将学习Java的IO操作和网络编程，进一步扩展你的Java技能，并继续探索AI与Java的结合应用。

参考