1. Log.java

public abstract class Log {
public abstract void write(String log);
}

2. DatabaseLog.java 

public class DatabaseLog extends Log {
// Write to the Database
public void write(String log){
}
}

3. DecoratorLog.java

public abstract DecoratorLog extends Log {
protected Log objLog;
public DecoratorLog(Log objLog) {
this.objLog = objLog;
}
public void write(String log){
// Write to the Textfile
objLog.write(log);
}
}

4. DecoratorLogA.java

public class DecoratorLogA extends
DecoratorLog {
public DecoratorLogA(Log aLog) {
super(objLog);
}
public void write(String log){
// Decorator A behavior here
objLog.write(String log);
}
}

5. DecoratorLogB.java

public class DecoratorLogB extends
DecoratorLog {
public DecoratorLogB(Log aLog) {
super(objLog);
}
public void write(String log){
// Decorator B behavior here
objLog.write(String log);
}
}

interface Log{
public void write(String log);
}
Once you have defined the interface, you can
implement its behaviors in any class e.g.
public class DatabaseLog implements Log
{public void write(String log){// Decorator A
behavior here}}

II. Facade Design Pattern

The Facade Pattern is an object-oriented design pattern, which provides a simplified interface to a larger body of code. This pattern can make the task of accessing a large number of modules much simpler by providing an additional and a higher-level interface layer to an entire subsystem of objects that makes the subsystem easier to use. Thus, it hides the complexities and the implementation of the subsystem from clients.
A facade is an object that is placed between the group of objects and its client who accesses the system.

Facade Pattern : When to use

• When a way of hiding a complex system within a simple interface is required.
• When lots of dependencies between client and its implementation class of an
abstraction are required.
• When you want to make subsystems in layers.