Question

我创建了一个抽象类A，它实现了常用的方法。现在我意识到新类必须使用相同的方法但具有不同的属性值。以下是一个快速摘要：

public abstract class A implement IUtils {
  protected final String LOGIN_XPATH = "xpathA";

  public String getLoginName() {
    return getXpath(LOGIN_XPATH);
  }
}

public class B extends A {
  private final String LOGIN_XPATH = "xpathB";
}

调用B.getXpath（）将导致调用super方法，从而使用“xpathA”。我希望它使用“xpathB”。我考虑过使用A类中的以下组合：

public abstract class A implement IUtils {
  protected IXpaths xpaths = null;

  public A() {
    xpaths = new XPathsClass();
  }  

  public String getLoginName() {
    return getXpath(xpaths.getXpath(StaticString.LOGIN_XPATH));
  }
}

public class StaticString {
  public final String LOGIN_XPATH = "LOGIN_XPATH";
}

public class XPathsClass implements IXpaths {
  private static final Map<String, String> conversionMap = new HashMap<String, String>();

  static {
    conversionMap.put(StaticString.LOGIN_XPATH, "xpathA");
  }

  public String getValue(String query) {
    return conversionMap.get(query);
  }
}

public class XPathsClassB implements IXpaths {
  private static final Map<String, String> conversionMap = new HashMap<String, String>();

  static {
    conversionMap.put(StaticString.LOGIN_XPATH, "xpathB");
  }

  public String getValue(String query) {
    return conversionMap.get(query);
  }
}

public class B extends A {
  public B() {
    super();
    xpaths = new XPathsClassB();
  }
}

这似乎有效，但它使得它很长并且更难以阅读。什么是更好的方式？

Answer 1

是的，我真的不喜欢静态在Java中的子类中工作的方式。我们有一个争论......我的意思是讨论......关于这个在另一篇文章中的SO在某处。

但无论如何，我认为最干净的解决方案是：

public abstract class A implement IUtils { 
  public String getXpathValue() {
    return "xpathA";
  }

  public String getLoginName() { 
   return getXpath(getXpathValue()); 
  } 
} 

public class B extends A { 
  public String getXpathValue() {
    return "xpathB";
  }
}

如果每个子类都应该有自己的Xpath值，那么在A abstract中创建getXpath函数。然后，如果您忘记在子类中实现它，您将收到编译时错误。

Answer 2

你真的有两个选择：

在基类中有一个变量，并添加一个受保护的setter方法，以便子类可以将其设置为新值
根本没有变量，并覆盖每个子类中的方法，以便返回正确的String。

我推荐解决方案2 - 通过覆盖方法解决

具有类特定属性的最佳解决方案

2 个答案: