Linux cli command javac

NAME 🖥️ javac 🖥️

read Java declarations and compile them into class files

SYNOPSIS

javac [options] [sourcefiles-or-classnames]

options
Command-line options.

sourcefiles-or-classnames
Source files to be compiled (for example, Shape.java) or the names of previously compiled classes to be processed for annotations (for example, geometry.MyShape).

DESCRIPTION

The javac command reads source files that contain module, package and type declarations written in the Java programming language, and compiles them into class files that run on the Java Virtual Machine.

The javac command can also process annotations in Java source files and classes.

Source files must have a file name extension of .java. Class files have a file name extension of .class. Both source and class files normally have file names that identify the contents. For example, a class called Shape would be declared in a source file called Shape.java, and compiled into a class file called Shape.class.

There are two ways to specify source files to javac:

• For a small number of source files, you can list their file names on the command line.

• For a large number of source files, you can use the @filename option on the command line to specify an argument file that lists their file names. See Standard Options for a description of the option and Command-Line Argument Files for a description of javac argument files.

The order of source files specified on the command line or in an argument file is not important. javac will compile the files together, as a group, and will automatically resolve any dependencies between the declarations in the various source files.

javac expects that source files are arranged in one or more directory hierarchies on the file system, described in Arrangement of Source Code.

To compile a source file, javac needs to find the declaration of every class or interface that is used, extended, or implemented by the code in the source file. This lets javac check that the code has the right to access those classes and interfaces. Rather than specifying the source files of those classes and interfaces explicitly, you can use command-line options to tell javac where to search for their source files. If you have compiled those source files previously, you can use options to tell javac where to search for the corresponding class files. The options, which all have names ending in “path”, are described in Standard Options, and further described in Configuring a Compilation and Searching for Module, Package and Type Declarations.

By default, javac compiles each source file to a class file in the same directory as the source file. However, it is recommended to specify a separate destination directory with the -d option.

Command-line options and environment variables also control how javac performs various tasks:

• Compiling code to run on earlier releases of the JDK.

• Compiling code to run under a debugger.

• Checking for stylistic issues in Java source code.

• Checking for problems in javadoc comments (/** ... */).

• Processing annotations in source files and class files.

• Upgrading and patching modules in the compile-time environment.

javac supports Compiling for Earlier Releases Of The Platform and can also be invoked from Java code using one of a number of APIs

OPTIONS

javac provides standard options, and extra options that are either non-standard or are for advanced use.

Some options take one or more arguments. If an argument contains spaces or other whitespace characters, the value should be quoted according to the conventions of the environment being used to invoke javac. If the option begins with a single dash (-) the argument should either directly follow the option name, or should be separated with a colon (:) or whitespace, depending on the option. If the option begins with a double dash (--), the argument may be separated either by whitespace or by an equals (=) character with no additional whitespace. For example,

-Aname="J. Duke"
-proc:only
-d myDirectory
--module-version 3
--module-version=3

In the following lists of options, an argument of path represents a search path, composed of a list of file system locations separated by the platform path separator character, (semicolon ; on Windows, or colon : on other systems.) Depending on the option, the file system locations may be directories, JAR files or JMOD files.

Standard Options

****@filename
Reads options and file names from a file. To shorten or simplify the javac command, you can specify one or more files that contain arguments to the javac command (except -J options). This lets you to create javac commands of any length on any operating system. See Command-Line Argument Files.

****-Akey[=value]
Specifies options to pass to annotation processors. These options are not interpreted by javac directly, but are made available for use by individual processors. The key value should be one or more identifiers separated by a dot (.).

--add-modules module,module
Specifies root modules to resolve in addition to the initial modules, or all modules on the module path if module is ALL-MODULE-PATH.

--boot-class-path path or -bootclasspath path
Overrides the location of the bootstrap class files.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details. For JDK 9 or later, see --system.

--class-path path, -classpath path, or -cp path
Specifies where to find user class files and annotation processors. This class path overrides the user class path in the CLASSPATH environment variable.

