As the applications get a bit more involved (such as code existing in more than one package/directory or more complex classpath dependencies on third-party libraries and frameworks), this approach can become unwieldy. The next screen snapshot shows the results of this.įor the simplest Java applications, it is pretty straightforward to use javac and java to build and execute the application respectively as just demonstrated. In my directory structure shown in the screen snapshot above, this would mean that, assuming I'm running the javac command from the C:\java\examples\javacAndJava\ directory, I'd need to have something like this in my command: javac -sourcepath src src\dustin\examples\*.java.
#Compiling java class how to
More details on how to apply these options can be found in the tools documentation for javac for Windows or Unix/Linux.Īs the javac documentation states, the -sourcepath option can be use to express the directory in which the source files exist. The Oracle/Sun-provided javac command-line tool's standard options can be seen by running javac -help and additional extension options can be viewed by running javac -help -X. No matter which approach one uses to build Java code (Ant, Maven, Gradle, or IDE) normally, I believe it is prudent to at least understand how to build Java code with javac. class files because javac will not create that directory when it doesn't exist.īuilding with javac and Running with java I have also created classes subdirectory (which is currently empty) to place the compiled. The screen snapshot shows that the source files are in a directory hierarchy representing the package name ( dustin/examples because of package dustin.examples) and that this package-reflecting directory hierarchy is under a subdirectory called src. The next screen snapshot shows the directory structure with these class. Public static void main(final String arguments) Private final Parent parent = new Parent() Public class Child extends String toString() The code listings for the three classes are shown next. Two of the classes do not have main functions and the third class, Main.java does have a main function to allow demonstration of running the class without an IDE. To make this post's discussion more concrete, I will use some very simple Java classes that are related to each other via composition or inheritance and are in the same named package (not in the unnamed package) called dustin.examples. The rest of this post shows how to build and run Java code without an IDE for these situations. However, for the simplest of example applications, this is not always the case. I have a pretty good idea now how my much "overhead" my favorite Java IDEs require and make an early decision whether the benefits achieved from using the IDE are sufficient to warrant the "overhead." In most real applications, there's no question the IDE "overhead" is well worth it.
In my blog post Learning Java via Simple Tests, I wrote about how I sometimes like to use a simple text editor and command-line tools to write, build, and run simple applications.
This post focuses on how to do just that. A recent Java subreddit thread called " Compiling Java Packages without IDE" posed the question, "is a command that compiles a group of java files that are inside a package into a separate folder (let's just call it bin), and how would I go about running the new class files?" The post's author, kylolink, explains that "When I started out using Java I relied on Eclipse to do all the compiling for me and just worried about writing code." I have seen this issue many times and, in fact, it's what prompted my (now 4 years old) blog post GPS Systems and IDEs: Helpful or Harmful? I love the powerful modern Java IDEs and they make my life easier on a daily basis, but there are advantages to knowing how to build and run simple Java examples without them.
0 kommentar(er)
