Java读取加密货币钱包TXT文件及多态方法实现求助

一、先解决文件读取与类型转换问题 #

你的现有代码只是读取整行打印，现在需要将每行内容拆分并转换为对应的数据类型。可以通过分割字符串或Scanner的token读取来实现，同时处理可能的格式异常。

修改后的文件读取代码：

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class CryptoCurrencies {
    public static void main(String[] args) throws IOException {
        System.out.println("Welcome to your Crypto Wallet\nCurrently, your coins are:");
        
        File cryptoWallet = new File("/Users/curti/OneDrive/Desktop/crypto.txt");
        Scanner scan = new Scanner(cryptoWallet);
        List<CryptoCurrency> wallet = new ArrayList<>();

        while (scan.hasNextLine()) {
            String line = scan.nextLine().trim();
            if (line.isEmpty()) continue; // 跳过空行
            
            String[] parts = line.split("\\s+"); // 按任意数量空格分割
            if (parts.length != 3) {
                System.out.println("无效格式行：" + line);
                continue;
            }

            try {
                String currencyName = parts[0];
                double quantity = Double.parseDouble(parts[1]);
                double valuePerUnit = Double.parseDouble(parts[2]);

                // 根据币种创建对应对象（后续多态实现的关键）
                CryptoCurrency crypto = createCryptoInstance(currencyName, quantity, valuePerUnit);
                wallet.add(crypto);
            } catch (NumberFormatException e) {
                System.out.println("行" + line + "数字格式错误：" + e.getMessage());
            }
        }
        scan.close();

        // 调用多态方法展示所有币种信息
        System.out.println("\n===== 钱包详情 =====");
        for (CryptoCurrency crypto : wallet) {
            crypto.displayInfo();
            System.out.println("---------------------");
        }
    }

    // 封装创建币种对象的逻辑，便于扩展
    private static CryptoCurrency createCryptoInstance(String name, double quantity, double valuePerUnit) {
        return switch (name.toLowerCase()) {
            case "bitcoin" -> new Bitcoin(quantity, valuePerUnit);
            case "ethereum" -> new Ethereum(quantity, valuePerUnit);
            default -> new UnknownCrypto(name, quantity, valuePerUnit);
        };
    }
}

二、多态方法的设计思路 #

多态的核心是抽象父类定义通用行为，子类实现具体逻辑。针对加密货币场景，我们可以：

1. 定义抽象父类 #

提取所有加密货币的共同属性（数量、单位价值）和通用方法（计算总价值、展示信息），将通用方法设为抽象，由子类实现差异化逻辑。

abstract class CryptoCurrency {
    protected double quantity;
    protected double valuePerUnit;

    public CryptoCurrency(double quantity, double valuePerUnit) {
        this.quantity = quantity;
        this.valuePerUnit = valuePerUnit;
    }

    // 抽象方法：计算总价值（子类可自定义逻辑）
    public abstract double calculateTotalValue();

    // 抽象方法：展示币种信息（子类自定义展示内容）
    public abstract void displayInfo();
}

2. 实现具体子类 #

针对不同币种，继承父类并实现抽象方法，添加各自的特性逻辑：

Bitcoin子类

class Bitcoin extends CryptoCurrency {
    // Bitcoin专属属性：交易手续费率
    private static final double TRANSACTION_FEE_RATE = 0.01;

    public Bitcoin(double quantity, double valuePerUnit) {
        super(quantity, valuePerUnit);
    }

    @Override
    public double calculateTotalValue() {
        // 总价值 = 数量 × 单位价值，扣除手续费后的实际可支配价值
        return quantity * valuePerUnit * (1 - TRANSACTION_FEE_RATE);
    }

    @Override
    public void displayInfo() {
        System.out.println("币种：Bitcoin");
        System.out.println("持有数量：" + quantity);
        System.out.println("单位价值：$" + valuePerUnit);
        System.out.println("实际可支配总价值：$" + String.format("%.2f", calculateTotalValue()));
        System.out.println("交易手续费率：" + (TRANSACTION_FEE_RATE * 100) + "%");
    }
}

Ethereum子类

class Ethereum extends CryptoCurrency {
    // Ethereum专属属性：质押年化收益率
    private static final double STAKING_REWARD_RATE = 0.04;

    public Ethereum(double quantity, double valuePerUnit) {
        super(quantity, valuePerUnit);
    }

    @Override
    public double calculateTotalValue() {
        // 总价值 = 数量 × 单位价值 × (1 + 质押收益率)
        return quantity * valuePerUnit * (1 + STAKING_REWARD_RATE);
    }

    @Override
    public void displayInfo() {
        System.out.println("币种：Ethereum");
        System.out.println("持有数量：" + quantity);
        System.out.println("单位价值：$" + valuePerUnit);
        System.out.println("总价值（含质押奖励）：$" + String.format("%.2f", calculateTotalValue()));
        System.out.println("年化质押收益率：" + (STAKING_REWARD_RATE * 100) + "%");
    }
}

未知币种子类

处理文件中未定义的币种，提供默认实现：

class UnknownCrypto extends CryptoCurrency {
    private String currencyName;

    public UnknownCrypto(String currencyName, double quantity, double valuePerUnit) {
        super(quantity, valuePerUnit);
        this.currencyName = currencyName;
    }

    @Override
    public double calculateTotalValue() {
        // 默认直接计算总价值
        return quantity * valuePerUnit;
    }

    @Override
    public void displayInfo() {
        System.out.println("币种：" + currencyName + "（未知币种）");
        System.out.println("持有数量：" + quantity);
        System.out.println("单位价值：$" + valuePerUnit);
        System.out.println("总价值：$" + String.format("%.2f", calculateTotalValue()));
    }
}

三、多态的体现 #

在主方法中，我们将所有币种对象存入List<CryptoCurrency>，遍历调用displayInfo()和calculateTotalValue()时，JVM会自动根据对象的实际类型调用对应的子类实现，这就是多态的核心：同一接口，不同实现。

内容的提问来源于stack exchange，提问作者Curtis