Java Development Tips: Reduce the Use of Magic Points

1. preface

A similar writing approach is encountered when refactoring old code:

    public void attend(String value) {
        if ("0".equals(value)) {
            //todo 
        } else if ("1".equals(value)) {
            //todo
        } else {
            //todo 
        }
    }

My skull hurts! from Java The grammar is impeccable, but it is incomprehensible from a business perspective 0 and 1 They are collectively calledmana 。We often need to infer the above code through context. If it is a very complex business or code from 10 years ago, it will be even worse, and there may be no documentation. So we should try to avoid magic points. Today, I will talk about a few operations to avoid magic points.

2. Avoid some operations with magic points.

Generally, magic points do not change frequently. The processing of magic values should be combined with business and scope.

2.1 static constants

If the scope of the value is in a class or under the same package, static constants can generally be used to resolve it.

    private static final String FEMALE = "0";
    private static final String MALE = "1";
    public void attend(String value) {
        if (FEMALE.equals(value)) {
            //todo
        } else if (MALE.equals(value)) {
            //todo
        } else {
            //todo
        }
    }

Doesn't this make it much clearer? 0 and 1 Represents gender (of course, it needs to match your good variable naming habits).

2.2 using the interface

Since we use static constants, it is possible for us to encapsulate magic values into the interface.

public interface Gender {
    String FEMALE = "0";
    String MALE = "1";
}

2.3 using an enumeration

However, the significance of the interface is to provide abstract functions rather than storing some constant values, which obviously violates the original intention of the interface design. sojdk1.5Introduced enumeration types enum。

public enum GenderEnum {
    FEMALE,
    MALE
}

In many cases, this writing is enough, and you can use GenderEnum.MALE.ordinal() Get the numerical sequence number corresponding to the enumeration, or you can use theGenderEnum.MALE.name() Gets the string name of the corresponding enumeration. They can be used for some logical identification in most cases. But it cannot satisfy our original design above. We need to modify the constructor of the enumeration class.

public enum GenderEnum {

    FEMALE("0"),
    MALE("1");

    private final String value;

    GenderEnum(String value) {
        this.value = value;

    }

    public String value() {
        return this.value;
    }
}

So that after rewriting it, we can pass value() The method gets the specific value.

Let's add more requirements to ourselves to make your enumeration more readable.

public enum GenderEnum {

    UNKNOWN("-1", "Unknown"),
    FEMALE("0", "Female"),
    MALE("1", "Male");

    private final String value;
    private final String description;

    GenderEnum(String value, String description) {
        this.value = value;
        this.description = description;
    }

    public String value() {
        return this.value;
    }

    public String description() {
        return this.description;
    }
}

description Value not only helps us know what the enumeration actually represents, but can even be returned to the front-end business as a description.

Tip: Try not to use Chinese statements, such as FEMALE Directly declared as women。Also, enumerations are singleton, so clone and deserialization cannot be used.

3. summary

Today we learned how to gracefully handle magic values in coding, especially enumeration schemes.