未记录事实核验 · 状态：维护中

记录仅说明核验时间与维护状态，不保证适用于所有环境；使用前请留意正文中的版本、适用条件与风险提示。

Java面向对象编程 - 数据开发中的OOP应用

🏗️ 类与对象基础

📋 什么是类和对象？

/**
 * 数据记录类 - 相当于数据表的结构定义
 */
public class DataRecord {
    // 成员变量（属性）- 相当于数据表的字段
    private String recordId;      // 记录ID
    private String source;        // 数据源
    private long timestamp;       // 时间戳
    private double value;         // 数值
    private String status;        // 状态
    
    // 构造方法 - 创建对象时初始化数据
    public DataRecord() {
        // 默认构造方法
        this.recordId = "";
        this.source = "unknown";
        this.timestamp = System.currentTimeMillis();
        this.value = 0.0;
        this.status = "NEW";
    }
    
    // 带参数的构造方法
    public DataRecord(String recordId, String source, double value) {
        this.recordId = recordId;
        this.source = source;
        this.value = value;
        this.timestamp = System.currentTimeMillis();
        this.status = "CREATED";
    }
    
    // 全参数构造方法
    public DataRecord(String recordId, String source, long timestamp, 
                     double value, String status) {
        this.recordId = recordId;
        this.source = source;
        this.timestamp = timestamp;
        this.value = value;
        this.status = status;
    }
    
    // 成员方法 - 相当于对数据的操作
    public void updateValue(double newValue) {
        this.value = newValue;
        this.timestamp = System.currentTimeMillis();
        this.status = "UPDATED";
        System.out.println("记录 " + recordId + " 已更新，新值: " + newValue);
    }
    
    public void markAsProcessed() {
        this.status = "PROCESSED";
        System.out.println("记录 " + recordId + " 已标记为已处理");
    }
    
    public boolean isValid() {
        return recordId != null && !recordId.isEmpty() 
            && source != null && !source.isEmpty()
            && value >= 0;
    }
    
    // Getter和Setter方法（封装的体现）
    public String getRecordId() { return recordId; }
    public void setRecordId(String recordId) { this.recordId = recordId; }
    
    public String getSource() { return source; }
    public void setSource(String source) { this.source = source; }
    
    public long getTimestamp() { return timestamp; }
    public void setTimestamp(long timestamp) { this.timestamp = timestamp; }
    
    public double getValue() { return value; }
    public void setValue(double value) { this.value = value; }
    
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    
    // toString方法 - 便于调试和日志输出
    @Override
    public String toString() {
        return String.format("DataRecord{id='%s', source='%s', timestamp=%d, value=%.2f, status='%s'}",
                recordId, source, timestamp, value, status);
    }
}

🎯 使用类和对象

public class DataRecordExample {
    public static void main(String[] args) {
        System.out.println("=== 数据记录管理示例 ===");
        
        // 创建对象（实例化）
        DataRecord record1 = new DataRecord(); // 使用默认构造方法
        DataRecord record2 = new DataRecord("R001", "sensor_A", 25.6); // 使用带参构造方法
        DataRecord record3 = new DataRecord("R002", "sensor_B", 1634567890000L, 30.2, "IMPORTED");
        
        // 输出对象信息
        System.out.println("记录1: " + record1);
        System.out.println("记录2: " + record2);
        System.out.println("记录3: " + record3);
        
        // 调用对象方法
        System.out.println("\n=== 数据操作 ===");
        record1.setRecordId("R000");
        record1.setSource("manual_input");
        record1.updateValue(15.8);
        
        record2.updateValue(28.9);
        record2.markAsProcessed();
        
        // 数据验证
        System.out.println("\n=== 数据验证 ===");
        System.out.println("记录1有效性: " + record1.isValid());
        System.out.println("记录2有效性: " + record2.isValid());
        System.out.println("记录3有效性: " + record3.isValid());
        
        // 最终状态
        System.out.println("\n=== 最终状态 ===");
        System.out.println("记录1: " + record1);
        System.out.println("记录2: " + record2);
        System.out.println("记录3: " + record3);
    }
}

🔒 封装原理与实践

封装是面向对象编程的三大特性之一，它能够保护数据安全并提供清晰的接口：

🛡️ 数据处理器封装示例

/**
 * 数据处理器类 - 展示封装的重要性
 */
public class DataProcessor {
    // 私有成员变量（数据隐藏）
    private String processorName;
    private int processedCount;
    private int errorCount;
    private double totalProcessingTime;
    private boolean isRunning;
    
    // 私有的内部状态
    private static final int MAX_RETRY_COUNT = 3;
    private static final double TIMEOUT_SECONDS = 30.0;
    
    // 构造方法
    public DataProcessor(String processorName) {
        this.processorName = processorName;
        this.processedCount = 0;
        this.errorCount = 0;
        this.totalProcessingTime = 0.0;
        this.isRunning = false;
    }
    
    // 公共接口方法
    public void startProcessor() {
        if (isRunning) {
            System.out.println("处理器 " + processorName + " 已经在运行中");
            return;
        }
        
        isRunning = true;
        System.out.println("数据处理器 " + processorName + " 已启动");
    }
    
