Conditional compilation in Java: will compiler omit "always false" blocks from class?

Question

Below is a snippet of my code:

class A { 

   private boolean debug = false;

   // Called when server boots up.
   public void init (property) { 
      debug = property.getBoolean ("debug_var"); // read debug from a config file.
   }

   // some other function  
   public void foo () { 
       if (debug) { 
                 System.out.println ("From inside the debug block");
       }
   }
 }

When I run the code, if (debug) actually prints out "From inside debug block" if debug == true in the config file.

Two Questions:

1. So, in this case does the compiler include the if block in the .class file just because the value of variable debug might change on run time?

2. If this is true, then how can I eliminate some code from being added to the .class file on certain environments?

Answer 1

If you must do something like this, most logging frameworks have their own means of setting the level of log detail, and they just don't output any log statements that are too low-level at runtime. Use a logging framework to do this properly.

For example, with the built-in java.util.logging framework, you'd do something like

Logger.getLogger("ThisClass").log(Level.FINE, "Log message");

which only gets printed when the log level is set to FINE or below, but is ignored when the log level is CONFIG or lower.

"Conditional compilation" isn't a thing that makes sense in Java in general, but with some care, the JIT will optimize away branches it can determine will never be executed.

Answer 2

As others have pointed out, a Java compiler is typically quite naive, and just translates what you have as Java source code, into Java bytecode. For example, an if statement is most often translated to a conditional branch, whether or not you may find it evident that the branching condition is always false.

From a theoretical perspective however, there's nothing that prevents a compiler to figure out that certain branches can never be taken, and simply omit them in the bytecode. Nothing in the Java Language Specification dictates how something should be compiled when targeting bytecode.

Answer 3

The closest you can come is by using a static variable, which is useless (essentially) at run-time.

However, in your example, the JVM will likely optimize it away after it's been run enough times, so if your concern is run-time efficiency, it's likely not worth worrying about.

Ultimately I'd ask why you want to remove code from the class file based on an environment--if it's not something that can change at run time then your best option would be to create some form of pluggable implementation that can be determined/injected at runtime.

Answer 4

There is nothing like conditional compilation (Unless java finds a condition which is guaranteed to be NOT executed). Your class file contains byte code equal of whatever you have in Java file.

EDIT: As aiobee pointed, compiler may omit branching statements if it finds them as not to be executed.

Answer 5

1. Yes, the compiler will include this in the .class file.
2. There is no mechanism for conditional compilation. You could emulate some of it by using a compiler plugin (in JDK 1.7 and higher), or you could try to achieve similar effects by using bytecode manipulating techniques like AspectJ.

Answer 6

It used to be that if you declared a boolean as static and final and set its value to false, that the compiler would elide the code. That was the original Java compiler though. I don't know if the current one does this or not though (the current one has been around for a long time now). The rationale behind this was to allow you to make your applet downloads smaller. It was a klunky mechanism at best so not widely used.

To test this, change your debug var to private static final boolean debug=false; compile it, save the class file, then flip it to true. Then compile it again and see if the class files are different. BTW, your init function won't work when debug is declared as final.