Java中的继承和静态成员

我正在做一个包含两个模块的项目。我希望在每个模块中都能提供一个自定义异常，该异常使用自定义错误\代码错误\消息对静态填充属性文件的内部结构，例如HashMap。 我有一个包含静态属性的基本抽象自定义异常：

public abstract class AbstractException extends RuntimeException{
   public static Map<String, String> ERRORS = new HashMap<String, String>();
   public String code;
   // getters and setter for code ommited

   public static init(String fileName, Class<?> clazz){
    // read properties file
    // populate map
   }

   public static String getMessageByCode(String code){
    //
   String mess = ERRORS.get(code);
   // in case of null message provide default message about unknown error
   }

   public AbstractException(String code){
      super(getMessageByCode(code));
      this.setCode(code);
   }

   public AbstractException(Throwable thr){
      super(getMessageByCode("ERROR_999"), thr);
      this.setCode(code);
   }

   public AbstractException(Throwable thr, String msg){
      super(getMessageByCode("ERROR_999") + " " + msg, thr);
      this.setCode(code);
   }

}

代码中自定义异常的简单用法：

throw new MyException("ERROR_404");

我在这段代码中看到的问题：

存在抽象异常的所有子类的错误映射

对静态错误字段的并发访问

---

问题是，如何避免这些问题，可能有人能更好地解决我的问题？

此设计将不起作用，因为只有一个

错误的副本，在所有子类之间共享。一种可能的解决方案是ExceptionFactory，它管理各种
错误
映射，并可以为您创建所需子类的异常。比如说

public static class AbstractException extends RuntimeException 
{ 
    String code;
    String message;
    public void setCode(String code) { this.code = code; }
    public void setMessage(String message) { this.message = message; }
}

public static class MyException1 extends AbstractException{ }

public static class MyException2 extends AbstractException{ }

public static class ExceptionFactory
{
    private Map<Class<?>,Map<String,String>> errorMaps = new HashMap<Class<?>, Map<String,String>>();
    public void register(Class<? extends AbstractException> exType, String fileName)
    {
        Map<String,String> errors = new HashMap<String,String>();
        // load errors from fileName
        errorMaps.put(exType, errors);
    }

    public <T extends AbstractException> T newException(Class<T> exType, String code)
    {
        Map<String,String> map = errorMaps.get(exType);
        String message = map.get(code);
        T ex;
        try
        {
            ex = exType.newInstance();
            ex.setCode(code);
            ex.setMessage(message);
            return ex;
        }
        catch(InstantiationException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IllegalAccessException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

公共静态类AbstractException扩展了RuntimeException
{ 
字符串代码；
字符串消息；
public void setCode（字符串代码）{this.code=code；}
public void setMessage（字符串消息）{this.message=message；}
}
公共静态类MyException1扩展了AbstractException{}
公共静态类MyException2扩展了AbstractException{}
公共静态类例外工厂
{
私有地图，地图>（）；
public void register（Class此设计不起作用，因为只有一个
错误
，在所有子类之间共享。一个可能的解决方案是使用ExceptionFactory管理各种
错误
映射，并可以为您创建所需子类的异常。例如

public static class AbstractException extends RuntimeException 
{ 
    String code;
    String message;
    public void setCode(String code) { this.code = code; }
    public void setMessage(String message) { this.message = message; }
}

public static class MyException1 extends AbstractException{ }

public static class MyException2 extends AbstractException{ }

public static class ExceptionFactory
{
    private Map<Class<?>,Map<String,String>> errorMaps = new HashMap<Class<?>, Map<String,String>>();
    public void register(Class<? extends AbstractException> exType, String fileName)
    {
        Map<String,String> errors = new HashMap<String,String>();
        // load errors from fileName
        errorMaps.put(exType, errors);
    }

    public <T extends AbstractException> T newException(Class<T> exType, String code)
    {
        Map<String,String> map = errorMaps.get(exType);
        String message = map.get(code);
        T ex;
        try
        {
            ex = exType.newInstance();
            ex.setCode(code);
            ex.setMessage(message);
            return ex;
        }
        catch(InstantiationException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IllegalAccessException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

公共静态类AbstractException扩展了RuntimeException
{ 
字符串代码；
字符串消息；
public void setCode（字符串代码）{this.code=code；}
public void setMessage（字符串消息）{this.message=message；}
}
公共静态类MyException1扩展了AbstractException{}
公共静态类MyException2扩展了AbstractException{}
公共静态类例外工厂
{
私有地图，地图>（）；
公共无效登记册（类你想在模块之间共享错误消息吗？并发访问静态错误时会出现什么问题？这些静态成员没有脏读/写，不是吗？也许你应该使用
java.util.logging
。你真的需要将这些错误保留在内存中吗？2不，我不想。使用公共父类我只想让Incapculate具有相同的逻辑填充和使用错误映射。是同步的，而HashMap不是。你想在模块之间共享错误消息吗？并发访问静态错误时会出现什么问题？这些静态成员没有脏读/写，不是吗？也许你应该使用
java.util.logging
Instead。您真的需要将这些错误保留在内存中吗？2Brian不，我不需要。对于公共父类，我只想让包含相同逻辑的错误映射填充和使用。是同步的，而HashMap不是。