调试：到System.out.println（）或不到System.out.println（）

Question

That is my question. More specifically, I'm trying to get used to Eclipse's debugger and I'd like to know if printing to console is still done in some cases or if it's considered a bad practise that should be entirely avoided. Also, what can be considered as good approach(es) to debugging overall?

Answer 1

Use System.err.println() instead.

Why?

System.out.println() is often redirected to a file or another output, while this is pretty much always printed on the console. It's easier for debugging and also the right way to do it.

---

Edit (warning: subjective):

Since you asked about whether System.out.println should be entirely avoided: I don't believe in anything that you must always avoid, be it using goto's, crashing your computer with a BSOD, or whatever. Sometimes you just need a quick-and-dirty way to get small things done fast, and it just plain isn't worth the 1 hour you'll spend on it to try to do things the "right" way, instead of a 5-minute fix, no matter how good the "good" way is. Use your judgment when deciding if something should be used or not, but never set rules for yourself like "I'll never use goto!". :)

Edit 2 (example):

Let's say you're debugging a crashing driver and you suspect that an if statement that shouldn't be execute is being executed. Instead of spending three hours finding out how to use ZwRaiseHardError to display a message box, just call KeBugCheck inside the if and crash the darned system. Sure, you'll reboot, but unless your reboot takes hours, you just saved yourself that much time.

Answer 2

The best choice would be a logging library (of course, this adds an extra dependency to your project). Check out commons-logging, for instance. The main advantage is that you can write your debug messages in the DEBUG level and when you deploy your code, you'll just configure the logger to skip those messages (instead of searching for all occurrences of System.out.println in your code). One other great advantage is that loggers usually can be configured to write anywhere (even send email messages or SMS) also without touching your code.

Answer 3

1. Minor point: if your program actually outputs something useful to the console via System.out, you may want to instead print the debugging info to System.err

2. You should generally strive to have as much debugging as possible (ideally using some standard logger like log4j ). This both eases debugging when you're actually developing the program AND allows for much easier debugging of already-released code in production. The benefit is that your code remains unchanged and you don't need to ADD debugf prints, yet by default the logging config can turn off the logging until it's actually needed (or at least turn down the level of logs)

3. As far as general simple "throw println s at the wall" debugging, it can sometimes be one of the fastest ways to debug, though it should by no means be the only/main one.

   Why can it be useful? Among other reasons, because running a Java program in a debugger may be much slower than outside of it; or because your bug manifests in an environment/situation that can't be easily replicated in your Eclipse debugger.

Answer 4

If the debugging print lines are not going to stay in the code after you've fixed your bug, then do whatever is easiest for you. Lambert's advice of using System.err.println() is a good idea since you can differentiate it from other output that your program may produce. If the debugging print lines are going to stay in your code, then I would advise on using a logging framework like log4j. This way you can dial up or down the level of output based on whether you're trying to debug something or just running in production. Be sure to output things at the right level when using log4j. Don't just log everything at INFO.

Answer 5

我使用System.out.println进行调试，以防我遇到问题或通知我方法已经开始确保一切正常，但是当我发布程序时，我总是删除它，因为它会减慢程序的速度。