The source and destination directory will be recursively scanned for Javasource files to compile. Only Java files that have no corresponding.class fileor where the class file is older than the.java file will be compiled.

Note: Apache Ant uses only the names of the source and class files to findthe classes that need a rebuild. It will not scan the source and thereforewill have no knowledge about nested classes, classes that are named differentfrom the source file, and so on. See the<depend> taskfor dependency checking based on other than justexistence/modification times.

When the source files are part of a package, the directory structure ofthe source tree should follow the packagehierarchy.

It is possible to refine the set of files that are being compiled.This can be done with the includes, includesfile,excludes, and excludesfileattributes. With the includes orincludesfile attribute, you specify the files you want tohave included.The exclude or excludesfile attribute is usedto specifythe files you want to have excluded. In both cases, the list of filescan be specified by either the filename, relative to the directory(s) specifiedin the srcdir attribute or nested <src>element(s), or by using wildcard patterns. See the section ondirectory-based tasks,for information on how theinclusion/exclusion of files works, and how to write wildcard patterns.

It is possible to use different compilers. This can be specified byeither setting the global build.compiler property, which willaffect all <javac> tasks throughout the build, bysetting the compiler attribute, specific to the current<javac> task or by using a nested element of anytypedeffed orcomponentdeffed type that implementsorg.apache.tools.ant.taskdefs.compilers.CompilerAdapter.Valid values for either thebuild.compiler property or the compilerattribute are:

