Java Language
Vloeiende interface

algorithm Android HTML javafx JavaScript MySQL Regular Expressions spring spring-boot SQL
Zoeken…


Opmerkingen

Goals

Het primaire doel van een vloeiende interface is een verhoogde leesbaarheid.

Wanneer gebruikt voor het construeren van objecten, kunnen de keuzes die beschikbaar zijn voor de beller duidelijk worden gemaakt en worden afgedwongen via compilatiecontroles. Overweeg bijvoorbeeld de volgende boom met opties die stappen langs het pad vertegenwoordigen om een complex object te construeren: 

A -> B 
  -> C -> D -> Done
       -> E -> Done
       -> F -> Done.
       -> G -> H -> I -> Done.

Met een bouwer die een vloeiende interface gebruikt, kan de beller gemakkelijk zien welke opties beschikbaar zijn bij elke stap. A -> B is bijvoorbeeld mogelijk, maar A -> C is dat niet en zou resulteren in een compilatie-fout.

Waarheid - Vloeiend testkader

Van "Hoe de waarheid te gebruiken" http://google.github.io/truth/ 

String string = "awesome";
assertThat(string).startsWith("awe");
assertWithMessage("Without me, it's just aweso").that(string).contains("me");

Iterable<Color> googleColors = googleLogo.getColors();
assertThat(googleColors)
    .containsExactly(BLUE, RED, YELLOW, BLUE, GREEN, RED)
    .inOrder();

Vloeiende programmeerstijl

In vloeiende programmeerstijl retourneer je this van vloeiende (setter) methoden die niets zouden opleveren in niet-vloeiende programmeerstijl.

Hiermee kunt u de verschillende methodeaanroepen koppelen, waardoor uw code korter en gemakkelijker te hanteren is voor de ontwikkelaars.

Overweeg deze niet-vloeiende code: 

public class Person {
  private  String firstName;
  private String lastName;

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String whoAreYou() {
    return "I am " + firstName + " " + lastName;
  }

  public static void main(String[] args) {
    Person person = new Person();
    person.setFirstName("John");
    person.setLastName("Doe");
    System.out.println(person.whoAreYou());
  }
}

Omdat de setter methoden niet terugkeert niets, moeten we 4 instructies in de main methode om een instantie van Person met een aantal gegevens en afdrukken. Met een vloeiende stijl kan deze code worden gewijzigd in: 

public class Person {
  private  String firstName;
  private String lastName;

  public String getFirstName() {
    return firstName;
  }

  public Person withFirstName(String firstName) {
    this.firstName = firstName;
    return this;
  }

  public String getLastName() {
    return lastName;
  }

  public Person withLastName(String lastName) {
    this.lastName = lastName;
    return this;
  }

  public String whoAreYou() {
    return "I am " + firstName + " " + lastName;
  }

  public static void main(String[] args) {
    System.out.println(new Person().withFirstName("John")
      .withLastName("Doe").whoAreYou());
  }
}

Het idee is om altijd een object te retourneren om het bouwen van een methodeaanroepketen mogelijk te maken en methodennamen te gebruiken die natuurlijk spreken weerspiegelen. Deze vloeiende stijl maakt de code leesbaarder.



Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow