Question

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

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

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

User user1 = new User（33， Jack ）;
用户user2 =新用户（33，麻雀）；

由于姓名和姓氏均来自同一数据类型，因此无法知道用户要设置的值。

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

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

User user1 = new User（33， Jack ）;
用户user2 =新用户（33，null， 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

    }

}

有没有更优雅的方法呢？

Answer 1

执行此操作的典型方法是使用静态创建方法或构建器对象。

如果存在独特的使用模式，则应采用静态创建方法。对于您的示例（可能不是这种情况）。

public static User ageName(int age, String name) {
    ...
}  
public static User ageSurname(int age, String surname) {
    ...
}
...

通常，最好避免任何过载。使用构造函数，Java会迫使您加入其中，但有时您必须挣脱。

Builder可能类似于：

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();

您确实需要真实的用法示例，以了解其用法。

Answer 2

您在这里使用HashMap使事情变得过于复杂。相反，您可以使用Builder Pattern来实现相同的目的。

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();

这假设age是一个强制字段，name和surname是用于创建{ {1}}。您可以根据需要对其进行相应的调整。

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

2 个答案: