Also am I correct in that this code intercepts all logging statements for all the different logging frameworks?

SLF4JBridgeHandler is a java.util.logging (JUL) logging bridge, which will "intercept" the JUL logging statements and route them to the SLF4J.

Other bridges available are jcl-over-slf4j (Jakarta Commons Logging => SL4J) and log4j-over-slf4j (Log4J => SL4J) (as well as their SLF4J => X counterparts).

Depending on which logging frameworks are used in your code (either directly or indirectly), you may want to include some or all of these, to capture all the logging statements, as detailed here.

How do I write the code for appendHandler method?

Using SLF4J (e.g. Logback) as your primary logging framework

Once you have setup your bridges, you can then configure your SLF4J implementation in a usual way.

Below is an example of how to do this for Logback:

//Install the JUL Bridge
SLF4JBridgeHandler.removeHandlersForRootLogger();
SLF4JBridgeHandler.install();

//Obtain an instance of LoggerContext
LoggerContext context = (LoggerContext)LoggerFactory.getILoggerFactory();

//Create a new FileAppender
FileAppender<ILoggingEvent> file = new FileAppender<ILoggingEvent>();
file.setName("FileLogger");
file.setFile("error.log");
file.setContext(context);
file.setAppend(true);

//Filter out anything < WARN
ThresholdFilter warningFilter = new ThresholdFilter();
warningFilter.setLevel("WARN");
warningFilter.setContext(context);
warningFilter.start();
file.addFilter(warningFilter);

//Message Encoder
PatternLayoutEncoder ple = new PatternLayoutEncoder();
ple.setContext(context);
ple.setPattern("%date %level [%thread] %logger{10} %msg%n");
ple.start();
file.setEncoder(ple);

file.start();

//Get ROOT logger, and add appender to it
Logger root = context.getLogger(Logger.ROOT_LOGGER_NAME);
root.setLevel(Level.DEBUG);
root.addAppender(file);

Using JUL as the primary logging framework

If what you want is to use JUL (java.util.logging) as your primary logging framework, you do not need to register the SLF4JBridgeHandler at all.

Just configure JUL handlers as usual, and add the slf4j-jdk14 (i.e. SLF4J => JUL) bridge to your list of dependencies.

//Create a new Handler
Handler fh = new FileHandler("error.log");
fh.setLevel(Level.WARNING);

//Register it with the ROOT logger
Logger.getLogger("").addHandler(fh);

//Log some messages
Logger.getLogger("scratchpad").info("Info !");
Logger.getLogger("scratchpad").warning("Warning !");
Logger.getLogger("scratchpad").severe("Severe !");

//Log some messages via SL4J 
LoggerFactory.getLogger("scratchpad").error("sl4j message");

This way any SL4J log statements will be redirected to the appropriate JUL handlers (you may also want to add jcl-over-slf4j and log4j-over-sl4j in the mix too).