Java 如何在程序代码之外的swing应用程序中维护硬编码值

有人能告诉我如何单独维护所有硬编码值的设计吗

我目前正在使用一些设计模式，这些好吗？还有什么我可以做的更好的设计我的应用程序代码

我使用的设计模式是（我的应用程序有多个屏幕）：

对用户可见的所有字符串使用ResourceBundle（对于Internationalization）

使用属性文件保存特定屏幕的所有值，以便其他屏幕可以访问（这些值用于程序内部，用户不可见）。我在不同的地方不断地在程序中加载这些属性，以获得更新的值，比如，从第一个屏幕转到第二个屏幕（面板），在第二个屏幕中获得第一个屏幕的值

我正在考虑使用资源包将日志消息外部化

---

有没有更好的设计方法？要与程序代码分开，A.用户可见的消息，B.日志消息，C.可用性值（屏幕大小、字体等），用户在屏幕中输入的值，目录/文件路径…

我将查看允许存储系统范围默认值的，每用户默认值，并在没有配置值的情况下使用硬编码默认值。

I18N的资源包正是正确的选择。属性文件做得很好，但如果您更改它们，则必须重新打包和重新部署。将其他项目放入数据库通常更为灵活，因为您可以通过推送数据来更改应用程序，而无需重新打包和重新部署。

对于“可用性值”，我使用了单例模式。创建一个名为Configuration的类，然后创建一个调用私有构造函数的静态方法，

Configuration.getConfig（）

。程序需要的所有对象都可以作为字段存储在此类中。构造函数使用preferences API加载值。我在中发布了一些示例代码

---

将所有配置数据放在一个负责加载的类中的优点是，现在存储这些数据的方法已从代码的其余部分抽象出来。如果您决定使用数据库或ResourceBundle进行存储，则只需更改配置。

您的GUI应具有完整的数据模型。此模型可以读取I18n资源文件和常规资源文件来填充模型的一部分。数据模型是一个或多个Java类，在应用程序运行时保存对应用程序重要的数据

例如，这里是我创建的秒表GUI

下面是与秒表GUI关联的数据模型类

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

import javax.swing.table.DefaultTableModel;

public class StopwatchModel {

    protected boolean isSplitTime;

    protected long startTime;

    protected long endTime;

    protected DefaultTableModel tableModel;

    protected List<Long> splitTimes;

    protected String[] columnNames = {"", "Increment", "Cumulative"};

    public StopwatchModel() {
        this.splitTimes = new ArrayList<Long>();
        this.isSplitTime = false;
        this.startTime = 0;
        this.endTime = 0;
        setTableModel();
    }

    public void resetTimes() {
        this.splitTimes.clear();
        this.isSplitTime = false;
        this.startTime = 0;
        this.endTime = 0;
    }

    public boolean isSplitTime() {
        return isSplitTime;
    }

    public long getStartTime() {
        return startTime;
    }

    public long getEndTime() {
        return endTime;
    }

    public long getLastSplitTime() {
        int size = splitTimes.size();
        if (size < 1) {
            return getStartTime();
        } else {
            return splitTimes.get(size - 1);
        }
    }

    public long getPenultimateSplitTime() {
        int size = splitTimes.size();
        if (size < 2) {
            return getStartTime();
        } else {
            return splitTimes.get(size - 2);
        }
    }

    public DefaultTableModel getTableModel() {
        return tableModel;
    }

    public int getTableModelRowCount() {
        return tableModel.getRowCount();
    }

    public void clearTableModel() {
        tableModel.setRowCount(0);
    }

    public int addTableModelRow(long startTime, long previousSplitTime, 
            long currentSplitTime, int splitCount) {
        String[] row = new String[3];

        row[0] = "Split " + ++splitCount;
        row[1] = formatTime(previousSplitTime, currentSplitTime, false);
        row[2] = formatTime(startTime, currentSplitTime, false);

        tableModel.addRow(row);

        return splitCount;
    }

    public void setStartTime() {
        if (getStartTime() == 0L) {
            this.startTime = System.currentTimeMillis();
        } else {
            long currentTime = System.currentTimeMillis();
            int size = splitTimes.size();
            if (size > 0) {
                long splitTime = splitTimes.get(size - 1);
                splitTime = splitTime - getEndTime() + currentTime;
                splitTimes.set(size - 1, splitTime);
            }
            this.startTime = currentTime - getEndTime() + getStartTime();
        }
    }

