如何避免方法传入多个同类型参数？String不可继承的简洁实现方案

这个问题我太有共鸣了——确实，String是final类没法继承，想靠子类区分参数语义的路子走不通，但有几个超简洁的方案能完美解决这个问题，完全贴合Clean Code的理念：

1. 优先用Java记录类（Java 16+）：极简且类型安全 #

这是最省事的方案，一行代码就能定义一个语义明确的包装类，Java会自动帮你生成构造方法、getter、equals、hashCode和toString：

public record Author(String value) {}
public record Illustrator(String value) {}
public record Publisher(String value) {}

之后你的方法参数就可以写成：

public void createBook(Author author, Illustrator illustrator, Publisher publisher) {
    // 业务逻辑
    String authorName = author.value();
}

调用的时候必须显式创建对应类型的实例，从根源上杜绝顺序错误：

createBook(new Author("J.K.罗琳"), new Illustrator("吉姆·凯"), new Publisher("布鲁姆斯伯里出版社"));

每个参数的语义一目了然，完全不用怕搞混，代码也干净到极致。

2. Java 16之前？用轻量级值对象 #

如果还在用旧版本Java，那就写几个极简的值对象类，不用基类，每个类只负责包装String并提供语义：

import java.util.Objects;

public class Author {
    private final String name;

    public Author(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 可选：重写equals和hashCode，方便集合操作或比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Author author = (Author) o;
        return Objects.equals(name, author.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

Illustrator和Publisher类依葫芦画瓢就行，虽然比记录类多几行，但依然很简洁，没有冗余，每个类只承担单一职责，语义清晰。

3. 不想创建太多小类？试试建造者模式 #

如果觉得三个小类有点“繁琐”（其实真的还好），可以用建造者模式把参数打包成一个语义明确的对象：

public class BookMetadata {
    private String author;
    private String illustrator;
    private String publisher;

    private BookMetadata() {}

    public static Builder builder() {
        return new Builder();
    }

    // 提供getter供业务逻辑使用
    public String getAuthor() { return author; }
    public String getIllustrator() { return illustrator; }
    public String getPublisher() { return publisher; }

    public static class Builder {
        private final BookMetadata metadata = new BookMetadata();

        public Builder author(String author) {
            metadata.author = author;
            return this;
        }

        public Builder illustrator(String illustrator) {
            metadata.illustrator = illustrator;
            return this;
        }

        public Builder publisher(String publisher) {
            metadata.publisher = publisher;
            return this;
        }

        public BookMetadata build() {
            return metadata;
        }
    }
}

调用的时候用链式调用指定参数，完全不用管顺序：

createBook(BookMetadata.builder()
        .author("J.K.罗琳")
        .publisher("布鲁姆斯伯里出版社")
        .illustrator("吉姆·凯")
        .build());

这种方式适合后续可能需要扩展更多参数的场景，灵活性更高。

总结 #

优先推荐记录类，因为它是Java官方提供的解决这类问题的最优解，代码最少、类型最安全、语义最清晰。如果用不了Java 16，轻量级值对象是第二选择，完全没有冗余。建造者模式则适合参数较多或需要灵活配置的场景。

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