How to deal with constructor with different arguments

public class Person{

     private String name;
     private int age;
     private int level;
     private int id;

     public Person(String name, int age, int level, int id){
        //...
     }
}

I can only have 4 arguments when I create a new Person object. But I want to make it valid when there is no level or id or both. So I created 3 more constructors to do this. But is there any efficient way? I think too many constructors is bad.

use lombok @Builder

@Builder
Public Class Person{
     private String name;
     private int age;
     private int level;
     private int id;
}

create

Person.builder().age(1).build();
Person.builder().id(1).age(1).build();

I personally don't see anything wrong with a class utilizing several constructors however there are pro's and con's to everything.

If you want to maintain only a single constructor and optionally supply what you want then perhaps something like this may help:

public class Person {
private String name;
private int age;
private int level;
private int id;
/**
* This constructor is setup so that it can be supplied with any number of 
* field arguments or none at all (rely on Setters). If arguments are supplied 
* then they <b>must</b> be supplied is the following order:<pre>
* 
*              <b>Name, Age, Level, ID</b></pre><br>
* 
* You can not supply: <b>Name, Level, ID</b> however if you want to skip a 
* parameter then you can supply: <b>Name, null, Level, ID</b>. If a Null or 
* a Null String ("") is supplied to a parameter then the value for that field 
* the parameter is related to is not changed and the declared default would 
* apply to it. The following would be a valid uses of this constructor:<pre>
* 
*      Person p = new Person();
*      Person p = new Person("John Doe", 34, 366, 1001);
*      Person p = new Person("John Doe", 34, 366);
*      Person p = new Person("John Doe", 34);
*      Person p = new Person("John Doe");
*      Person p = new Person("John Doe", null, 366, 1001);
*      Person p = new Person(null, null, 366, 1001);
*      Person p = new Person("", "", 366, 1001);
*      Person p = new Person("", "", 366, null);
*      Person p = new Person("John Doe", "34", "366", "1001");
*      Person p = new Person("John Doe", "34", "", "1001");
* 
* as some examples.</pre>
* 
* You will of noticed in the constructor examples above that any one the parameters can 
* be supplied a string. Where Integers are required there can be string representations 
* of integer values...as long as they are valid integer representations. If the a 
* any numerical value is supplied to the <b>name</b> parameter then an exception is 
* thrown.
* 
* @param args (Optional - Object) The optional parameters to be supplied if desired. 
* The parameters follow this entry order: <b>Name, Age, Level, ID</b>. Name must be 
* a string, Age must be Integer or a string representation of an Integer, Level must 
* be Integer or a string representation of an Integer, ID must be Integer or a string 
* representation of an Integer. Any parameter can be passed a Null or a Null String ("") 
* in which case that corresponding parameter's related field will fall to its default 
* value.
*/
public Person(Object... args) {
if (args.length > 0) {
String invalidString = "Person Class Constructor Error - "
+ "Invalid Argument Supplied! (" + java.util.Arrays.toString(args)
.replaceAll("[\\[\\]]", "") + ")";
try {
// Name parameter...
if (args.length >= 1 && args[0] != null && !args[0].toString().equals("")) {
if (args[0].toString().matches("\\D+")) {
this.name = args[0].toString();
}
else {
throw new Exception("Not a proper String for Name field! "
+ "It contains digits!");
}
}
// Age parameter...
if (args.length >= 2 && args[1] != null && !args[1].toString().equals("")) {
if (args[1].toString().matches("\\d{1,3}")) {
if (args[1] instanceof String && !args[1].toString().equals("")) {
args[1] = Integer.valueOf(args[1].toString());
}
if (!args[1].toString().equals("")) {
this.age = (int) args[1];
}
}
else {
throw new Exception("Not a proper Integer value for Age field!");
}
}
// Level parameter...
if (args.length >= 3 && args[2] != null && !args[2].toString().equals("")) {
if (args[2].toString().matches("\\d+")) {
if (args[2] instanceof String && !args[2].toString().equals("")) {
args[2] = Integer.valueOf(args[2].toString());
}
if (!args[2].toString().equals("")) {
this.level = (int) args[2];
}
}
else {
throw new Exception("Not a proper Integer value for Level field!");
}
}
// ID parameter...
if (args.length >= 4 && args[3] != null && !args[3].toString().equals("")) {
if (args[3].toString().matches("\\d+")) {
if (args[3] instanceof String && !args[3].toString().equals("")) {
args[3] = Integer.valueOf(args[3].toString());
}
if (!args[3].toString().equals("")) {
this.id = (int) args[3];
}
}
else {
throw new Exception("Not a proper Integer value for ID field!");
}
}
}
catch (Exception ex) {
System.err.println(invalidString);
System.err.println(ex.toString());
// Close Application! 
// Do whatever you like on a Constructor Failure.
System.exit(0); 
}
}
}
// GETTERS and SETTERS
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
// An overriden toString() method 
@Override
public String toString() {
return new StringBuilder("").append("Name = ").append(name).append(", Age = ")
.append(age).append(", Level = ").append(level).append(", ID = ")
.append(id).toString();
}
}

Example Constructor Usage:

Person p = new Person("John Doe", 34, 366, 1001);
System.out.println(p.toString());

Read the Constructor's JavaDoc.