Chaining methods of different class instances and object sharing

Question

For the sample code below...

1. Is there a way to chain instances of different classes? The example provided is a failed attempt for wiring up methods belonging to different class instances.

2. Also, In the same example, Client2 is sharing the error object with Client3. What is a more efficient way of sharing objects between subclasses and unassociated classes?

For clarity, i have also commented inline.

Thank You for your time and help.

Sample Code

public class StubRunner
{
    public run(){
        ClientFactory client = new ClientFactory();

        //not correct. But, this is how i want to finally chain methods 
        //belonging to different class instances. Please advise.
        client.getClient1().testClient1().getClient2().testClient2().assert(...);
    }
}
public class ClientFactory
{
    public Client1 getClient1(){return new Client1();}
    public Client2 getClient2(){return new Client2();}
}
public class BaseClient
{
    public Errors errors = null; 
}
public class Client1 extends BaseClient
{
    public void testClient1(){...}
}
public class Client2 extends BaseClient
{
    public void testClient2()
    {
        //here i am directly passing the error object
        //what is a better way?
        //is there a more efficient way to make the SAME error object
        //available to Client3
        new Client3(this.errors).testClient3();
        ...
    }
}
public class Client3 extends BaseClient
{
    public Client3(Errors errors){this.errors = errors;}
    public void testClient3(){...}
}

Answer 1

Thank you everyone for the great help. Your advise has allowed me to arrive at the following working solution. Maybe it is not the best, so seeking your valuable time and your expertise to direct to a better solution.

Given some remarks my naming convention being fishy, i have tried to amend them to a certain extent. Kindly bear with me.

Objective was:

• To chain instances of different classes
• To share objects between subclasses and unassociated classes

Problem description:

• There are 4 tasks to be performed: Task1 to Task4.
• Each task is unique. But sometimes, to complete a task we need to perform mixed Task: refer Task3 >> performMixedTasks()
• To complete a piece of work we need to complete a set of Tasks.

State.java

public class State {
    public Boolean ISAUDITED = false;
    public int ERRORCODE = 0;
    public String ERRORTEXT = "";

    public void raise(int code, String msg){
        this.ERRORCODE = code;
        this.ERRORTEXT = msg;
    }
}

BaseClient.java

public abstract class BaseClient {

    public State state;

    public BaseClient(){
        this.state = new State();
    }
    public BaseClient(State state){
        this.state = state;
    }
    public ClientFactory getTest(){
        return new ClientFactory(state);
    }
    public Boolean Assert(){
        if(state.ERRORCODE == 0){
            System.out.println("Parsing was successful.");
            return true;
        }
        else{
            System.out.println("Parsing was not successful.");
            return false;
        }
    }
    public abstract BaseClient GoTo();
}

Task1.java

public class Task1 extends BaseClient {
    public Task1(){ GoTo(); }
    public Task1(State state){ super(state); GoTo(); }  
    public Task1 performTask1(){
        if(!state.ISAUDITED)
        {
            System.out.println("perform Task1");
            state.ISAUDITED = true;
        }
        return this;
    }

    @Override
    public BaseClient GoTo() {
        if(state.ISAUDITED){
            new Task2(state).performTask2();
        }
        return this;
    }
}

Task2.java

public class Task2 extends BaseClient{
    public Task2(){ GoTo(); }
    public Task2(State state){ super(state); GoTo(); }      
    public Task2 performTask2(){
        if(state.ISAUDITED)
        {
            System.out.println("perform Task2");
            state.ISAUDITED = false;
        }
        return this;
    }

    @Override
    public BaseClient GoTo() {
        if(!state.ISAUDITED){
            new Task1().performTask1();
        }
        return this;
    }
}

Task3.java

public class Task3 extends BaseClient {
    public Task3(){ }
    public Task3(State state){ super(state); }
    public Task3 GoTo(){
        if(!state.ISAUDITED) {new Task1(state).performTask1();}
        System.out.println("Opening Task3");
        return this;
    }
    public Task3 performTask3(){
        try
        {
            this.GoTo();
            System.out.println("Submitted Task3 Data");
        }
        catch(Exception e){
            state.raise(1, e.getMessage());
        }
        return this;
    }
    public Task3 performMixedTasks(){
        new Task4(state).performTask4();        
        this.performTask3();        
        return this;
    }
}

Task4.java

public class Task4 extends BaseClient {
    public Task4(){ }
    public Task4(State state){ super(state); }

    public Task4 GoTo(){
        if(!state.ISAUDITED) {new Task1(state).performTask1();}
        System.out.println("Opening Task 4");
        return this;
    }
    public Task4 performTask4(){
        try
        {
            this.GoTo();
            System.out.println("Submitted Task 4 Data");
        }
        catch(Exception e){
            state.raise(1, e.getMessage());
        }
        return this;
    }
}

ClientFactory.java

public class ClientFactory {
    State state;
    public ClientFactory(){
        state = new State();
    }
    public ClientFactory(State state){
        this.state = state;
    }
    public Task3 loadTask3(){return new Task3(state);}
    public Task4 loadTask4(){return new Task4(state);}
}

StubRunner1.java

public class StubRunner1 {

    public static void main(String[] arg)
    {
        ClientFactory test = new ClientFactory();
        test.loadTask3()
                .performTask3()
                .getTest()
            .loadTask4()
                .performTask4()
            .Assert();
    }
}

**RESULT IS**

perform Task1
Opening Task3
Submitted Task3 Data
Opening Task4
Submitted Task4 Data
Parsing was successful.

StubRunner2.java

