Java Language
Fluent Interface

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


Osservazioni

obiettivi

L'obiettivo principale di un'interfaccia fluida è la leggibilità aumentata.

Quando viene utilizzato per la costruzione di oggetti, le scelte disponibili per il chiamante possono essere rese chiare e applicate tramite controlli in fase di compilazione. Ad esempio, si consideri il seguente albero di opzioni che rappresentano passi lungo il percorso per costruire un oggetto complesso: 

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

Un costruttore che utilizza un'interfaccia fluente consentirebbe al chiamante di vedere facilmente quali opzioni sono disponibili in ogni fase. Ad esempio, A -> B è possibile, ma A -> C non lo è e risulterebbe in un errore in fase di compilazione.

Truth - Fluent Testing Framework

Da "Come usare la verità" 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();

Ottimo stile di programmazione

Nello stile di programmazione fluente si restituisce this metodo da metodi fluenti (setter) che non restituirebbero nulla in uno stile di programmazione non fluente.

Ciò consente di concatenare le diverse chiamate di metodo che rendono il codice più breve e più facile da gestire per gli sviluppatori.

Considera questo codice non fluente: 

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());
  }
}

Siccome i metodi di settaggio non restituiscono nulla, abbiamo bisogno di 4 istruzioni nel metodo main per istanziare una Person con alcuni dati e stamparla. Con uno stile fluido questo codice può essere cambiato 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());
  }
}

L'idea è di restituire sempre alcuni oggetti per abilitare la costruzione di una catena di chiamate di metodo e di usare nomi di metodi che riflettano il linguaggio naturale. Questo stile fluente rende il codice più leggibile.



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow