Is it possible to create a method that returns a try/catch?

Say we have a lot of methods where we want to print something fx using System.out.println(...)
then we can just create a method like

public void print(String msg) {
       System.out.println(...)
}

And then we can just do: print("Some message") which is faster and saves us for writing System.out.println(...) everytime.

So now to the case. I am practicing with Java I/O, which wants hell a lot of try/catch. So instead of having to write a try/catch block everytime, can I do something like

public sometype tryCatch (String objThatCanThrowExc) {
   clause = "try {
            " + objThatCanThrowExc + "
   } catch(Exception e) { 
      print(e); 
   } "
   return clause;
}

And then do something like this

public void server(int port) {
    ServerSocket ss = null; 
    //Assume ss is not null, and client is a Socket
    tryCatch("client = ss.accept();");
    ...
}

With the above code I am just trying to express what I want to do. I am not sure if there is something smart available to help me achieve this. Another way that could be even better is if I could do something like this

public void server(int port) {
        ServerSocket ss = null;
        tryCatch() {
            client = ss.accept();
        }
        ...
}

I have not much programming experience, so I know this is a silly question, but who knows, maybe there is something smart

The concept that you're looking for is called a Try type. It's similar to java.util.Optional, which can be either "present" or "empty"; a Try can be either "success" or "failure". It's not built into Java, but the Vavr library is one commonly-used implementation.

If I understand it correctly, what you want to do is call multiple IO functions that might throw, but without writing the same "catch" logic for each.

You are right that what you want to do is somehow "pass" the code that might throw into another method that handles the catch for you. In Java, this mechanism is not strings but lambda functions.

We can use them like this:

import java.io.*;

class Main {

  @FunctionalInterface
  public interface Action {
    void run() throws Exception;
  }

  private static void printExceptionAndContinue(final Action action) {
    try {
      action.run();
    } catch(Exception error) {
      System.out.println(error.toString());
    }
  }

  public static void main(String[] args) {
    printExceptionAndContinue(() -> {
      // Here goes some code that might throw!
      throw new Exception("Oh no!");
    });    
    
    printExceptionAndContinue(() -> {
      // And some more
      System.out.println("Still gets called!");
    });
  }
}

For those saying that a "string" of code cannot be typed and interpreted in a strongly-typed compiled language, I would encourage them to look at F# quotations.

In your example, the "clause" you're using is a String, so unless you try parsing it as code (which is complicated) it's not going to work.

Instead it's better to have a different return statement in the try part and in the catch part. If you get an error saying that you aren't returning anything, try putting a dummy return statement after the try/catch statements which returns null or zero or the empty string.

if the try-catch needs to work with some specific operation to an object yes. we can.

Say. we have an interface

public interface - oneOperation

public interface oneOperation{

    public void execute() throws Exception;

    default void invoke(){
        try {
            this.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

now the impls of the interface only implement execute() method.

Other Objects that uses the impls can call the invoke() method in case they want the exception to be not thrown

not sure if this is what you were looking for ..