设计模式与面向对象编程：举例说明在Java中应用工厂模式的场景，并编写一个简单的工厂模式实现。编写一个Java装饰器，用于添加日志记录功能到现有方法上。

工厂模式的应用场景与实现：
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在实际应用中，我们常常需要根据不同的条件或参数来创建不同的对象。工厂模式就是为了解决这个问题而提出的。

例如，在Java中，我们可以使用工厂模式来创建不同类型的数据库连接：

public interface DatabaseConnection {
   
    void connect();
}

public class MySQLDatabaseConnection implements DatabaseConnection {
   
    @Override
    public void connect() {
   
        System.out.println("Connecting to MySQL database...");
    }
}

public class OracleDatabaseConnection implements DatabaseConnection {
   
    @Override
    public void connect() {
   
        System.out.println("Connecting to Oracle database...");
    }
}

public class DatabaseConnectionFactory {
   
    public static DatabaseConnection createDatabaseConnection(String type) {
   
        if ("mysql".equalsIgnoreCase(type)) {
   
            return new MySQLDatabaseConnection();
        } else if ("oracle".equalsIgnoreCase(type)) {
   
            return new OracleDatabaseConnection();
        } else {
   
            throw new IllegalArgumentException("Invalid database type");
        }
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        DatabaseConnection mysqlConnection = DatabaseConnectionFactory.createDatabaseConnection("mysql");
        mysqlConnection.connect();

        DatabaseConnection oracleConnection = DatabaseConnectionFactory.createDatabaseConnection("oracle");
        oracleConnection.connect();
    }
}

在这个例子中，DatabaseConnectionFactory是一个工厂类，它根据传入的类型字符串创建相应的数据库连接对象。

装饰器模式的应用场景与实现：
装饰器模式是一种结构型设计模式，它允许我们在运行时给一个对象动态地添加新的功能，同时保持代码的可读性和简洁性。

以下是一个简单的Java装饰器，用于添加日志记录功能到现有方法上：

public abstract class LoggingDecorator {
   
    protected final Object component;

    public LoggingDecorator(Object component) {
   
        this.component = component;
    }

    public void log(String message) {
   
        System.out.println("Logging: " + message);
    }

    public abstract void execute();
}

public class LoggingExecutor extends LoggingDecorator {
   
    public LoggingExecutor(Object component) {
   
        super(component);
    }

    @Override
    public void execute() {
   
        log("Starting execution...");
        ((Runnable) component).run();
        log("Finished execution.");
    }
}

public class MyTask implements Runnable {
   
    @Override
    public void run() {
   
        System.out.println("Running my task...");
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        Runnable myTask = new MyTask();
        Runnable loggingTask = new LoggingExecutor(myTask);

        loggingTask.run();
    }
}

在这个例子中，LoggingExecutor是一个装饰器类，它通过包装原始的任务对象并添加日志记录功能。当我们调用loggingTask.run()时，会先打印出"Starting execution..."，然后执行原始任务，最后打印出"Finished execution."。