Java-使用相同数据类型的多个构造函数

我们如何创建构造函数来设置来自同一数据类型的不同值

创建两个相同的构造函数是不可能的：

public User(int age, String name){
}  
public User(int age, String surname){
}

用户user1=新用户（33，Jack）
用户user2=新用户（33，麻雀）

因为名字和姓氏都来自同一数据类型，所以不可能知道用户想要设置哪个值

---

我们可以创建一个具有所有属性的构造函数，然后为未设置的参数传递null

public User(int age, String name, String surname){
}  

用户user1=新用户（33，Jack）
用户user2=新用户（33，空，Sparrow）

---

有一种方法可以做到这一点，使用HashMap模拟javascript对象文字

package javaapplication;

import java.awt.Color; 
import java.util.HashMap;

public class JavaApplication {

    public static class User {

        public int age;
        public String name;
        public String surname;
        public Color hairColor;

        public User(HashMap<String, Object> arguments) {

            if (arguments.containsKey("hairColor")) {
                this.hairColor = (Color) arguments.get("hairColor");
            }

            if (arguments.containsKey("name")) {
                this.name = (String) arguments.get("name");
            }

            if (arguments.containsKey("surname")) {
                this.surname = (String) arguments.get("surname");
            }

            if (arguments.containsKey("age")) {
                this.age = (int) arguments.get("age");
            }
        }
    }

    public static void main(String[] args) {

        User jack1 = new User(new HashMap<String, Object>() {
            {
                put("hairColor", Color.RED);
                put("name", "Jack");
                put("age", 33);
            }
        });
        System.out.println(jack1.hairColor);  // java.awt.Color[r=255,g=0,b=0]
        System.out.println(jack1.surname);    // null
        System.out.println(jack1.name);       // Jack
        System.out.println(jack1.age);        // 33

        User jack2 = new User(new HashMap<String, Object>() {
            {
                put("hairColor", Color.RED);
                put("surname", "Sparrow");
                put("age", 33);
            }
        });
        System.out.println(jack2.hairColor);    // java.awt.Color[r=255,g=0,b=0]
        System.out.println(jack2.surname);      // Sparrow
        System.out.println(jack2.name);         // null
        System.out.println(jack2.age);          // 33

    }

}

封装javaapplication；
导入java.awt.Color；
导入java.util.HashMap；
公共类Java应用程序{
公共静态类用户{
公共信息；
公共字符串名称；
公共字符串姓氏；
公共色发型；
公共用户（哈希映射参数）{
if（arguments.containsKey（“头发颜色”））{
this.hairolor=（Color）arguments.get（“hairolor”）；
}
if（arguments.containsKey（“名称”））{
this.name=（String）arguments.get（“name”）；
}
if（arguments.containsKey（“姓氏”））{
this.name=（字符串）参数.get（“姓氏”）；
}
if（arguments.containsKey（“年龄”））{
this.age=（int）arguments.get（“age”）；
}
}
}
公共静态void main（字符串[]args）{
User jack1=新用户（新HashMap（）{
{
put（“头发颜色”，颜色为红色）；
放入（“姓名”、“杰克”）；
put（“年龄”，33岁）；
}
});
System.out.println（jack1.hairColor）；//java.awt.Color[r=255，g=0，b=0]
System.out.println（jack1.name）；//null
System.out.println（jack1.name）；//Jack
System.out.println（jack1.age）；//33
用户jack2=新用户（新HashMap（）{
{
put（“头发颜色”，颜色为红色）；
放（“姓”、“麻雀”）；
put（“年龄”，33岁）；
}
});
System.out.println（jack2.hairColor）；//java.awt.Color[r=255，g=0，b=0]
System.out.println（jack2.姓氏）；//Sparrow
System.out.println（jack2.name）；//null
System.out.println（jack2.age）；//33
}
}

---

有更优雅的方法吗？

典型的方法是使用静态创建方法或生成器对象

如果有不同的使用模式，静态创建方法就是一条出路。以你为例（情况可能并非如此）

一般来说，避免过载是个好主意。有了构造器，Java会强迫你进入构造器，但有时你必须挣脱束缚

建筑商可能会这样做：

public class UserBuilder { // This could be made a nested class of User
    private int age = -1;
    private String name;
    private String surname;
    private Color hairColor;

    public UserBuilder age(int age) {
        this.age = age;
        return this;
    }
    // ... other properties ...
    public User build() {
        // Or return new User(this)
        return new User(age, name, surname, hairColor);
    }
}

这使用了典型的Java脏黑客，即在构建器中返回

This

，这样您就可以构建一个火车残骸

User user1 = new UserBuilder().age(33).name("Jack").build();

---

您确实需要使用真实的示例来了解它应该如何适应。

在这里使用HashMap会使事情变得过于复杂。相反，您可以使用相同的

class User {
    // required parameters
    private int age;

    // optional parameters
    private String name;
    private String surname;

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getSurname() {
        return surname;
    }

    private User(UserBuilder userBuilder) {
        this.age = userBuilder.age;
        this.name = userBuilder.name;
        this.surname = userBuilder.surname;
    }

    public static class UserBuilder {
        // required parameters
        private int age;

        // optional parameters
        private String name;
        private String surname;

        public UserBuilder setName(String name) {
            this.name = name;
            return this;
        }

        public UserBuilder setSurname(String surname) {
            this.surname = surname;
            return this;
        }

        public UserBuilder(int age) {
            this.age = age;
        }

        public User build() {
            return new User(this);
        }

    }
}

现在您可以使用它：

User user1 = new User.UserBuilder(12).setName("Jack").build();
User user2 = new User.UserBuilder(12).setSurname("Sparrow").build();

这假设

年龄

是必填字段，

姓名

和

姓氏

是创建

用户

对象的可选字段。您可以根据需要相应地调整它。

new User（）.setName（name）.setSurname（姓氏）.setAge（年龄）。或“静态用户createUsingLastname（…，姓氏）

User user1 = new User.UserBuilder(12).setName("Jack").build();
User user2 = new User.UserBuilder(12).setSurname("Sparrow").build();