    public void stopProcessor() {
        if (!isRunning) {
            System.out.println("处理器 " + processorName + " 已经停止");
            return;
        }
        
        isRunning = false;
        System.out.println("数据处理器 " + processorName + " 已停止");
        printStatistics();
    }
    
    public boolean processData(String data) {
        if (!isRunning) {
            System.out.println("处理器未启动，无法处理数据");
            return false;
        }
        
        if (data == null || data.trim().isEmpty()) {
            System.out.println("无效数据，处理失败");
            incrementErrorCount();
            return false;
        }
        
        long startTime = System.currentTimeMillis();
        
        try {
            // 模拟数据处理
            boolean success = processDataInternal(data);
            
            long endTime = System.currentTimeMillis();
            double processingTime = (endTime - startTime) / 1000.0;
            if (success) {
                updateProcessingTime(processingTime);
                incrementProcessedCount();
                System.out.println("数据处理成功: " + data.substring(0, Math.min(20, data.length())));
                return true;
            } else {
                incrementErrorCount();
                System.out.println("数据处理失败: " + data.substring(0, Math.min(20, data.length())));
                return false;
            }
            
        } catch (Exception e) {
            incrementErrorCount();
            System.out.println("处理异常: " + e.getMessage());
            return false;
        }
    }
    
