Java - Naming Conventions

痛定思痛。 2023-07-15 13:22 7阅读 0赞

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击[http://www.captainbed.net][http_www.captainbed.net]

**Java naming conventions** are sort of guidelines that application programmers are expected to follow to produce a consistent and readable code throughout the application. We should follow these naming conventions in the day to day project work.

### 1. Packages naming conventions ###

A package should be named in lowercase characters. There should be only one English word after each dot.

The prefix of a unique package name is always written in all-lowercase ASCII letters and should be one of the top-level domain names, like *com, edu, gov, mil, net, org*.

Example:

package org.springframework.core.convert;
    package org.hibernate.criterion;
    package org.springframework.boot.actuate.audit;
    package org.apache.tools.ant.dispatch;

Package naming convention used by Oracle for the Java core packages. The initial package name representing the domain name must be in lower case.

package java.lang;
    package java.util;

### 2. Classes naming conventions ###

Class names should be *nouns* in *UpperCamelCase *(in mixed case with the first letter of each internal word capitalized). Try to keep your class names simple and descriptive.

Example:

class Employee
    class Student
    class EmployeeDao
    class CompanyService

The class naming convention used by Oracle for the Java core packages.

class String
    class Color
    class Button
    class System
    class Thread
    class Character
    class Compiler
    class Number

### 3. Interfaces naming conventions ###

In Java, interfaces names, generally, should be **adjectives**. Interfaces should be in titlecase with the first letter of each separate word capitalized. In some cases, interfaces can be nouns as well when they present a family of classes e.g. *List* and *Map*.

Example:

Runnable
    Remote
    ActionListener
    Appendable
    AutoCloseable
    CharSequence
    Cloneable
    Comparable
    Readable

### 4. Methods naming conventions ###

Methods always should be **verbs**. They represent action and the method name should clearly state the action they perform. The method name can be single or 2-3 words as needed to clearly represent the action. Words should be in **camel case notation**.  
Examples:

public List <Customer> getCustomers();
    
    public void saveCustomer(Customer theCustomer);
    
    public Customer getCustomer(int theId);
    
    public void deleteCustomer(int theId);

More Examples:

getName()
    computeTotalWidth()
    actionPerformed()
    main()
    print()
    println()

### 5. Variables naming conventions ###

The variable name should start with a lowercase letter. Parameter names, member variable names, and local variable names should be written in *lowerCamelCase*.

Example:

firstName
    orderNumber
    lastName
    phoneNo
    id
    counter
    temp

### 6. Constants naming conventions ###

Constant variable names should be written in upper characters separated by *underscores*. These names should be semantically complete and clear.

Example:

RED
    YELLOW
    MAX_PRIORITY
    MAX_STOCK_COUNT

### 7. Abstract classes naming conventions ###

I observed in many standard libraries, the naming conventions used for *Abstract* class is class name must start with *Abstract or Base* prefix. This naming convention can vary from organization to organization.

Example:

AbstractHibernateDao
    AbstractCommonDao
    AbstractBase

Let's take an example from the Spring Framework:

AbstractBean
    AbstractBeanDefinition
    AbstractUrlBasedView
    AbstractIdentifiable

### 8. Exception classes naming conventions ###

I observed in many standard libraries, the naming conventions used for custom *Exception* class is class name must end with *Exception* suffix.

Example:

TransactionException
    SQLDataException
    ResourceNotFountException
    ResourceAlreadyExistException

The exception class naming convention used by Oracle for the Java core packages.

ArithmeticException
    ArrayIndexOutOfBoundsException
    ArrayIndexOutOfBoundsException
    ClassNotFoundException
    CloneNotSupportedException
    EnumConstantNotPresentException
    Exception
    IllegalAccessException
    IllegalArgumentException
    IllegalMonitorStateException
    IllegalStateException
    IllegalThreadStateException
    IndexOutOfBoundsException

### 9. Enumeration naming conventions ###

Enum Class members should be spelled out in upper case words, separated by underlines.

Example:

public enum Day {
        SUNDAY,
        MONDAY,
        TUESDAY,
        WEDNESDAY,
        THURSDAY,
        FRIDAY,
        SATURDAY;
    }

### 10. Generic types naming conventions ###

Generic type parameter names should be uppercase single letters. The letter *'T'* for a type is typically recommended. In JDK classes, *E* is used for collection elements, *S* is used for service loaders, and *K* and *V* are used for map keys and values.

Example:

public interface Map <K,V> {}
    public interface List<E> extends Collection<E> {}
    Iterator<E> iterator() {}

### 11. Annotations naming conventions ###

Annotation names follow title case notation. They can be adjective, verb or noun based on the requirements.

Example:

public @interface FunctionalInterface {}
    public @interface Deprecated {}
    public @interface Documented {}
    public @Async Documented {}
    public @Test Documented {}

### 12. Other Specific Naming Conventions ###

Apart from the above java standard naming conventions, there are few more naming conventions that would be followed in many standard libraries such as Spring, Apache, Hibernate etc.

Note that these naming conventions can be varied as per different libraries or organizations.

*is* prefix can be used for boolean variables and methods.

This is the naming convention for *boolean* methods and variables used by Oracle for the Java core packages.

Using the is prefix solves a common problem of choosing bad boolean names like status or flag. *isStatus* or *isFlag* simply doesn't fit, and the programmer is forced to choose more meaningful names.

Setter methods for boolean variables must have set prefix as in:

void setFound(boolean isFound);

There are a few alternatives to the *is* a prefix that fits better in some situations. These have, can and should prefixes:

boolean hasLicense();
    boolean canEvaluate();
    boolean shouldAbort = false;

The term *compute* can be used in methods where something is computed.

valueSet.computeAverage();
    matrix.computeInverse();

Give the reader the immediate clue that this is a potentially time-consuming operation, and if used repeatedly, he might consider caching the result. Consistent use of the term enhances readability.

The term *find* can be used in methods where something is looked up.

vertex.findNearestVertex();
    matrix.findSmallestElement();
    node.findShortestPath(Node destinationNode);

Give the reader the immediate clue that this is a simple lookup method with a minimum of computations involved. Consistent use of the term enhances readability.

The term *initialize* can be used where an object or a concept is established.

printer.initializeFontSet();

The *Plural* form can be used on names representing a collection of objects.

Collection<Point>  points;
    int[]              values;

Enhances readability since the name gives the user an immediate clue of the type of the variable and the operations that can be performed on its elements.

Generic variables should have the same name as their type.

void setTopic(Topic topic) // NOT: void setTopic(Topic value)
                               // NOT: void setTopic(Topic aTopic)
                               // NOT: void setTopic(Topic t)
    
    void connect(Database database) // NOT: void connect(Database db)
                                    // NOT: void connect(Database oracleDB)

The name of the object is implicit and should be avoided in a method name.

line.getLength();   // NOT: line.getLineLength();

[http_www.captainbed.net]: http://www.captainbed.net/troubleshooter