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.