    // 私有辅助方法（内部实现细节）
    private boolean processDataInternal(String data) {
        // 模拟数据处理逻辑
        try {
            Thread.sleep(100); // 模拟处理时间
            return Math.random() > 0.1; // 90%成功率
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
    
    private void incrementProcessedCount() {
        processedCount++;
    }
    
    private void incrementErrorCount() {
        errorCount++;
    }
    
    private void updateProcessingTime(double time) {
        totalProcessingTime += time;
    }
    
    // 只读访问器（不提供setter，保护内部状态）
    public String getProcessorName() {
        return processorName;
    }
    
    public int getProcessedCount() {
        return processedCount;
    }
    
    public int getErrorCount() {
        return errorCount;
    }
    
    public double getAverageProcessingTime() {
        if (processedCount == 0) return 0.0;
        return totalProcessingTime / processedCount;
    }
    
    public boolean isRunning() {
        return isRunning;
    }
    
    public double getSuccessRate() {
        int totalAttempts = processedCount + errorCount;
        if (totalAttempts == 0) return 0.0;
        return (double) processedCount / totalAttempts * 100.0;
    }
    
    // 统计信息输出
    public void printStatistics() {
        System.out.println("\n=== " + processorName + " 处理统计 ===");
        System.out.println("成功处理: " + processedCount + " 条");
        System.out.println("处理失败: " + errorCount + " 条");
        System.out.println("成功率: " + String.format("%.2f", getSuccessRate()) + "%");
        System.out.println("成功处理平均时间: " + String.format("%.3f", getAverageProcessingTime()) + " 秒");
        System.out.println("成功处理总时间: " + String.format("%.3f", totalProcessingTime) + " 秒");
    }
}

🎯 封装应用示例

public class EncapsulationExample {
    public static void main(String[] args) {
        // 创建数据处理器
        DataProcessor processor = new DataProcessor("用户行为数据处理器");
        
        // 启动处理器
        processor.startProcessor();
        
        // 处理一批数据
        String[] testData = {
            "user_click_event_001",
            "user_view_event_002",
            "", // 无效数据
            "user_purchase_event_003",
            "user_logout_event_004",
            null, // 无效数据
            "user_search_event_005"
        };
        
        System.out.println("\n=== 开始处理数据 ===");
        for (String data : testData) {
            processor.processData(data);
        }
        
        // 查看处理状态
        System.out.println("\n=== 处理状态查询 ===");
        System.out.println("处理器名称: " + processor.getProcessorName());
        System.out.println("是否运行中: " + processor.isRunning());
        System.out.println("成功处理数量: " + processor.getProcessedCount());
        System.out.println("错误数量: " + processor.getErrorCount());
        System.out.println("成功率: " + String.format("%.2f", processor.getSuccessRate()) + "%");
        
        // 停止处理器
        processor.stopProcessor();
        
        // 注意：无法直接访问私有变量
        // System.out.println(processor.processedCount); // 编译错误！
        // processor.isRunning = false; // 编译错误！
    }
}

🧬 继承机制详解

继承允许我们创建基于现有类的新类，实现代码复用和扩展：

🏗️ 数据源基类设计

/**
 * 数据源基类 - 定义所有数据源的通用行为
 */
public abstract class DataSource {
    // 通用属性
    protected String sourceName;
    protected String connectionString;
    protected boolean isConnected;
    protected long lastAccessTime;
    protected int accessCount;
    
    // 构造方法
    public DataSource(String sourceName, String connectionString) {
        this.sourceName = sourceName;
        this.connectionString = connectionString;
        this.isConnected = false;
        this.lastAccessTime = 0;
        this.accessCount = 0;
    }
    
    // 通用方法实现
    public void connect() {
        if (isConnected) {
            System.out.println("数据源 " + sourceName + " 已经连接");
            return;
        }
        
        System.out.println("正在连接数据源: " + sourceName);
        
        // 调用子类的具体连接实现
        if (doConnect()) {
            isConnected = true;
            lastAccessTime = System.currentTimeMillis();
            System.out.println("数据源 " + sourceName + " 连接成功");
        } else {
            System.out.println("数据源 " + sourceName + " 连接失败");
        }
    }
    
    public void disconnect() {
        if (!isConnected) {
            System.out.println("数据源 " + sourceName + " 未连接");
            return;
        }
        
        System.out.println("正在断开数据源: " + sourceName);
        doDisconnect();
        isConnected = false;
        System.out.println("数据源 " + sourceName + " 已断开连接");
    }
    
    public boolean isHealthy() {
        if (!isConnected) {
            return false;
        }
        
        // 检查连接是否超时（5分钟）
        long currentTime = System.currentTimeMillis();
        long timeoutMillis = 5 * 60 * 1000; // 5分钟
        
        if (currentTime - lastAccessTime > timeoutMillis) {
            System.out.println("数据源 " + sourceName + " 连接超时");
            return false;
        }
        
        return doHealthCheck();
    }
    
    protected void updateAccessTime() {
        lastAccessTime = System.currentTimeMillis();
        accessCount++;
    }
    
    // 抽象方法 - 子类必须实现
    protected abstract boolean doConnect();
    protected abstract void doDisconnect();
    protected abstract boolean doHealthCheck();
    public abstract String[] readData();
    public abstract boolean writeData(String[] data);
    
    // Getter方法
    public String getSourceName() { return sourceName; }
    public String getConnectionString() { return connectionString; }
    public boolean isConnected() { return isConnected; }
    public long getLastAccessTime() { return lastAccessTime; }
    public int getAccessCount() { return accessCount; }
    
    @Override
    public String toString() {
        return String.format("DataSource{name='%s', connected=%b, accessCount=%d}",
                sourceName, isConnected, accessCount);
    }
}

📊 数据库数据源实现

/**
 * 数据库数据源 - 继承自DataSource
 */
public class DatabaseDataSource extends DataSource {
    private String databaseType;
    private String username;
    private int port;
    private int maxConnections;
    
    public DatabaseDataSource(String sourceName, String connectionString, 
                            String databaseType, String username, int port) {
        super(sourceName, connectionString); // 调用父类构造方法
        this.databaseType = databaseType;
        this.username = username;
        this.port = port;
        this.maxConnections = 10; // 默认值
    }
    
    // 实现父类的抽象方法
    @Override
    protected boolean doConnect() {
        System.out.println("  使用JDBC连接到 " + databaseType + " 数据库");
        System.out.println("  连接字符串: " + connectionString);
        System.out.println("  用户名: " + username);
        System.out.println("  端口: " + port);
        
        // 模拟连接过程
        try {
            Thread.sleep(1000); // 模拟连接延迟
            return Math.random() > 0.1; // 90%成功率
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
    
    @Override
    protected void doDisconnect() {
        System.out.println("  关闭数据库连接池");
        System.out.println("  释放 " + databaseType + " 数据库资源");
    }
    
    @Override
    protected boolean doHealthCheck() {
        System.out.println("  执行数据库健康检查: SELECT 1");
        // 模拟健康检查
        return Math.random() > 0.05; // 95%健康率
    }
    
    @Override
    public String[] readData() {
        if (!isConnected) {
            System.out.println("数据库未连接，无法读取数据");
            return new String[0];
        }
        
        updateAccessTime(); // 更新访问时间
        
        System.out.println("从 " + databaseType + " 数据库读取数据...");
        
        // 模拟读取数据
        return new String[]{
            "SELECT * FROM users WHERE age > 18",
            "SELECT * FROM orders WHERE status = 'PENDING'",
            "SELECT * FROM products WHERE price > 100"
        };
    }
    
    @Override
    public boolean writeData(String[] data) {
        if (!isConnected) {
            System.out.println("数据库未连接，无法写入数据");
            return false;
        }
        
        updateAccessTime(); // 更新访问时间
        
        System.out.println("向 " + databaseType + " 数据库写入 " + data.length + " 条数据");
        
        for (String item : data) {
            System.out.println("  执行SQL: " + item);
        }
        
        return true;
    }
    
    // 数据库特有的附加方法
    public void executeQuery(String sql) {
        if (!isConnected) {
            System.out.println("数据库未连接，无法执行查询");
            return;
        }
        
        updateAccessTime();
        System.out.println("执行查询: " + sql);
    }
    
    public void createIndex(String tableName, String columnName) {
        if (!isConnected) {
            System.out.println("数据库未连接，无法创建索引");
            return;
        }
        
        updateAccessTime();
        System.out.println("在表 " + tableName + " 的列 " + columnName + " 上创建索引");
    }
    
    // Getter和Setter
    public String getDatabaseType() { return databaseType; }
    public String getUsername() { return username; }
    public int getPort() { return port; }
    public int getMaxConnections() { return maxConnections; }
    public void setMaxConnections(int maxConnections) { this.maxConnections = maxConnections; }
}

📁 文件数据源实现

/**
 * 文件数据源 - 继承自DataSource
 */
public class FileDataSource extends DataSource {
    private String filePath;
    private String fileType;
    private long fileSize;
    
    public FileDataSource(String sourceName, String filePath, String fileType) {
        super(sourceName, filePath); // connectionString就是文件路径
        this.filePath = filePath;
        this.fileType = fileType;
        this.fileSize = 0;
    }
    
    @Override
    protected boolean doConnect() {
        System.out.println("  检查文件是否存在: " + filePath);
        System.out.println("  文件类型: " + fileType);
        
        // 模拟文件检查
        try {
            Thread.sleep(200);
            this.fileSize = (long) (Math.random() * 1000000); // 模拟文件大小
            System.out.println("  文件大小: " + fileSize + " bytes");
            return true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
    
    @Override
    protected void doDisconnect() {
        System.out.println("  关闭文件句柄: " + filePath);
        this.fileSize = 0;
    }
    
    @Override
    protected boolean doHealthCheck() {
        System.out.println("  检查文件访问权限: " + filePath);
        return Math.random() > 0.02; // 98%健康率
    }
    
    @Override
    public String[] readData() {
        if (!isConnected) {
            System.out.println("文件未打开，无法读取数据");
            return new String[0];
        }
        
        updateAccessTime();
        
        System.out.println("从 " + fileType + " 文件读取数据: " + filePath);
        
        // 根据文件类型返回不同格式的数据
        switch (fileType.toUpperCase()) {
            case "CSV":
                return new String[]{
                    "name,age,city",
                    "张三,25,北京",
                    "李四,30,上海"
                };
            case "JSON":
                return new String[]{
                    "{\"users\": [",
                    "  {\"name\": \"张三\", \"age\": 25, \"city\": \"北京\"},",
                    "  {\"name\": \"李四\", \"age\": 30, \"city\": \"上海\"}",
                    "]}"
                };
            case "TXT":
                return new String[]{
                    "用户数据文件",
                    "张三 25 北京",
                    "李四 30 上海"
                };
            default:
                return new String[]{"未知文件格式"};
        }
    }
    
    @Override
    public boolean writeData(String[] data) {
        if (!isConnected) {
            System.out.println("文件未打开，无法写入数据");
            return false;
        }
        
        updateAccessTime();
        
        System.out.println("向 " + fileType + " 文件写入 " + data.length + " 行数据");
        
        for (String line : data) {
            System.out.println("  写入: " + line);
        }
        
        return true;
    }
    
    // 文件特有的方法
    public void compressFile() {
        if (!isConnected) {
            System.out.println("文件未打开，无法压缩");
            return;
        }
        
        System.out.println("压缩文件: " + filePath);
        this.fileSize = (long) (fileSize * 0.7); // 模拟压缩后大小
        System.out.println("压缩后大小: " + fileSize + " bytes");
    }
    
    public void backupFile(String backupPath) {
        if (!isConnected) {
            System.out.println("文件未打开，无法备份");
            return;
        }
        
        System.out.println("备份文件从 " + filePath + " 到 " + backupPath);
    }
    
    // Getter方法
    public String getFilePath() { return filePath; }
    public String getFileType() { return fileType; }
    public long getFileSize() { return fileSize; }
}

🎯 继承应用示例

public class InheritanceExample {
    public static void main(String[] args) {
        System.out.println("=== 数据源继承示例 ===");
        
        // 创建不同类型的数据源
        DatabaseDataSource dbSource = new DatabaseDataSource(
            "用户数据库", 
            "jdbc:mysql://localhost:3306/userdb", 
            "MySQL", 
            "admin", 
            3306
        );
        
        FileDataSource csvSource = new FileDataSource(
            "用户CSV文件", 
            "/data/users.csv", 
            "CSV"
        );
        
        FileDataSource jsonSource = new FileDataSource(
            "用户JSON文件", 
            "/data/users.json", 
            "JSON"
        );
        
        // 将不同的数据源放在同一个数组中（多态性）
        DataSource[] dataSources = {dbSource, csvSource, jsonSource};
        
        System.out.println("\n=== 连接所有数据源 ===");
        for (DataSource source : dataSources) {
            source.connect();
            System.out.println("连接状态: " + source.toString());
            System.out.println();
        }
        
        System.out.println("=== 健康检查 ===");
        for (DataSource source : dataSources) {
            boolean healthy = source.isHealthy();
            System.out.println(source.getSourceName() + " 健康状态: " + 
                (healthy ? "正常" : "异常"));
        }
        
        System.out.println("\n=== 读取数据 ===");
        for (DataSource source : dataSources) {
            String[] data = source.readData();
            System.out.println("从 " + source.getSourceName() + " 读取到 " + data.length + " 条数据:");
            for (String item : data) {
                System.out.println("  " + item);
            }
            System.out.println();
        }
        
        System.out.println("=== 写入数据 ===");
        String[] newData = {"新用户1", "新用户2", "新用户3"};
        for (DataSource source : dataSources) {
            boolean success = source.writeData(newData);
            System.out.println("向 " + source.getSourceName() + " 写入数据: " + 
                (success ? "成功" : "失败"));
        }
        
        System.out.println("\n=== 使用子类特有方法 ===");
        // 数据库特有方法
        dbSource.executeQuery("SELECT COUNT(*) FROM users");
        dbSource.createIndex("users", "email");
        
        // 文件特有方法
        csvSource.compressFile();
        csvSource.backupFile("/backup/users.csv.bak");
        
        jsonSource.compressFile();
        
        System.out.println("\n=== 断开所有连接 ===");
        for (DataSource source : dataSources) {
            source.disconnect();
        }
        
        System.out.println("\n=== 最终统计 ===");
        for (DataSource source : dataSources) {
            System.out.println(source.getSourceName() + " 访问次数: " + source.getAccessCount());
        }
    }
}

🎭 多态特性应用

多态是面向对象编程的核心特性，它允许我们用统一的接口处理不同类型的对象：

🔄 数据转换器多态示例

/**
 * 数据转换器接口
 */
public interface DataConverter {
    String convert(String input);
    String getConverterType();
    boolean supports(String dataType);
}

/**
 * JSON转换器实现
 */
public class JsonConverter implements DataConverter {
    @Override
    public String convert(String input) {
        System.out.println("执行JSON转换...");
        // 模拟JSON转换逻辑
        return "{\"data\": \"" + input + "\", \"timestamp\": " + System.currentTimeMillis() + "}";
    }
    
    @Override
    public String getConverterType() {
        return "JSON_CONVERTER";
    }
    
    @Override
    public boolean supports(String dataType) {
        return "JSON".equalsIgnoreCase(dataType) || "APPLICATION/JSON".equalsIgnoreCase(dataType);
    }
}

/**
 * XML转换器实现
 */
public class XmlConverter implements DataConverter {
    @Override
    public String convert(String input) {
        System.out.println("执行XML转换...");
        // 模拟XML转换逻辑
        return "<?xml version=\"1.0\"?><data><content>" + input + "</content><timestamp>" + 
               System.currentTimeMillis() + "</timestamp></data>";
    }
    
    @Override
    public String getConverterType() {
        return "XML_CONVERTER";
    }
    
    @Override
    public boolean supports(String dataType) {
        return "XML".equalsIgnoreCase(dataType) || "APPLICATION/XML".equalsIgnoreCase(dataType);
    }
}

/**
 * CSV转换器实现
 */
public class CsvConverter implements DataConverter {
    @Override
    public String convert(String input) {
        System.out.println("执行CSV转换...");
        // 模拟CSV转换逻辑
        return "data,timestamp\n\"" + input + "\"," + System.currentTimeMillis();
    }
    
    @Override
    public String getConverterType() {
        return "CSV_CONVERTER";
    }
    
    @Override
    public boolean supports(String dataType) {
        return "CSV".equalsIgnoreCase(dataType) || "TEXT/CSV".equalsIgnoreCase(dataType);
    }
}

🏭 数据转换工厂

/**
 * 数据转换工厂 - 演示多态的实际应用
 */
public class DataConverterFactory {
    private static DataConverter[] converters = {
        new JsonConverter(),
        new XmlConverter(),
        new CsvConverter()
    };
    
    public static DataConverter getConverter(String dataType) {
        for (DataConverter converter : converters) {
            if (converter.supports(dataType)) {
                return converter;
            }
        }
        return null; // 不支持的类型
    }
    
    public static String[] getSupportedTypes() {
        return new String[]{"JSON", "XML", "CSV"};
    }
    
    public static void processDataBatch(String[] inputData, String[] dataTypes) {
        System.out.println("=== 批量数据转换处理 ===");
        
        for (int i = 0; i < inputData.length && i < dataTypes.length; i++) {
            String input = inputData[i];
            String type = dataTypes[i];
            
            System.out.println("\n处理数据 " + (i + 1) + ": " + input);
            System.out.println("目标格式: " + type);
            
            // 多态的核心：同一个接口，不同的实现
            DataConverter converter = getConverter(type);
            
            if (converter != null) {
                System.out.println("使用转换器: " + converter.getConverterType());
                String result = converter.convert(input);
                System.out.println("转换结果: " + result);
            } else {
                System.out.println("不支持的数据类型: " + type);
            }
        }
    }
}

🎯 多态应用示例

public class PolymorphismExample {
    public static void main(String[] args) {
        System.out.println("=== 数据转换多态示例 ===");
        
        // 准备测试数据
        String[] testData = {
            "用户购买商品",
            "系统登录日志",
            "传感器读数",
            "交易记录"
        };
        
        String[] targetFormats = {
            "JSON",
            "XML", 
            "CSV",
            "YAML" // 不支持的格式
        };
        
        // 使用多态进行批量处理
        DataConverterFactory.processDataBatch(testData, targetFormats);
        
        System.out.println("\n=== 支持的格式列表 ===");
        String[] supportedTypes = DataConverterFactory.getSupportedTypes();
        for (String type : supportedTypes) {
            System.out.println("- " + type);
        }
        
        System.out.println("\n=== 动态转换器选择 ===");
        // 演示运行时的多态性
        String[] formats = {"json", "XML", "csv", "unknown"};
        
        for (String format : formats) {
            DataConverter converter = DataConverterFactory.getConverter(format);
            
            if (converter != null) {
                System.out.println("格式 " + format + " -> 转换器: " + converter.getConverterType());
                String result = converter.convert("测试数据 for " + format);
                System.out.println("转换示例: " + result.substring(0, Math.min(50, result.length())) + "...");
            } else {
                System.out.println("格式 " + format + " -> 无对应转换器");
            }
            System.out.println();
        }
    }
}

📦 接口与抽象类

🔌 数据连接器接口设计

/**
 * 数据连接器接口 - 定义标准的数据连接协议
 */
public interface DataConnector {
    // 连接相关方法
    boolean connect(String connectionString);
    void disconnect();
    boolean isConnected();
    
    // 数据操作方法
    Object[] query(String queryString);
    boolean execute(String command);
    
    // 连接信息
    String getConnectionInfo();
    long getLastActivityTime();
}

/**
 * 可配置接口 - 支持配置管理
 */
public interface Configurable {
    void configure(Properties config);
    Properties getConfiguration();
    boolean validateConfiguration();
}

/**
 * 监控接口 - 支持性能监控
 */
public interface Monitorable {
    Map<String, Object> getMetrics();
    void resetMetrics();
    boolean isHealthy();
}

🏗️ 抽象数据库连接器

/**
 * 抽象数据库连接器 - 实现通用功能，子类实现特定数据库逻辑
 */
public abstract class AbstractDatabaseConnector implements DataConnector, Configurable, Monitorable {
    protected String connectionString;
    protected boolean connected;
    protected long lastActivityTime;
    protected Properties configuration;
    protected Map<String, Object> metrics;
    
    public AbstractDatabaseConnector() {
        this.connected = false;
        this.lastActivityTime = 0;
        this.configuration = new Properties();
        this.metrics = new HashMap<>();
        initializeMetrics();
    }
    
    // 模板方法模式 - 定义连接流程
    @Override
    public final boolean connect(String connectionString) {
        if (connected) {
            System.out.println("已经连接到数据库");
            return true;
        }
        
        this.connectionString = connectionString;
        System.out.println("开始连接数据库: " + connectionString);
        
        // 1. 验证连接字符串
        if (!validateConnectionString(connectionString)) {
            System.out.println("连接字符串无效");
            return false;
        }
        
        // 2. 建立连接（子类实现）
        if (!doConnect()) {
            System.out.println("连接失败");
            return false;
        }
        
        // 3. 初始化连接
        if (!initializeConnection()) {
            System.out.println("连接初始化失败");
            doDisconnect();
            return false;
        }
        
        connected = true;
        lastActivityTime = System.currentTimeMillis();
        incrementMetric("connection_count");
        
        System.out.println("数据库连接成功");
        return true;
    }
    
    @Override
    public final void disconnect() {
        if (!connected) {
            System.out.println("数据库未连接");
            return;
        }
        
        System.out.println("断开数据库连接");
        doDisconnect();
        connected = false;
        lastActivityTime = System.currentTimeMillis();
    }
    
    @Override
    public boolean isConnected() {
        return connected;
    }
    
    @Override
    public String getConnectionInfo() {
        return String.format("Database Connection: %s, Connected: %b, Last Activity: %d",
                connectionString, connected, lastActivityTime);
    }
    
    @Override
    public long getLastActivityTime() {
        return lastActivityTime;
    }
    
    // Configurable接口实现
    @Override
    public void configure(Properties config) {
        this.configuration.putAll(config);
        System.out.println("配置已更新，共 " + config.size() + " 项");
    }
    
    @Override
    public Properties getConfiguration() {
        Properties copy = new Properties();
        copy.putAll(configuration);
        return copy;
    }
    
    @Override
    public boolean validateConfiguration() {
        // 检查必需的配置项
        String[] requiredKeys = {"host", "port", "database", "username"};
        for (String key : requiredKeys) {
            if (!configuration.containsKey(key)) {
                System.out.println("缺少必需的配置项: " + key);
                return false;
            }
        }
        return true;
    }
    
    // Monitorable接口实现
    @Override
    public Map<String, Object> getMetrics() {
        metrics.put("last_activity_time", lastActivityTime);
        metrics.put("is_connected", connected);
        metrics.put("idle_time_ms", connected ? System.currentTimeMillis() - lastActivityTime : 0);
        return new HashMap<>(metrics);
    }
    
    @Override
    public void resetMetrics() {
        initializeMetrics();
        System.out.println("监控指标已重置");
    }
    
    @Override
    public boolean isHealthy() {
        if (!connected) {
            return false;
        }
        
        // 检查连接是否超时
        long currentTime = System.currentTimeMillis();
        long timeoutMs = 300000; // 5分钟超时
        
        return (currentTime - lastActivityTime) < timeoutMs;
    }
    
    // 受保护的辅助方法
    protected void updateActivity() {
        lastActivityTime = System.currentTimeMillis();
    }
    
    protected void incrementMetric(String metricName) {
        Object current = metrics.get(metricName);
        if (current instanceof Integer) {
            metrics.put(metricName, (Integer) current + 1);
        } else {
            metrics.put(metricName, 1);
        }
    }
    
    private void initializeMetrics() {
        metrics.clear();
        metrics.put("connection_count", 0);
        metrics.put("query_count", 0);
        metrics.put("execute_count", 0);
        metrics.put("error_count", 0);
    }
    
    // 抽象方法 - 子类必须实现
    protected abstract boolean validateConnectionString(String connectionString);
    protected abstract boolean doConnect();
    protected abstract void doDisconnect();
    protected abstract boolean initializeConnection();
}

🐬 MySQL连接器实现

/**
 * MySQL数据库连接器 - 具体实现
 */
public class MySQLConnector extends AbstractDatabaseConnector {
    private String host;
    private int port;
    private String database;
    private String username;
    private String password;
    
    @Override
    protected boolean validateConnectionString(String connectionString) {
        // 简单的MySQL连接字符串验证
        // 格式：jdbc:mysql://host:port/database
        if (!connectionString.startsWith("jdbc:mysql://")) {
            return false;
        }
        
        try {
            // 解析连接字符串
            String url = connectionString.replace("jdbc:mysql://", "");
            String[] parts = url.split("/");
            
            if (parts.length < 2) {
                return false;
            }
            
            String[] hostPort = parts[0].split(":");
            this.host = hostPort[0];
            this.port = hostPort.length > 1 ? Integer.parseInt(hostPort[1]) : 3306;
            this.database = parts[1];
            
            // 从配置中获取认证信息
            this.username = configuration.getProperty("username", "root");
            this.password = configuration.getProperty("password", "");
            
            return true;
        } catch (Exception e) {
            System.out.println("连接字符串解析错误: " + e.getMessage());
            return false;
        }
    }
    
    @Override
    protected boolean doConnect() {
        System.out.println("  连接MySQL服务器: " + host + ":" + port);
        System.out.println("  数据库: " + database);
        System.out.println("  用户名: " + username);
        
        // 模拟MySQL连接过程
        try {
            Thread.sleep(1000); // 模拟连接延迟
            return Math.random() > 0.1; // 90%成功率
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
    
    @Override
    protected void doDisconnect() {
        System.out.println("  关闭MySQL连接");
        System.out.println("  释放数据库资源");
    }
    
    @Override
    protected boolean initializeConnection() {
        System.out.println("  设置MySQL连接参数");
        System.out.println("  设置字符集为UTF-8");
        System.out.println("  设置事务隔离级别");
        return true;
    }
    
    @Override
    public Object[] query(String queryString) {
        if (!connected) {
            System.out.println("数据库未连接，无法执行查询");
            return new Object[0];
        }
        
        updateActivity();
        incrementMetric("query_count");
        
        System.out.println("执行MySQL查询: " + queryString);
        
        // 模拟查询结果
        return new Object[]{
            "ResultSet: " + queryString,
            "Row 1: Sample Data",
            "Row 2: Sample Data",
            "Query completed successfully"
        };
    }
    
    @Override
    public boolean execute(String command) {
        if (!connected) {
            System.out.println("数据库未连接，无法执行命令");
            return false;
        }
        
        updateActivity();
        incrementMetric("execute_count");
        
        System.out.println("执行MySQL命令: " + command);
        
        // 模拟命令执行
        try {
            Thread.sleep(200);
            return Math.random() > 0.05; // 95%成功率
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            incrementMetric("error_count");
            return false;
        }
    }
    
    // MySQL特有的方法
    public void optimizeTable(String tableName) {
        if (!connected) {
            System.out.println("数据库未连接，无法优化表");
            return;
        }
        
        System.out.println("优化MySQL表: " + tableName);
        execute("OPTIMIZE TABLE " + tableName);
    }
    
    public void showProcessList() {
        if (!connected) {
            System.out.println("数据库未连接，无法显示进程列表");
            return;
        }
        
        Object[] result = query("SHOW PROCESSLIST");
        System.out.println("MySQL进程列表:");
        for (Object row : result) {
            System.out.println("  " + row);
        }
    }
}

🎯 接口与抽象类应用示例

public class InterfaceAbstractExample {
    public static void main(String[] args) {
        System.out.println("=== 接口与抽象类应用示例 ===");
        
        // 创建MySQL连接器
        MySQLConnector mysqlConnector = new MySQLConnector();
        
        // 配置连接器
        Properties config = new Properties();
        config.setProperty("host", "localhost");
        config.setProperty("port", "3306");
        config.setProperty("database", "testdb");
        config.setProperty("username", "admin");
        config.setProperty("password", "password123");
        
        mysqlConnector.configure(config);
        
        // 验证配置
        System.out.println("\n=== 配置验证 ===");
        boolean configValid = mysqlConnector.validateConfiguration();
        System.out.println("配置有效性: " + configValid);
        
        // 连接数据库
        System.out.println("\n=== 建立连接 ===");
        boolean connected = mysqlConnector.connect("jdbc:mysql://localhost:3306/testdb");
        System.out.println("连接结果: " + connected);
        
        if (connected) {
            // 使用多个接口的功能
            useDataConnector(mysqlConnector);
            useMonitorable(mysqlConnector);
            useConfigurable(mysqlConnector);
            
            // 使用MySQL特有功能
            System.out.println("\n=== MySQL特有功能 ===");
            mysqlConnector.optimizeTable("users");
            mysqlConnector.showProcessList();
            
            // 断开连接
            System.out.println("\n=== 断开连接 ===");
            mysqlConnector.disconnect();
        }
        
        // 最终状态检查
        System.out.println("\n=== 最终状态 ===");
        System.out.println("连接信息: " + mysqlConnector.getConnectionInfo());
        System.out.println("健康状态: " + mysqlConnector.isHealthy());
    }
    
    // 使用DataConnector接口的方法
    private static void useDataConnector(DataConnector connector) {
        System.out.println("\n=== 使用DataConnector接口 ===");
        System.out.println("连接状态: " + connector.isConnected());
        
        if (connector.isConnected()) {
            // 执行查询
            Object[] queryResult = connector.query("SELECT * FROM users LIMIT 5");
            System.out.println("查询结果数量: " + queryResult.length);
            for (Object result : queryResult) {
                System.out.println("  " + result);
            }
            
            // 执行命令
            boolean executeResult = connector.execute("UPDATE users SET last_login = NOW()");
            System.out.println("命令执行结果: " + executeResult);
        }
    }
    
    // 使用Monitorable接口的方法
    private static void useMonitorable(Monitorable monitorable) {
        System.out.println("\n=== 使用Monitorable接口 ===");
        Map<String, Object> metrics = monitorable.getMetrics();
        
        System.out.println("监控指标:");
        for (Map.Entry<String, Object> entry : metrics.entrySet()) {
            System.out.println("  " + entry.getKey() + ": " + entry.getValue());
        }
        
        System.out.println("健康检查: " + monitorable.isHealthy());
    }
    
    // 使用Configurable接口的方法
    private static void useConfigurable(Configurable configurable) {
        System.out.println("\n=== 使用Configurable接口 ===");
        Properties currentConfig = configurable.getConfiguration();
        
        System.out.println("当前配置项:");
        for (Object key : currentConfig.keySet()) {
            String value = currentConfig.getProperty((String) key);
            // 隐藏敏感信息
            if (key.toString().toLowerCase().contains("password")) {
                value = "******";
            }
            System.out.println("  " + key + ": " + value);
        }
        
        // 添加新配置
        Properties newConfig = new Properties();
        newConfig.setProperty("timeout", "30000");
        newConfig.setProperty("pool_size", "10");
        configurable.configure(newConfig);
    }
}

📋 面向对象总结

✅ 核心概念回顾

1. 类与对象：

   • 类是模板，对象是实例
   • 合理的构造方法设计
   • 成员变量和方法的组织

2. 封装：

   • 数据隐藏和访问控制
   • 公共接口的设计
   • getter/setter方法的使用

3. 继承：

   • 代码复用和扩展
   • 父类和子类的关系
   • 方法重写和调用

4. 多态：

   • 接口统一，实现多样
   • 运行时的动态绑定
   • 灵活的程序架构

5. 接口与抽象类：

   • 规范定义和实现分离
   • 多重继承的模拟
   • 设计模式的基础

🎯 在数据开发中的应用

// 面向对象在数据开发中的最佳实践示例
public class DataPipelineOOPExample {
    public static void main(String[] args) {
        // 1. 使用接口实现可插拔的数据处理组件
        DataProcessor[] processors = {
            new DataCleaner(),
            new DataTransformer(),
            new DataValidator()
        };
        
        // 2. 使用继承构建数据源家族
        DataSource[] sources = {
            new DatabaseDataSource("db", "connection", "MySQL", "user", 3306),
            new FileDataSource("file", "/data/input.csv", "CSV")
        };
        
        // 3. 使用多态统一处理不同类型的数据
        for (DataSource source : sources) {
            source.connect();
            String[] data = source.readData();
            
            for (DataProcessor processor : processors) {
                // 多态调用，统一接口
                data = processor.process(data);
            }
            
            source.disconnect();
        }
    }
}

---

📚 相关学习资源

继续学习

• 学习路线图：Java
• 基础语法入门：Java基础语法
• 开发环境搭建：Java开发环境搭建
• 数据处理与文件IO：Java数据处理与文件IO

高级主题

• Java在数据开发中的应用：Java在数据开发中的
• Java大数据技术栈：Java大数据技术栈
• 数据库操作与数据仓库开发：Java数据库操作与数据仓库开发