    protected void setTableModel() {
        this.tableModel = new DefaultTableModel();
        this.tableModel.addColumn(columnNames[0]);
        this.tableModel.addColumn(columnNames[1]);
        this.tableModel.addColumn(columnNames[2]);
    }

    public void setSplitTime() {
        this.splitTimes.add(System.currentTimeMillis());
        isSplitTime = true;
    }

    public void setEndTime() {
        Long split = System.currentTimeMillis();
        if (isSplitTime) {
            this.splitTimes.add(split);
        }
        this.endTime = split;
    }

    public String formatTime(long startTime, long time, boolean isTenths) {
        long elapsedTime = time - startTime;

        int seconds = (int) (elapsedTime / 1000L);

        int fraction = (int) (elapsedTime - ((long) seconds * 1000L));
        fraction = (fraction + 5) / 10;
        if (fraction > 99) {
            fraction = 0;
        }
        if (isTenths) {
            fraction = (fraction + 5) / 10;
            if (fraction > 9) {
                fraction = 0;
            }
        }


        int hours = seconds / 3600;
        seconds -= hours * 3600;

        int minutes = seconds / 60;
        seconds -= minutes * 60;

        StringBuilder builder = new StringBuilder();

        builder.append(hours);
        builder.append(":");
        if (minutes < 10) builder.append("0");
        builder.append(minutes);
        builder.append(":");
        if (seconds < 10) builder.append("0");
        builder.append(seconds);
        builder.append(".");
        if ((!isTenths) && (fraction < 10)) builder.append("0");
        builder.append(fraction);

        return builder.toString();
    }

}

import java.util.ArrayList；
导入java.util.List；
导入javax.swing.table.DefaultTableModel；
公共类秒表模型{
受保护布尔isSplitTime；
保护长启动时间；
长期保护；
受保护的DefaultTableModel表模型；
受保护列表拆分时间；
受保护的字符串[]columnNames={“，”增量“，”累积“}；
公共秒表模型（）{
this.splitTimes=new ArrayList（）；
this.isSplitTime=false；
this.startTime=0；
this.endTime=0；
setTableModel（）；
}
公众假期（星期日）{
这是.splitTimes.clear（）；
this.isSplitTime=false；
this.startTime=0；
this.endTime=0；
}
公共布尔值isSplitTime（）{
返回时间；
}
公共长getStartTime（）{
返回起始时间；
}
公共长getEndTime（）{
返回结束时间；
}
公共长getLastSplitTime（）{
int size=splitTimes.size（）；
如果（尺寸<1）{
返回getStartTime（）；
}否则{
返回splitTimes.get（大小-1）；
}
}
公共长getPenultimateSplitTime（）{
int size=splitTimes.size（）；
如果（尺寸<2）{
返回getStartTime（）；
}否则{
返回splitTimes.get（大小-2）；
}
}
公共DefaultTableModel getTableModel（）{
返回表模型；
}
public int getTableModelRowCount（）{
返回tableModel.getRowCount（）；
}
public void clearTableModel（）{
tableModel.setRowCount（0）；
}
public int addTableModelRow（长开始时间、长上次拆分时间、，
长currentSplitTime，int splitCount）{
字符串[]行=新字符串[3]；
行[0]=“拆分”++拆分计数；
行[1]=格式化时间（previousSplitTime、currentSplitTime、false）；
行[2]=格式化时间（startTime、currentSplitTime、false）；
tableModel.addRow（row）；
返回拆分计数；
}
公共无效设置开始时间（）{
如果（getStartTime（）==0L）{
this.startTime=System.currentTimeMillis（）；
}否则{
长currentTime=System.currentTimeMillis（）；
int size=splitTimes.size（）；
如果（大小>0）{
长splitTime=splitTimes.get（大小-1）；
splitTime=splitTime-getEndTime（）+currentTime；
splitTimes.set（大小-1，splitTime）；
}
this.startTime=currentTime-getEndTime（）+getStartTime（）；
}
}
受保护的void setTableModel（）{
this.tableModel=新的DefaultTableModel（）；
this.tableModel.addColumn（columnNames[0]）；
this.tableModel.addColumn（columnNames[1]）；
this.tableModel.addColumn（columnNames[2]）；
}
public void setSplitTime（）{
this.splitTimes.add（System.currentTimeMillis（））；
isSplitTime=true；
}
public void setEndTime（）{
长拆分=System.currentTimeMillis（）；
如果（isSplitTime）{
这个.splitTimes.add（split）；
}
this.endTime=split；
}
公共字符串格式化时间（长启动时间、长时间、，