public class StubRunner2 {

    public static void main(String[] args) {
        ClientFactory test = new ClientFactory();
        test.loadTask3()
                .performMixedTasks()
                .Assert();
    }

}

**RESULT IS**

perform Task1
Opening Task4
Submitted Task4 Data
Opening Task3
Submitted Task3 Data
Parsing was successful.

Answer 2

I would normally use lambda expressions for the cases when I want to program a short chain of method calls but I want the methods to change relatively to any kind of state. As for your scenario, each of your test would be a lambda expression and it would mean that I would pass the testClient4 method to the testClient3 method, the testClient3 method to the testClient2 method, etc. However, the code becomes more and more ugly as your chain of method calls becomes long.

=> You can use Fluent interface: you would have each method doing some logic and then returning an instance on which you can call the next inline methods you want to execute.

• ClientFactory.getClient1() : Client1
• Client1.testClient1() : Client1 (i.e. return this)
• Client1.getClient2() : Client2
• Client2.testClient2() Client2 (i.e. return this)
• ...

Obviously, each instance would need to have a reference to the next inline instance, knowing the one it will call (Client1 would have a reference to Client2, Client2 to Client3, etc).

This would work but I'm not a fan in this scenario! I'd say it's more a trick than clean coding. You should use fluent interface with each client separately unless one of your method is actually returning another instance:

client1.testClient1().testClient2().testClient3() with each test method returning an instance of the next client if there is a good reason for it

but it wouldn't make sense to interpose the getClient methods between the test methods...

Answer 3

Now testClient1() could return the client factory and such. But that is very convoluted.

Another regulatory syntax is to override a context providing class.

   new ClientFactory() {{
       getClient1().testClient1();
       getClient2().testClient2().assert(...);
   }};

Here an initializing block ("anonymous constructor") will provide a context. Then a bit of chaining can be done when testClient2 returns a Client2.

It can be a clean and useful design, for instance for my ambiguous grammar parser AnyParser on sourceforge.net (purely a craftmanship piece of work).

Answer 4

Is there a way to chain instances of different classes? The example provided is a failed attempt for wiring up methods belonging to different class instances.

client.getClient1().testClient1().getClient2().testClient2().assert(...);

In order to chain methods like this, each method must return a reference to an object which supports the method which you want to call. However, each test method returns void.

In this case, method chaining seems very questionable because you are operating on different types. Often methods in a chain like this will just return this; so that another method can be called on the exact same object which started the chain.

Additionally, the names of your methods suggest that you are attempting to implement some automated testing of your code. You should learn about established testing techniques and libraries. In particular, JUnit is commonly used in Java and variations in other languages. There are certain techniques that are considered good practice when writing tests in frameworks such as this.

To be clear here, you should certainly not mix testing code with production code.

Also, In the same example, Client2 is sharing the error object with Client3. What is a more efficient way of sharing objects between subclasses and unassociated classes?

//here i am directly passing the error object
//what is a better way?
//is there a more efficient way to make the SAME error object
//available to Client3
new Client3(this.errors).testClient3();

The only way to send an object to a class is to pass a parameter, either to the constructor or to a method. This is how Java works.

Note that there is very little overhead because you are passing a reference variable. You are not copying the entire object. This means that both the current instance of Client2 and the new instance of Client3 have references to the same error object.

Answer 5

I am not really getting what your need really is, however in the actual state of the code it cannot even compile since you are trying to execute methods from a "Client" object from a void method return.

If you do not know how many clients and from which type you are going to get, I would simply use a list.

If you want to chain the clients using the 'testClient' method, then first this method should return the next client (which is a really awkward way to chain objects by the way), then you should start using more abstraction and overriding technics.

Basically, there's no need to know what object you are dealing with as long as it is a "BaseClient", but if you name the child methods "testClient1", "testClient2" etc ... you basically breaking it and you need to start thinking of what you are actually getting and adapt your code accordingly.

Finally, there's no need for a factory here, but if you want one, it should be static.

Here is a working example of this, again I do not really comprehend what you wanna do so it may not solve your issue, but it's a working solution to "chaining instances":

Main:

public class Foo
{
    // arguments are passed using the text field below this editor
    public static void main(String[] args)
    {
        StubRunner stub = new StubRunner();
        stub.run();
    }

}

Stubrunner:

public class StubRunner implements Runnable
{
    public void run(){

        Object clients = ClientFactory.getClient1();

        while (null!= clients && clients instanceof BaseClient) {

            clients = ((BaseClient) clients).test();            
        }
    }
}

Base:

public abstract class BaseClient
{
    public Exception errors = null; 



    public BaseClient() {};
    public BaseClient(Exception errors) {
        this.errors = errors;
    }

    public abstract BaseClient test();

    public void checkErrors() {
        System.out.println(this.toString());
        assert null == errors;
    }
}

Client 1:

public class Client1 extends BaseClient
{
    public BaseClient test(){
        checkErrors();
        return new Client2();      
    }
}

Client 2:

public class Client2 extends BaseClient
{
    public BaseClient test()
    {
        checkErrors();
        return new Client3(this.errors);

    }
}

Client 3:

public class Client3 extends BaseClient
{
    public Client3(Exception errors) {
        super(errors);
    }

    public BaseClient test() {
        checkErrors();
        return null;
    }
}

Factory:

public final class ClientFactory { private ClientFactory() {};

public static Client1 getClient1(){return new Client1();}
public static Client2 getClient2(){return new Client2();}

}

This outputs the following:

test.Client1@15db9742 test.Client2@6d06d69c test.Client3@7852e922