How to stop repeating myself in Java

Question

I use a method for more than one time in JavaScript by using callback method because JavaScript is an async language.

Example:

function missionOne () {
    sumCalculation(1, 2, function (result) {
        console.log(result) // writes 3
    })
}

function sumCalculation (param1, param2, callback) { 
  let result = param1 + param2
  // The things that take long time can be done here
  callback(result)
}

I wonder if there is any way to stop myself in Java?

Edit: I remove several sentences that make more complex the question.

Answer 1

Yes it is easy in Java. To take your example above you can write it in Java like this:

public static void main(String[] args) {
  System.out.println(sumCalc(1,2));
}

private int sumCalc(int first, int second) {
  return first + second;
}

Answer 2

I may be reading too much into your question, but it seems that you're looking into how to handle asynchronous code in Android. There are a couple of native options (not considering any library). I'll focus on two, but keep in mind there are other options.

AsyncTasks

From the documentation

AsyncTask enables proper and easy use of the UI thread. This class allows you to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers.

Before writing one, you need to know which type of parameters it will receive, the type of progress it will publish during computation and what is its return type. These types are define via the AsyncTask generic Parameters AsyncTask<Params,Progress,Result> . If you don't need them any of them, set them to Void

Here's the basic gist of using an AsyncTask to compute the sum of two ints :

public void sumCalculation (int param1, int param2, Callback callback) { 
    new AsyncTask<Integer, Void, Integer>() {

        @Override
        public Integer doInBackground(Integer... params) {
            int result = 0;
            for (Integer param : params) {
                result += param;
            }
            return result;                
        }

        @Override
        protected void onPostExecute(Integer integer) {
            super.onPostExecute(integer);
            callback.onDone(integer);
        }

    }.execute(param1, param2);
}

doInBackground , as the name says, will execute a certain piece of code in a background thread. Please note that every AsyncTask will run on a ThreadPool of size 1, so they actually get in the way of other AsyncTasks .

onPostExecute brings the result back to the main thread, so you can update any UI componente. If you try to update the UI from a background thread, an exception will be thrown.

The down side of this particular example is the creation of a new AsyncTask every time that function is called. Also you should use AsyncTask only if the task won't run for a very long time, couple of seconds at most.

Thread and Handler

Another option suggested on the documentation is using a thread and a handler to communicate between the main thread and a background thread. Although this provides greater flexibility, it also requires more responsibility as you will be responsible for managing the communication yourself, picking the right time to kill your threads and how to recover when something goes bad.

As a rule of thumb, you should only go this way if you really need the extra flexibility.

The overall idea is to create your own Handler and override its handleMessage method.

  public class MyHandler {

        @Override
        public void handleMessage(Message inputMessage) {
            int messageType = inputMessage.what;
            Object extraData = inputMessage.obj;
            ...
        }
  }

  public class MyTask extends Thread {
       public static public int COMPUTATION_DONE = 0;
       private MyHandler handler;

       public MyTask(MyHandler handler) {
            this.handler = handler;
       }

        @Override
        public void run() {
            //do your computation
            Message message = handler.obtainMessage(COMPUTATION_DONE, your_result);
            handler.sendMessage(message);
        }
  }

As you can see, this requiring parsing inputMessage.what and deciding what to do with it. Additionally, you need to cast inputMessage.obj to the right type and so on.

These are just two examples, but depending on what you're trying to do, you might need to dig deeper into Services or take a look at some reactive approach, such as RxJava2 . However I encourage you to start with the basic before diving into something way more complicated.