Difference between revisions of "Naming convention"

Revision as of 08:54, 5 February 2021

Java naming convention

Getters and setters

• Getters (get, is)
  • Takes no parameters
  • Does not alter the object in any way; it is constant
  • Can be called multiple times, and in any order
  • Returns a consistent single result

public String getName() {
  return this.name;
}

public boolean isAdult() {
  return true;
}

• Setters (set)
  • Takes one parameter
  • May or may not alter the object
  • Only affects the object that has the setter; it does not persist anywhere else
  • Can be called multiple times, and in any order

public void setName(String name) {
  this.name = name;
}

Finders & filters

• Finders (find)
  • Takes zero or more arguments (which act as filter or sorting controls)
  • Does not alter the object in any way; it is constant
  • Can be called multiple times, and in any order
  • Returns a consistent, single, non-null collection result (or an empty Optional) - never null

public List<String> findNames() {
  return Collections.emptyList();
}

public Optional<Person> findById(String personId) {
  return Optional.empty();
}

Factories

• Factories
  • Responsible for creating objects - not persisting them!
  • Are stateless

• Factory classes
  • Conform to [ObjectType]Factory naming convention

• Factory methods
  • Conform to create[ObjectType] naming convention

public Person createPerson(String name) {
  Person person = new Person();
  person.setName(name);
  return person;
}

Other

• Populator methods (imbue)
  • Only modify the object(s) passed as arguments
  • Does not affect the object's state

public Person imbueDefaults(Person person) {
  if(person.getName()==null) {
    person.setName(person.getFirstName() + " " + person.getLastName() );
  }
  return person;
}

Persistance

• Repositories
  • Conform to [ObjectType]Repository naming convention
  • Methods such as save*, load*, find*, read*, write*, delete*

Adapter

An Adapter is a class that takes one or more objects and implements an interface. i.e. it adapts an X so it looks like a Y.

public class EmployedPersonAdapter implements IEmployedPerson {
  public EmployedPersonAdapter(Person person) {
    ...
  }
  ...
}