本文深入探讨了在java中如何有效重定向超类构造器中`system.out.println()`的输出，并解决同时将输出导向文件和控制台的需求。核心在于理解java对象初始化时构造器的调用顺序，并利用全局`system.setout()`结合自定义`printstream`实现多目标输出，或采用更专业的日志框架，以提升输出管理的可控性和灵活性。
在Java中，当子类构造器被调用时，它总是会隐式或显式地调用其父类的构造器。这个调用发生在子类构造器体内的任何代码执行之前。这意味着，如果在子类构造器中尝试通过System.setOut()重定向标准输出流，那么在super()调用期间执行的父类构造器中的System.out.println()语句将仍然输出到原始的System.out流，因为此时重定向尚未生效。
考虑以下示例代码：
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.PrintStream;
// 超类定义
public class SuperClass implements ActionListener {
public SuperClass() {
System.out.println("SuperClass constructor: Some message");
}
@Override
public void actionPerformed(ActionEvent event) {
System.out.println("SuperClass actionPerformed: " + toString());
}
@Override
public String toString() {
return "Some other message";
}
}
// 子类定义
public class SubClass extends SuperClass {
private PrintStream ps;
public SubClass() {
super(); // 此处会先执行SuperClass的构造器
// SuperClass构造器执行完毕后，才会执行以下代码
try {
ps = new PrintStream("file.txt");
} catch (IOException e) {
e.printStackTrace();
}
System.setOut(ps); // 此时重定向才生效，但SuperClass构造器已执行完毕
}
}当我们创建SubClass实例时，SuperClass构造器中的"SuperClass constructor: Some message"会打印到控制台，而不是file.txt。然而，actionPerformed()方法中的System.out.println()则会被重定向到file.txt，因为它在System.setOut(ps)之后被调用。
为了解决超类构造器输出的重定向问题，System.setOut()必须在子类实例被创建之前就执行。同时，为了满足将输出同时导向文件和控制台的需求，我们可以创建一个自定义的PrintStream，它能将数据写入到多个底层输出流。
立即学习“Java免费学习笔记（深入）”；
“Tee”型流（TeePrintStream）的工作原理类似于管道中的“T”形接头，将一个输入流的数据同时复制到两个或多个输出流。
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
/**
* TeePrintStream是一个PrintStream的子类，它将所有输出写入到两个底层的PrintStream。
* 类似于Unix的'tee'命令，将输出同时发送到两个目的地。
*/
public class TeePrintStream extends PrintStream {
private final PrintStream branch1;
private final PrintStream branch2;
/**
* 构造一个TeePrintStream。
* @param out1 第一个输出流。
* @param out2 第二个输出流。
*/
public TeePrintStream(PrintStream out1, PrintStream out2) {
// 调用父类构造器，通常将一个流作为主要流，但实际写入会分发到两个。
// 这里选择out1作为super的底层流，但关键在于重写write方法。
super(out1);
this.branch1 = out1;
this.branch2 = out2;
}
@Override
public void write(int b) {
branch1.write(b);
branch2.write(b);
}
@Override
public void write(byte[] buf, int off, int len) {
branch1.write(buf, off, len);
branch2.write(buf, off, len);
}
@Override
public void flush() {
branch1.flush();
branch2.flush();
super.flush(); // 确保父类底层的流也被刷新
}
@Override
public void close() {
// 关闭所有底层流
branch1.close();
branch2.close();
super.close(); // 关闭由super()构造器关联的流
}
}在主应用程序的入口点（例如main方法）中，在任何可能创建SubClass实例的代码之前，进行System.out的重定向。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
public class MainApplication {
public static void main(String[] args) {
PrintStream originalOut = System.out; // 保存原始的System.out
PrintStream fileStream = null;
TeePrintStream teeStream = null;
try {
// 1. 创建文件输出流
fileStream = new PrintStream(new FileOutputStream("output.log", true)); // true表示追加模式
// 2. 创建TeePrintStream，将输出同时导向文件和原始控制台
teeStream = new TeePrintStream(fileStream, originalOut);
// 3. 全局重定向System.out
System.setOut(teeStream);
// 此时，任何System.out.println()都会同时输出到文件和控制台
System.out.println("Application starting...");
// 创建SubClass实例，其SuperClass构造器现在也会打印到文件和控制台
SubClass sub = new SubClass();
System.out.println("SubClass instance created.");
// 模拟动作执行
sub.actionPerformed(null);
System.out.println("Application finished.");
} catch (IOException e) {
originalOut.println("Error setting up output redirection: " + e.getMessage());
e.printStackTrace(originalOut);
} finally {
// 恢复原始的System.out并关闭自定义流
if (teeStream != null) {
System.setOut(originalOut); // 恢复原始输出流
teeStream.close(); // 关闭TeePrintStream，它会负责关闭其内部的fileStream
} else if (fileStream != null) {
fileStream.close();
}
}
}
}通过这种方式，System.out在SubClass实例创建之前就已经被重定向，因此SuperClass构造器中的System.out.println()也会被捕获并同时输出到文件和控制台。
在生产环境中，直接修改System.out通常不是最佳实践。更推荐的方法是使用成熟的Java日志框架，如Log4j、Logback或Java Util Logging (JUL)。日志框架提供了更强大、更灵活的输出管理能力，包括：
假设我们使用SLF4J作为日志门面，Logback作为实现。
添加依赖：
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.30</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>配置Logback (logback.xml)： 在src/main/resources目录下创建logback.xml文件。
<configuration>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<appender name="FILE" class="ch.qos.logback.core.FileAppender">
<file>application.log</file>
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<root level="INFO">
<appender-ref ref="CONSOLE" />
<appender-ref ref="FILE" />
</root>
</configuration>修改SuperClass和SubClass使用Logger：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
// 超类定义
public class SuperClass implements ActionListener {
private static final Logger logger = LoggerFactory.getLogger(SuperClass.class);
public SuperClass() {
logger.info("SuperClass constructor: Some message"); // 使用logger输出
}
@Override
public void actionPerformed(ActionEvent event) {
logger.info("SuperClass actionPerformed: {}", toString()); // 使用logger输出
}
@Override
public String toString() {
return "Some other message";
}
}
// 子类定义 (不再需要重定向System.out)
public class SubClass extends SuperClass {
private static final Logger logger = LoggerFactory.getLogger(SubClass.class);
public SubClass() {
super(); // SuperClass的日志会通过其自身的logger输出
logger.info("SubClass constructor: Initialized.");
}
}
// 主应用程序
public class MainApplicationWithLogging {
private static final Logger logger = LoggerFactory.getLogger(MainApplicationWithLogging.class);
public static void main(String[] args) {
logger.info("Application starting...");
SubClass sub = new SubClass();
logger.info("SubClass instance created.");
sub.actionPerformed(null);
logger.info("Application finished.");
}
}通过这种方式，SuperClass和SubClass的输出都将通过各自的Logger进行管理，并根据logback.xml的配置同时输出到控制台和文件，而无需担心构造器调用顺序导致的System.out重定向问题。
要解决Java中超类构造器System.out.println()输出无法被子类System.setOut()重定向的问题，关键在于理解构造器调用的时序性：父类构造器先于子类构造器体执行。因此，System.setOut()必须在子类实例创建之前全局设置。为了同时将输出导向文件和控制台，可以实现一个自定义的TeePrintStream。然而，对于生产级的应用程序，更推荐使用功能强大的日志框架（如Logback、Log4j），它们提供了更灵活、更健壮的日志管理机制，是处理应用程序输出的最佳实践。
以上就是Java中重定向超类构造器System.out输出的策略与最佳实践的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
926
收藏
