Java 避免由于相同参数类型而导致构造函数冲突的最佳实践？

虽然这种情况很少发生，但有时我需要两个具有相同参数类型的构造函数，当然每个构造函数的参数角色不同。以下是一个例子：

public class MyClass {
    public MyClass(String title, String content) {
        // ...
    }

    public MyClass(String title, String link) {
        // ...
    }
}

我很想知道你们在这种情况下是怎么做的

在可能的情况下，交换一个构造函数的参数顺序（好的，不是 （以我为例）

放弃战斗，在构造器后面叫一个二传手

从未发生过，因为它应该由设计来管理，比如多态性/继承

使用设计模式

添加一个虚拟的未使用参数，使其唯一（否，真的吗？）

---

编辑：不要自我：我刚刚在

java.util.HashSet

中发现了一件可怕的事情：（对于JDK类来说，即使它是包私有的，也非常令人惊讶）

---

在这种情况下，您可以添加回答类实例的静态方法。如果您喜欢类型化参数，则可以更改名称。为了强制使用这些方法，您可以使用一个声明为私有的无参数构造函数。

在这种情况下，您可以添加响应类实例的静态方法。如果您喜欢类型化参数，则可以更改名称。为了强制使用这些方法，可以使用一个声明为私有的无参数构造函数。

使用。名为

Builder

的嵌套类接受设置，一次接受一个setter方法，而

build（）

方法返回实际的

MyClass

对象

public class MyClass {
   private String title;
   private String content;
   private String link;
   public static class Builder {
      private String title;
      private String content;
      private String link;

      public void setTitle(String title) { this.title = title; }
      public void setContent(String content) { this.content = content; }
      public void setLink(String link) { this.link = link; }
      public MyClass build() {
         return new MyClass(this);
      }
   }

   private MyClass(Builder builder) {
      // Validate here.
      if (builder.title == null)
         throw new IllegalArgumentException("Title is required!");
      this.title = builder.title;
      this.content = builder.content;
      this.link = builder.link;
   }
}

这样参数就不会混淆，构造函数也不会因所有情况而成倍增加。

使用。名为

Builder

的嵌套类接受设置，一次接受一个setter方法，而

build（）

方法返回实际的

MyClass

对象

public class MyClass {
   private String title;
   private String content;
   private String link;
   public static class Builder {
      private String title;
      private String content;
      private String link;

      public void setTitle(String title) { this.title = title; }
      public void setContent(String content) { this.content = content; }
      public void setLink(String link) { this.link = link; }
      public MyClass build() {
         return new MyClass(this);
      }
   }

   private MyClass(Builder builder) {
      // Validate here.
      if (builder.title == null)
         throw new IllegalArgumentException("Title is required!");
      this.title = builder.title;
      this.content = builder.content;
      this.link = builder.link;
   }
}

---

这样参数就不会混淆，构造函数也不会因为所有情况而成倍增加。

您可以这样做

public class Link{ /* constructor from string */ }
public class Content{ /* constructor from string */ }

---

然后分别用链接和内容类重载MyClass构造函数

您可以这样做

public class Link{ /* constructor from string */ }
public class Content{ /* constructor from string */ }

---

然后分别使用Link和Content类重载MyClass构造函数

您可以使用命名工厂方法的列表和私有构造函数：调用方只知道方法的语义，它们的实现是隐藏的。稍后，如果愿意，可以重构代码而不更改调用方

我发现这个解决方案更适合您的目的，IMHO是一个过度设计的解决方案（在您的案例中）

---

您可以使用带有私有构造函数的命名工厂方法列表：调用方只知道方法的语义，它们的实现是隐藏的。稍后，如果愿意，可以重构代码而不更改调用方

我发现这个解决方案更适合您的目的，IMHO是一个过度设计的解决方案（在您的案例中）

---

您可以使用“Builder”模式。您可以使用“Builder”模式。我通常会将Builder对象传递给构造函数。我想这只是偏好的问题。通过传递builder对象，您可以保留签名。嗯，如果您使用一个builder，为什么要公开“build class”构造函数呢？我认为这是一个过度设计的解决方案，我建议采用更轻的方法。我通常会将builder对象传递给构造函数。我想这只是偏好的问题。通过传递生成器对象，您可以保留签名。嗯，如果您使用生成器，为什么要公开“构建类”构造函数？我认为这是一个过度设计的解决方案，我建议采用更轻的方法。谢谢。我认为构建器模式更好，但您的解决方案更简洁，我也会尝试。构建器也可以工作，但如果只能设置一些属性组合，我会看到很多重载。谢谢。我认为构建器模式更好，但您的解决方案更简洁，我也会尝试。构建器也可以工作，但如果只能设置一些属性组合，我会看到很多重载。我同意。类似于@ChrisGerken的提议。我认为是正确的。但是我只写一个（私有）构造点，可能有所有可能的参数——当然，实现者知道，调用者不知道。我同意。类似于@ChrisGerken的提议。我认为是正确的。但我只编写一个（私有）构造点，可能包含所有可能的参数——当然，实现者知道，调用者不知道。