classic (the standard compiler of JDK 1.1/1.2) – javac1.1 and javac1.2 can be used as aliases.
modern (the standard compiler of JDK 1.3/1.4/1.5/1.6/1.7/1.8) – javac1.3 and javac1.4 and javac1.5 and javac1.6 and javac1.7 (since Ant 1.8.2) and javac1.8 (since Ant 1.8.3) can be used as aliases.
jikes (the Jikes compiler).
jvc (the Command-Line Compiler from Microsoft's SDK for Java / Visual J++) – microsoft can be used as an alias.
kjc (the kopi compiler).
gcj (the gcj compiler from gcc).
sj (Symantec java compiler) – symantec can be used as an alias.
extJavac (run either modern or classic in a JVM of its own).

The default is javac1.x with x dependingon the JDK version you use while you are running Ant.If you wish to use a different compiler interface than thosesupplied, you can write a class that implements the CompilerAdapter interface(package org.apache.tools.ant.taskdefs.compilers). Supply the fullclassname in the build.compiler property or thecompiler attribute.

The fork attribute overrides the build.compiler propertyor compiler attribute setting andexpects a JDK1.1 or higher to be set in JAVA_HOME.

You can also use the compiler attribute to tell Antwhich JDK version it shall assume when it puts together the commandline switches - even if you set fork="true".This is useful if you want to run the compiler of JDK 1.1 while youcurrent JDK is 1.2+. If you usecompiler="javac1.1" and (for example)depend="true" Ant will use the command lineswitch -depend instead of -Xdepend.

This task will drop all entries that point to non-existentfiles/directories from the classpath it passes to the compiler.

The working directory for a forked executable (if any) is the project's base directory.

Windows Note:When the modern compiler is usedin unforked mode on Windows, it locks up the files present in theclasspath of the <javac> task, and does not release them.The side effect of this is that you will not be able to delete or movethose files later on in the build. The workaround is to fork wheninvoking the compiler.

Parameters

Attribute	Description	Required
srcdir	Location of the java files. (See the note below.)	Yes, unless nested `<src>` elements are present.
destdir	Location to store the class files.	No
includes	Comma- or space-separated list of files (may be specified using wildcard patterns) that must be included; all `.java` files are included when omitted.	No
includesfile	The name of a file that contains a list of files to include (may be specified using wildcard patterns).	No
excludes	Comma- or space-separated list of files (may be specified using wildcard patterns) that must be excluded; no files (except default excludes) are excluded when omitted.	No
excludesfile	The name of a file that contains a list of files to exclude (may be specified using wildcard patterns).	No
classpath	The classpath to use.	No
sourcepath	The sourcepath to use; defaults to the value of the srcdir attribute (or nested `<src>` elements). To suppress the sourcepath switch, use `sourcepath=""`.	No
bootclasspath	Location of bootstrap class files. (See below for using the -X and -J-X parameters for specifing the bootstrap classpath).	No
classpathref	The classpath to use, given as a reference to a path defined elsewhere.	No
sourcepathref	The sourcepath to use, given as a reference to a path defined elsewhere.	No
bootclasspathref	Location of bootstrap class files, given as a reference to a path defined elsewhere.	No
extdirs	Location of installed extensions.	No
encoding	Encoding of source files. (Note: gcj doesn't support this option yet.)	No
nowarn	Indicates whether the `-nowarn` switch should be passed to the compiler; defaults to `off`.	No
debug	Indicates whether source should be compiled with debug information; defaults to `off`. If set to `off`, `-g:none` will be passed on the command line for compilers that support it (for other compilers, no command line argument will be used). If set to `true`, the value of the `debuglevel` attribute determines the command line argument.	No
debuglevel	Keyword list to be appended to the `-g` command-line switch. This will be ignored by all implementations except `modern`, `classic(ver >= 1.2)` and `jikes`. Legal values are `none` or a comma-separated list of the following keywords: `lines`, `vars`, and `source`. If `debuglevel` is not specified, by default, nothing will be appended to `-g`. If `debug` is not turned on, this attribute will be ignored.	No
optimize	Indicates whether source should be compiled with optimization; defaults to `off`. Note that this flag is just ignored by Sun's `javac` starting with JDK 1.3 (since compile-time optimization is unnecessary).	No
deprecation	Indicates whether source should be compiled with deprecation information; defaults to `off`.	No
target	Generate class files for specific VM version (e.g., `1.1` or `1.2`). Note that the default value depends on the JVM that is running Ant. In particular, if you use JDK 1.4+ the generated classes will not be usable for a 1.1 Java VM unless you explicitly set this attribute to the value 1.1 (which is the default value for JDK 1.1 to 1.3). We highly recommend to always specify this attribute. A default value for this attribute can be provided using the magic `ant.build.javac.target` property.	No
verbose	Asks the compiler for verbose output; defaults to `no`.	No
depend	Enables dependency-tracking for compilers that support this (`jikes` and `classic`).	No
includeAntRuntime	Whether to include the Ant run-time libraries in the classpath; defaults to `yes`, unless `build.sysclasspath` is set. It is usually best to set this to false so the script's behavior is not sensitive to the environment in which it is run.	No
includeJavaRuntime	Whether to include the default run-time libraries from the executing VM in the classpath; defaults to `no`. Note: In some setups the run-time libraries may be part of the "Ant run-time libraries" so you may need to explicitly set includeAntRuntime to false to ensure that the Java run-time libraries are not included.	No
fork	Whether to execute `javac` using the JDK compiler externally; defaults to `no`.	No
executable	Complete path to the `javac` executable to use in case of `fork="yes"`. Defaults to the compiler of the Java version that is currently running Ant. Ignored if `fork="no"`. Since Ant 1.6 this attribute can also be used to specify the path to the executable when using jikes, jvc, gcj or sj.	No
memoryInitialSize	The initial size of the memory for the underlying VM, if `javac` is run externally; ignored otherwise. Defaults to the standard VM memory setting. (Examples: `83886080`, `81920k`, or `80m`)	No
memoryMaximumSize	The maximum size of the memory for the underlying VM, if `javac` is run externally; ignored otherwise. Defaults to the standard VM memory setting. (Examples: `83886080`, `81920k`, or `80m`)	No
failonerror	Indicates whether compilation errors will fail the build; defaults to `true`.	No
errorProperty	The property to set (to the value "true") if compilation fails. Since Ant 1.7.1.	No
source	Value of the `-source` command-line switch; will be ignored by all implementations prior to `javac1.4` (or `modern` when Ant is not running in a 1.3 VM), `gcj` and `jikes`. If you use this attribute together with `gcj` or `jikes`, you must make sure that your version supports the `-source` (or `-fsource` for gcj) switch. By default, no `-source` argument will be used at all. Note that the default value depends on the JVM that is running Ant. We highly recommend to always specify this attribute. A default value for this attribute can be provided using the magic `ant.build.javac.source` property.	No
compiler	The compiler implementation to use. If this attribute is not set, the value of the `build.compiler` property, if set, will be used. Otherwise, the default compiler for the current VM will be used. (See the above list of valid compilers.)	No
listfiles	Indicates whether the source files to be compiled will be listed; defaults to `no`.	No
tempdir	Where Ant should place temporary files. This is only used if the task is forked and the command line args length exceeds 4k. Since Ant 1.6.	No; default is java.io.tmpdir.
updatedProperty	The property to set (to the value "true") if compilation has taken place and has been successful. Since Ant 1.7.1.	No
includeDestClasses	This attribute controls whether to include the destination classes directory in the classpath given to the compiler. The default value of this is "true" and this means that previously compiled classes are on the classpath for the compiler. This means that "greedy" compilers will not recompile dependant classes that are already compiled. In general this is a good thing as it stops the compiler for doing unnecessary work. However, for some edge cases, involving generics, the javac compiler needs to compile the dependant classes to get the generics information. One example is documented in the bug report: Bug 40776 - a problem compiling a Java 5 project with generics. Setting the attribute to "false" will cause the compiler to recompile dependent classes. Since Ant 1.7.1.	No - default is "true"
createMissingPackageInfoClass	Some package level annotations in `package-info.java` files don't create any `package-info.class` files so Ant would recompile the same file every time. Starting with Ant 1.8 Ant will create an empty `package-info.class` for each `package-info.java` if there isn't one created by the compiler. In some setups this additional class causes problems and it can be suppressed by setting this attribute to "false". Since Ant 1.8.3.	No - default is "true"

Parameters specified as nested elements

This task forms an implicit FileSet andsupports most attributes of <fileset>(dir becomes srcdir) as well as the nested<include>, <exclude> and<patternset> elements.

`srcdir`, `classpath`, `sourcepath`,`bootclasspath` and `extdirs`

<javac>'s srcdir, classpath,sourcepath, bootclasspath, andextdirs attributes arepath-like structuresand can also be set via nested<src> (note the different name!),<classpath>,<sourcepath>,<bootclasspath> and<extdirs> elements, respectively.

compilerarg

You can specify additional command line arguments for the compilerwith nested <compilerarg> elements. These elementsare specified like Command-lineArguments but have an additional attribute that can be used toenable arguments only if a given compiler implementation will beused.

Attribute	Description	Required
value	See Command-line Arguments.	Exactly one of these.
line
file
path
prefix	See Command-line Arguments. Since Ant 1.8.	No
suffix	See Command-line Arguments. Since Ant 1.8.	No
compiler	Only pass the specified argument if the chosen compiler implementation matches the value of this attribute. Legal values are the same as those in the above list of valid compilers.)	No

compilerclasspath since Ant 1.8.0

A PATH like structure holding the classpath to use when loading the compiler implementation if a custom class has been specified. Doesn't have any effect when using one of the built-in compilers.

Any nested element of a type that implements CompilerAdapter since Ant 1.8.0

If a defined type implements the CompilerAdapter interface a nested element of that type can be used as an alternative to the compiler attribute.

Examples

  <javac srcdir="${src}" destdir="${build}" classpath="xyz.jar" debug="on" source="1.4"  />

compiles all .java files under the ${src}directory, and storesthe .class files in the ${build} directory.The classpath used includes xyz.jar, and compiling withdebug information is on. The source level is 1.4,so you can use assert statements.

  <javac srcdir="${src}" destdir="${build}" fork="true" source="1.2" target="1.2"  />

compiles all .java files under the ${src}directory, and stores the .class files in the${build} directory. This will fork off the javaccompiler using the default javac executable.The source level is 1.2 (similar to 1.1 or 1.3) andthe class files should be runnable under JDK 1.2+ as well.

  <javac srcdir="${src}" destdir="${build}" fork="java$$javac.exe" source="1.5"  />

compiles all .java files under the ${src}directory, and stores the .class files in the${build} directory. This will fork off the javaccompiler, using the executable named java$javac.exe. Notethat the $ sign needs to be escaped by a second one.The source level is 1.5, so you can use generics.

  <javac srcdir="${src}" destdir="${build}" includes="mypackage/p1/**,mypackage/p2/**" excludes="mypackage/p1/testpackage/**" classpath="xyz.jar" debug="on"  />

compiles .java files under the ${src}directory, and stores the.class files in the ${build} directory.The classpath used includes xyz.jar, and debug information is on.Only files under mypackage/p1 and mypackage/p2 areused. All files in and below the mypackage/p1/testpackagedirectory are excluded from compilation.You didn't specify a source or target level,so the actual values used will depend on which JDK you ran Ant with.

  <javac srcdir="${src}:${src2}" destdir="${build}" includes="mypackage/p1/**,mypackage/p2/**" excludes="mypackage/p1/testpackage/**" classpath="xyz.jar" debug="on"  />

is the same as the previous example, with the addition of a secondsource path, defined bythe property src2. This can also be represented using nested<src> elements as follows:

  <javac destdir="${build}" classpath="xyz.jar" debug="on"> <src path="${src}"/> <src path="${src2}"/> <include name="mypackage/p1/**"/> <include name="mypackage/p2/**"/> <exclude name="mypackage/p1/testpackage/**"/>  </javac>

If you want to run the javac compiler of a different JDK, youshould tell Ant, where to find the compiler and which version of JDKyou will be using so it can choose the correct command line switches.The following example executes a JDK 1.1 javac in a new process anduses the correct command line switches even when Ant is running in aJava VM of a different version:

  <javac srcdir="${src}" destdir="${build}" fork="yes" executable="/opt/java/jdk1.1/bin/javac" compiler="javac1.1"  />

Note:If you wish to compile only source files located in certain packages below acommon root, use the include/exclude attributesor <include>/<exclude> nested elementsto filter for these packages. Do not include part of your package structurein the srcdir attribute(or nested <src> elements), or Ant will recompile yoursource files every time you run your compile target. See theAnt FAQfor additional information.

If you wish to compile only files explicitly specified and disablejavac's default searching mechanism then you can unset the sourcepathattribute:

  <javac sourcepath="" srcdir="${src}" destdir="${build}" > <include name="**/*.java"/> <exclude name="**/Example.java"/>  </javac>

That way the javac will compile all java source files under "${src}"directory but skip the examples. The compiler will even produce errors if some ofthe non-example files refers to them.

If you wish to compile with a special JDK (another than the one Ant is currently using),set the executable and fork attribute. Using tasknamecould show in the log, that these settings are fix.

  <javac srcdir=""  destdir="" executable="path-to-java14-home/bin/javac"  fork="true" taskname="javac1.4" />

Note: If you are using Ant on Windows and a new DOS window pops upfor every use of an external compiler, this may be a problem of the JDK you areusing. This problem may occur with all JDKs < 1.2.

If you want to activate other compiler options like lint you could usethe <compilerarg> element:

  <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="libraries"> <compilerarg value="-Xlint"/>  </javac>

If you want to use a custom CompilerAdapter org.example.MyAdapter you can either use the compiler attribute:

<javac srcdir="${src.dir}"   destdir="${classes.dir}"   compiler="org.example.MyAdapter"/>

or a define a type and nest this into the task like in:

<componentdef classname="org.example.MyAdapter"  name="myadapter"/><javac srcdir="${src.dir}"   destdir="${classes.dir}">  <myadapter/></javac>

in which case your compiler adapter can support attributes and nested elements of its own.

Jikes Notes

You need Jikes 1.15 or later.

Jikes supports some extra options, which can be set be definingthe properties shown below prior to invoking the task. The settingfor each property will be in affect for all <javac>tasks throughout the build.The Ant developers are aware thatthis is ugly and inflexible – expect a better solution in the future.All the options are boolean, and must be set to true oryes to beinterpreted as anything other than false. By default,build.compiler.warnings is true,while all others are false.

Property	Description	Default
build.compiler.emacs	Enable emacs-compatible error messages.	`false`
build.compiler.fulldepend	Enable full dependency checking; see the `+F` switch in the Jikes manual.	`false`
build.compiler.pedantic	Enable pedantic warnings.	`false`
build.compiler.warnings Deprecated. Use `<javac>`'s `nowarn` attribute instead.	Don't disable warning messages.	`true`

Jvc Notes

Jvc will enable Microsoft extensions unless you set the propertybuild.compiler.jvc.extensions to false before invoking<javac>.

Bootstrap Options

The Sun javac compiler has a bootclasspath command line option - this corresponds to the "bootclasspath" attribute/element of the <javac> task. The Sun compiler also allows more control over the boot classpath using the -X and -J-X attributes. One can set these by using the <compilerarg>. Since Ant 1.6.0, there is a shortcut to convert path references to strings that can by used in an OS independent fashion (see pathshortcut). For example:

  <path id="lib.path.ref"> <fileset dir="lib" includes="*.jar"/>  </path>  <javac srcdir="src" destdir="classes"> <compilerarg arg="-Xbootclasspath/p:${toString:lib.path.ref}"/>  </javac>

OpenJDK Notes

The openjdk project has provided the javac compiler as an opensource project. The output of this project is a javac.jar which contains the javac compiler. This compiler may be used with the <javac> task with the use of a -Xbootclasspath/p java argument. The argument needs to be given to the runtime system of the javac executable, so it needs to be prepended with a "-J". For example:

  <property name="patched.javac.jar" location="${my.patched.compiler}/dist/lib/javac.jar"/>  <presetdef name="patched.javac"> <javac fork="yes">  <compilerarg value="-J-Xbootclasspath/p:${patched.javac.jar}"/> </javac>  </presetdef>  <patched.javac srcdir="src/java" destdir="build/classes" debug="yes"/>

Note on package-info.java

package-info.java files were introduced in Java5 to allow package level annotations. On compilation, if the java file does not contain runtime annotations, there will be no .class file for the java file. Up to Ant 1.7.1, when the <javac> task is run again, the task will try to compile the package-info java files again.

With Ant 1.7.1 a different kind of logic was introduced that involved the timestamp of the directory that would normally contain the .class file. This logic turned out to lead to Ant not recompiling package-info.java in certain setup.

Starting with Ant 1.8.0 Ant will create "empty" package-info.class files if it compiles a package-info.java and no package-info.class file has been created by the compiler itself.

» Authors » The Apache Software Foundation

(Sebelumnya) Java

JavaCC (Berikutnya)