Benefits and drawbacks of method chaining and a possibility to replace all void return parameters by the object itself

by

Drawbacks

  • Principally it confuses the signature, if something returns a new
    instance I don’t expect it to also be a mutator method. For example if
    a vector has a scale method then if it has a return I would presume
    it returns a new vector scaled by the input, if it doesn’t then I
    would expect it to scale internally.
  • Plus of course you get problems if the class is extended, where partway through your chaining your object gets cast to a supertype. This occurs when a chaining method is declared in the parent class, but used on an instance of the child class.

Benefits

  • It allows mathematical equation style code to be written as full equations without the need for multiple intermediate objects (leading to unnecessary overhead), for example without method chaining the vector triple cross product (as a random example) would have to be written either as

    MyVector3d tripleCrossProduct=(vector1.multiply(vector2)).multiply(vector3);

    which has the disadvantage of creating an intermediate object which must be created and garbage collected, or

    MyVector3d tripleCrossProduct=vector1;
tripleCrossProduct.multiplyLocal(vec2);
tripleCrossProduct.multiplyLocal(vec3);

    which avoids the creation of intermediate objects but is deeply unclear, the variable name tripleCrossProduct is in fact a lie until line 3. However, if you have method chaining this can be written concisely in a normal mathematical way without creating unnecessary intermediate objects.

    MyVector3d tripleCrossProduct=vector1.multiplyLocal(vector2).multiplyLocal(vector3);

    All of this assumes that vector1 is sacrificial and will never need to be used again

  • And of course the obvious benefit; brevity. Even if your operations aren’t linked in the manor of my above example you can still avoid unnecessary references to the object

    SomeObject someObject=new SomeObject();
someObject
  .someOperation()
  .someOtherOperation();

NB MyVector3d is not being used as a real class of Java, but is assumed to perform the cross product when .multiply() methods are called. .cross() is not used so that the ‘intention’ is clearer to those not familiar with vector calculus
NB Amit’s solution was the first answer to use multiline method chaining, I include it as part of the forth bullet point for completeness

More Related Contents:

  1. Finding a good design pattern for Java
  2. Design Patterns web based applications [closed]
  3. Singletons vs. Application Context in Android?
  4. Implementing Singleton with an Enum (in Java)
  5. Design Patterns: Factory vs Factory method vs Abstract Factory
  6. What is the solution for the N+1 issue in JPA and Hibernate?
  7. Long list of if statements in Java
  8. Subclassing a Java Builder class
  9. Use Cases and Examples of GoF Decorator Pattern for IO
  10. Spring AOP vs AspectJ
  11. Builder Pattern in Effective Java
  12. Best way to build a Plugin system with Java
  13. How to avoid ‘instanceof’ when implementing factory design pattern?
  14. Visitor pattern’s purpose with examples [duplicate]
  15. Is it bad practice to make a setter return “this”?
  16. Other Ways of Singleton in Java [duplicate]
  17. Open Session In View Pattern
  18. How to get all classes names in a package? [duplicate]
  19. In simplest terms, what is a factory?
  20. Why does every object in Java implicitly extend java.lang.Object class?
  21. Parcelable and inheritance in Android
  22. should a db connection be a singleton?
  23. Advantages of Java’s enum over the old “Typesafe Enum” pattern?
  24. Creation of Objects: Constructors or Static Factory Methods
  25. Java collections covariance problem
  26. Why use a singleton instead of static methods?
  27. When would the garbage collector erase an instance of an object that uses Singleton pattern?
  28. Why Java allows increasing the visibility of protected methods in child class?
  29. How to improve the builder pattern?
  30. Does the Bridge Pattern decouples an abstraction from implementation?

Leave a Comment