Os argumentos nomeados substituem o padrão do construtor?

Ao usar uma linguagem que suporta argumentos nomeados e opcionais, o padrão do construtor não tem mais um uso prático?

Construtor:

new Builder(requiredA, requiredB).setOptionalA("optional").Build();

Argumentos opcionais / nomeados:

new Object(requiredA, requiredB, optionalA: "optional");

Os construtores são mais úteis quando seu objeto precisa de muitos argumentos / dependências para ser útil, ou você deseja permitir várias maneiras diferentes de construir o objeto.

Em cima da minha cabeça, eu posso imaginar que alguém possa querer "construir" objetos em um jogo 3D como este:

// Just ignore the fact that this hypothetical god class is coupled to everything ever
new ObjectBuilder(x, y, z).importBlenderMesh("./meshes/foo")
                          .syncWithOtherPlayers(serverIP)
                          .compileShaders("./shaders/foo.vert", "./shaders/foo.frag")
                          .makeDestructibleRigidBody(health, weight)
                          ...

Eu diria que este exemplo é mais legível com os métodos construtores que criei agora do que com parâmetros opcionais:

new Object(x, y, z, meshType: MESH.BLENDER,
                    meshPath: "./meshes/foo",
                    serverToSyncWith: serverIP,
                    vertexShader: "./shaders/foo.vert",
                    physicsType: PHYSICS_ENGINE.RIGID_DESTRUCTIBLE,
                    health: health,
                    weight: weight)
                    ...

Em particular, as informações implícitas nos nomes dos métodos do construtor precisam ser substituídas por mais parâmetros, e é muito mais fácil esquecer um parâmetro em um grupo de parâmetros intimamente relacionados. De fato, o shader de fragmento está ausente, mas você não notaria isso a menos que soubesse procurá-lo.

Obviamente, se o seu objeto precisar de um a cinco argumentos para construir, não há necessidade de envolver o padrão do construtor, independentemente de você ter nomeado / não parâmetros opcionais.

Além do que o Ixrec disse, os construtores ou o método nomeado parâmetros não permitirão que você tenha seu objeto em um estado a ser construído, no qual ele ainda pode ser modificado antes de construí-lo. Esta é a beleza do Construtor, onde você pode delegar partes de sua construção para diferentes métodos ou classes:

var myThingBuilder = new ThingBuilder("table");
myThingBuilder.setAttribute(Attributes.Legs, 4);

inventoryManager.setPrices(myThingBuilder);

// inventory manager
var availableCheapestMaterial = getMaterial();
myThingBuilder.setMaterial(availableCheapestMaterial);

Basicamente, você também pode lançar seu construtor em torno de seu sistema até que esteja pronto para construir o objeto final, permitindo diminuir a quantidade de conhecimento que seu construtor-consumidor precisa ter.

Depende do que você está fazendo com o construtor.

Se você estiver usando o construtor apenas para definir (e variar) propriedades do objeto e (adiar) a criação do objeto, ele poderá ser substituído por parâmetros nomeados.

Substituindo o construtor, você pode ter a troca de legibilidade / uso mencionada pelo @Ixrec (ou pode não o ter, depende do que você está fazendo com o construtor).

No entanto, se o construtor fizer mais do que apenas manter as propriedades e cada etapa da construção envolver lógica, ela não poderá ser substituída.

O MockBuilder é um exemplo em que não pode ser substituído por parâmetros nomeados. Na página:

O padrão do construtor é essencial ao trabalhar com objetos imutáveis. Existem muitos benefícios ao trabalhar com objetos imutáveis, especialmente para tornar seu programa mais robusto na execução em um ambiente simultâneo (ou seja, threads)