• If --class-path, -classpath, or -cp are not specified, then the user class path is the value of the CLASSPATH environment variable, if that is set, or else the current directory.

• If not compiling code for modules, if the --source-path or -sourcepath` option is not specified, then the user class path is also searched for source files.

• If the -processorpath option is not specified, then the class path is also searched for annotation processors.

-d directory
Sets the destination directory (or class output directory) for class files. If a class is part of a package, then javac puts the class file in a subdirectory that reflects the module name (if appropriate) and package name. The directory, and any necessary subdirectories, will be created if they do not already exist.

If the -d option is not specified, then javac puts each class file in the same directory as the source file from which it was generated.

Except when compiling code for multiple modules, the contents of the class output directory will be organized in a package hierarchy. When compiling code for multiple modules, the contents of the output directory will be organized in a module hierarchy, with the contents of each module in a separate subdirectory, each organized as a package hierarchy.

Note: When compiling code for one or more modules, the class output directory will automatically be checked when searching for previously compiled classes. When not compiling for modules, for backwards compatibility, the directory is not automatically checked for previously compiled classes, and so it is recommended to specify the class output directory as one of the locations on the user class path, using the --class-path option or one of its alternate forms.

-deprecation
Shows a description of each use or override of a deprecated member or class. Without the -deprecation option, javac shows a summary of the source files that use or override deprecated members or classes. The -deprecation option is shorthand for -Xlint:deprecation.

--enable-preview
Enables preview language features. Used in conjunction with either -source or --release.

-encoding encoding
Specifies character encoding used by source files, such as EUC-JP and UTF-8. If the -encoding option is not specified, then the platform default converter is used.

-endorseddirs directories
Overrides the location of the endorsed standards path.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

-extdirs directories
Overrides the location of the installed extensions. directories is a list of directories, separated by the platform path separator (; on Windows, and : otherwise). Each JAR file in the specified directories is searched for class files. All JAR files found become part of the class path.

If you are compiling for a release of the platform that supports the Extension Mechanism, then this option specifies the directories that contain the extension classes. See [Compiling for Other Releases of the Platform].

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

-g
Generates all debugging information, including local variables. By default, only line number and source file information is generated.

****-g:[lines, vars, source]
Generates only the kinds of debugging information specified by the comma-separated list of keywords. Valid keywords are:

lines
Line number debugging information.

vars
Local variable debugging information.

source
Source file debugging information.

-g:none
Does not generate debugging information.

-h directory
Specifies where to place generated native header files.

When you specify this option, a native header file is generated for each class that contains native methods or that has one or more constants annotated with the java.lang.annotation.Native annotation. If the class is part of a package, then the compiler puts the native header file in a subdirectory that reflects the module name (if appropriate) and package name. The directory, and any necessary subdirectories, will be created if they do not already exist.

**--help**, -help or -?
Prints a synopsis of the standard options.

--help-extra or -X
Prints a synopsis of the set of extra options.

--help-lint
Prints the supported keys for the -Xlint option.

****-implicit:[none, class]
Specifies whether or not to generate class files for implicitly referenced files:

• -implicit:class — Automatically generates class files.

• -implicit:none — Suppresses class file generation.

If this option is not specified, then the default automatically generates class files. In this case, the compiler issues a warning if any class files are generated when also doing annotation processing. The warning is not issued when the -implicit option is explicitly set. See Searching for Module, Package and Type Declarations.

****-Joption
Passes option to the runtime system, where option is one of the Java options described on java command. For example, -J-Xms48m sets the startup memory to 48 MB.

Note: The CLASSPATH environment variable, -classpath option, -bootclasspath option, and -extdirs option do not specify the classes used to run javac. Trying to customize the compiler implementation with these options and variables is risky and often does not accomplish what you want. If you must customize the compiler implementation, then use the -J option to pass options through to the underlying Java launcher.

--limit-modules module,module*
Limits the universe of observable modules.

**--module module-name (**,module-name)* or -m module-name (,module-name)*
Compiles those source files in the named modules that are newer than the corresponding files in the output directory.

--module-path path or -p path
Specifies where to find application modules.

--module-source-path module-source-path
Specifies where to find source files when compiling code in multiple modules. See [Compilation Modes] and The Module Source Path Option.

--module-version version
Specifies the version of modules that are being compiled.

-nowarn
Disables warning messages. This option operates the same as the -Xlint:none option.

-parameters
Generates metadata for reflection on method parameters. Stores formal parameter names of constructors and methods in the generated class file so that the method java.lang.reflect.Executable.getParameters from the Reflection API can retrieve them.

****-proc:[none, only]
Controls whether annotation processing and compilation are done. -proc:none means that compilation takes place without annotation processing. -proc:only means that only annotation processing is done, without any subsequent compilation.

**-processor class1[**,class2,class3…]
Names of the annotation processors to run. This bypasses the default discovery process.

--processor-module-path path
Specifies the module path used for finding annotation processors.

--processor-path path or -processorpath path
Specifies where to find annotation processors. If this option is not used, then the class path is searched for processors.

-profile profile
Checks that the API used is available in the specified profile.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

--release release
Compiles source code according to the rules of the Java programming language for the specified Java SE release, generating class files which target that release. Source code is compiled against the combined Java SE and JDK API for the specified release.

The supported values of release are the current Java SE release and a limited number of previous releases, detailed in the command-line help.

For the current release, the Java SE API consists of the java.*, javax.*, and org.* packages that are exported by the Java SE modules in the release; the JDK API consists of the com.* and jdk.* packages that are exported by the JDK modules in the release, plus the javax.* packages that are exported by standard, but non-Java SE, modules in the release.

For previous releases, the Java SE API and the JDK API are as defined in that release.

Note: When using --release, you cannot also use the --source/-source or --target/-target options.

Note: When using --release to specify a release that supports the Java Platform Module System, the --add-exports option cannot be used to enlarge the set of packages exported by the Java SE, JDK, and standard modules in the specified release.

-s directory
Specifies the directory used to place the generated source files. If a class is part of a package, then the compiler puts the source file in a subdirectory that reflects the module name (if appropriate) and package name. The directory, and any necessary subdirectories, will be created if they do not already exist.

Except when compiling code for multiple modules, the contents of the source output directory will be organized in a package hierarchy. When compiling code for multiple modules, the contents of the source output directory will be organized in a module hierarchy, with the contents of each module in a separate subdirectory, each organized as a package hierarchy.

--source release or -source release
Compiles source code according to the rules of the Java programming language for the specified Java SE release. The supported values of release are the current Java SE release and a limited number of previous releases, detailed in the command-line help.

If the option is not specified, the default is to compile source code according to the rules of the Java programming language for the current Java SE release.

--source-path path or -sourcepath path
Specifies where to find source files. Except when compiling multiple modules together, this is the source code path used to search for class or interface definitions.

Note: Classes found through the class path might be recompiled when their source files are also found. See Searching for Module, Package and Type Declarations.

--system jdk | none
Overrides the location of system modules.

--target release or -target release
Generates class files suitable for the specified Java SE release. The supported values of release are the current Java SE release and a limited number of previous releases, detailed in the command-line help.

Note: The target release must be equal to or higher than the source release. (See --source.)

--upgrade-module-path path
Overrides the location of upgradeable modules.

-verbose
Outputs messages about what the compiler is doing. Messages include information about each class loaded and each source file compiled.

--version or -version
Prints version information.

-Werror
Terminates compilation when warnings occur.

Extra Options

--add-exports module/package=other-module(,other-module)*
Specifies a package to be considered as exported from its defining module to additional modules or to all unnamed modules when the value of other-module is ALL-UNNAMED.

--add-reads module=other-module(,other-module)*
Specifies additional modules to be considered as required by a given module.

--default-module-for-created-files module-name
Specifies the fallback target module for files created by annotation processors, if none is specified or inferred.

****-Djava.endorsed.dirs=dirs
Overrides the location of the endorsed standards path.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

****-Djava.ext.dirs=dirs
Overrides the location of installed extensions.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

--patch-module module=path
Overrides or augments a module with classes and resources in JAR files or directories.

****-Xbootclasspath:path
Overrides the location of the bootstrap class files.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

****-Xbootclasspath/a:path
Adds a suffix to the bootstrap class path.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

****-Xbootclasspath/p:path
Adds a prefix to the bootstrap class path.

Note: This can only be used when compiling for releases prior to JDK 9. As applicable, see the descriptions in --release, -source, or -target for details.

****-Xdiags:[compact, verbose]
Selects a diagnostic mode.

-Xdoclint
Enables recommended checks for problems in javadoc comments

****-Xdoclint:(all|none|[-]group)[/access]
Enables or disables specific groups of checks,

group can have one of the following values:

• accessibility

• html

• missing

• reference

• syntax

The variable access specifies the minimum visibility level of classes and members that the -Xdoclint option checks. It can have one of the following values (in order of most to least visible):

• public

• protected

• package

• private

The default access level is private.

For more information about these groups of checks, see the -Xdoclint option of the javadoc command. The -Xdoclint option is disabled by default in the javac command.

For example, the following option checks classes and members (with all groups of checks) that have the access level of protected and higher (which includes protected and public):

-Xdoclint:all/protected

The following option enables all groups of checks for all access levels, except it will not check for HTML errors for classes and members that have the access level of package and higher (which includes package, protected and public):

-Xdoclint:all,-html/package

****-Xdoclint/package:[-]packages(,[-]package)*
Enables or disables checks in specific packages. Each package is either the qualified name of a package or a package name prefix followed by .*, which expands to all sub-packages of the given package. Each package can be prefixed with a hyphen (-) to disable checks for a specified package or packages.

-Xlint
Enables all recommended warnings. In this release, enabling all available warnings is recommended.

****-Xlint:[-]key(,[-]key)*
Supplies warnings to enable or disable, separated by comma. Precede a key by a hyphen (-) to disable the specified warning.

Supported values for key are:

• all: Enables all warnings.

• auxiliaryclass: Warns about an auxiliary class that’s hidden in a source file, and is used from other files.

• cast: Warns about the use of unnecessary casts.

• classfile: Warns about the issues related to classfile contents.

• deprecation: Warns about the use of deprecated items.

• dep-ann: Warns about the items marked as deprecated in javadoc but without the @Deprecated annotation.

• divzero: Warns about the division by the constant integer 0.

• empty: Warns about an empty statement after if.

• exports: Warns about the issues regarding module exports.

• fallthrough: Warns about the falling through from one case of a switch statement to the next.

• finally: Warns about finally clauses that do not terminate normally.

• module: Warns about the module system-related issues.

• opens: Warns about the issues related to module opens.

• options: Warns about the issues relating to use of command line options.

• overloads: Warns about the issues related to method overloads.

• overrides: Warns about the issues related to method overrides.

• path: Warns about the invalid path elements on the command l ine.

• processing: Warns about the issues related to annotation processing.

• rawtypes: Warns about the use of raw types.

• removal: Warns about the use of an API that has been marked for removal.

• requires-automatic: Warns developers about the use of automatic modules in requires clauses.

• requires-transitive-automatic: Warns about automatic modules in requires transitive.

• serial: Warns about the serializable classes that do not provide a serial version ID. Also warns about access to non-public members from a serializable element.

• static: Warns about the accessing a static member using an instance.

• try: Warns about the issues relating to the use of try blocks ( that is, try-with-resources).

• unchecked: Warns about the unchecked operations.

• varargs: Warns about the potentially unsafe vararg methods.

• none: Disables all warnings.

See Examples of Using -Xlint keys.

-Xmaxerrs number
Sets the maximum number of errors to print.

-Xmaxwarns number
Sets the maximum number of warnings to print.

****-Xpkginfo:[always, legacy, nonempty]
Specifies when and how the javac command generates package-info.class files from package-info.java files using one of the following options:

always
Generates a package-info.class file for every package-info.java file. This option may be useful if you use a build system such as Ant, which checks that each .java file has a corresponding .class file.

legacy
Generates a package-info.class file only if package-info.java contains annotations. This option does not generate a package-info.class file if package-info.java contains only comments.

Note: A package-info.class file might be generated but be empty if all the annotations in the package-info.java file have RetentionPolicy.SOURCE.

nonempty
Generates a package-info.class file only if package-info.java contains annotations with RetentionPolicy.CLASS or RetentionPolicy.RUNTIME.

****-Xplugin:name args
Specifies the name and optional arguments for a plug-in to be run. If args are provided, name and args should be quoted or otherwise escape the whitespace characters between the name and all the arguments. For details on the API for a plugin, see the API documentation for jdk.compiler/com.sun.source.util.Plugin.

****-Xprefer:[source, newer]
Specifies which file to read when both a source file and class file are found for an implicitly compiled class using one of the following options. See Searching for Module, Package and Type Declarations.

• -Xprefer:newer: Reads the newer of the source or class files for a type (default).

• -Xprefer:source : Reads the source file. Use -Xprefer:source when you want to be sure that any annotation processors can access annotations declared with a retention policy of SOURCE.

-Xprint
Prints a textual representation of specified types for debugging purposes. This does not perform annotation processing or compilation. The format of the output could change.

-XprintProcessorInfo
Prints information about which annotations a processor is asked to process.

-XprintRounds
Prints information about initial and subsequent annotation processing rounds.

-Xstdout filename
Sends compiler messages to the named file. By default, compiler messages go to System.err.

ENVIRONMENT VARIABLES

CLASSPATH

If the --class-path option or any of its alternate forms are not specified, the class path will default to the value of the CLASSPATH environment variable if it is set. However, it is recommended that this environment variable should not be set, and that the --class-path option should be used to provide an explicit value for the class path when one is required.

JDK_JAVAC_OPTIONS

The content of the JDK_JAVAC_OPTIONS environment variable, separated by white-spaces ( ) or white-space characters ( , , , or ) is prepended to the command line arguments passed to javac as a list of arguments.

The encoding requirement for the environment variable is the same as the javac command line on the system. JDK_JAVAC_OPTIONS environment variable content is treated in the same manner as that specified in the command line.

Single quotes (') or double quotes (") can be used to enclose arguments that contain whitespace characters. All content between the open quote and the first matching close quote are preserved by simply removing the pair of quotes. In case a matching quote is not found, the launcher will abort with an error message. **@**files are supported as they are specified in the command line. However, as in **@**files, use of a wildcard is not supported.

Examples of quoting arguments containing white spaces:

export JDK_JAVAC_OPTIONS='@"C:\white spacesrgfile"'

export JDK_JAVAC_OPTIONS='"@C:\white spacesrgfile"'

export JDK_JAVAC_OPTIONS='@C:\"white spaces"rgfile'

COMMAND-LINE ARGUMENT FILES

An argument file can include command-line options and source file names in any combination. The arguments within a file can be separated by spaces or new line characters. If a file name contains embedded spaces, then put the whole file name in double quotation marks.

File names within an argument file are relative to the current directory, not to the location of the argument file. Wildcards (*) are not allowed in these lists (such as for specifying *.java). Use of the at sign (@) to recursively interpret files is not supported. The -J options are not supported because they’re passed to the launcher, which does not support argument files.

When executing the javac command, pass in the path and name of each argument file with the at sign (@) leading character. When the javac command encounters an argument beginning with the at sign (@), it expands the contents of that file into the argument list.

Examples of Using javac @filename

Single Argument File
You could use a single argument file named argfile to hold all javac arguments:

javac @argfile

This argument file could contain the contents of both files shown in the following Two Argument Files example.

Two Argument Files
You can create two argument files: one for the javac options and the other for the source file names. Note that the following lists have no line-continuation characters.

Create a file named options that contains the following:

Linux and macOS:

-d classes
-g
-sourcepath /java/pubs/ws/1.3/src/share/classes

Windows:

-d classes
-g
-sourcepath C:\java\pubs\ws\1.3\src\share