Javac and Eclipse tutorial

Transcription

1 Javac and Eclipse tutorial Author: Balázs Simon, BME IIT, Contents 1 Introduction JRE and JDK Java and Javac Environment variables Setting the environment variables in Windows Setting the environment variables for a single command line Compiling and running from the command line Simple Hello World Using packages Using jar files The Eclipse development environment Download and install Using workspaces The development environment Creating a Java application Simple Hello World application Running the application Debugging the application Handling Jar files Creating Jar files Using Jar files Configuring Eclipse

2 1 Introduction The Java language is platform (operating system) independent. The compiled Java code is platform independent, too. This is the reason why no exe files are created when we compile Java programs. Java programs have to be executed a bit differently. The goal of this lesson is to get to know the compile and runtime environment of Java. At first we will exam the basic command line of Java, since it is important to see the model behind the scenes. After this we will use the Eclipse environment which hides the complexities of the command line from us. 2 JRE and JDK When we want to install Java we can choose from two options: Java Runtime Environment (JRE): this is for running Java applications. However, it cannot compile Java programs. Java Development Kit (JDK): this is for developing Java applications. It can compile and run Java programs. The JDK installer also contains a JRE installer. This means that we will have to use the JDK. After we compiled the program, the JRE is enough to run it. On a Windows operating system the default installation directory for the JRE is c:\program Files\Java\jreX.Y.Z_W, and it is c:\program Files\Java\jdkX.Y.Z_W for the JDK, where X.Y.Z_W is the version number. 3 Java and Javac The two most important programs in we will use are the following: java: the Java virtual machine for running compiled Java programs javac: the Java Compiler for compiling Java programs The java.exe program can be found both in the JRE and in the JDK under the bin folder: c:\program Files\Java\jreX.Y.Z_W\bin\java.exe c:\program Files\Java\jdkX.Y.Z_W\bin\java.exe The javac.exe program is in the bin folder of the JDK: c:\program Files\Java\jdkX.Y.Z_W\bin\javac.exe 2

3 4 Environment variables There are some useful environment variables to set for Java development: PATH: here searches the operating system the command line commands. It is useful to add the JDK bin library to this environment variable so that the java and javac commands are always available. JAVA_HOME: the installation folder of the JDK. A lot of Java program uses this environment variable, so it is very important to set this. CLASSPATH: here searches the Java runtime the compiled class files. It is usually not very wise to set this environment variable at the operating system level, since the different Java programs may use different CLASSPATH-s. The CLASSPATH can also be set for the java and javac commands as arguments, so usually it is not necessary to set it at the operating system level. However, it is important to know about this variable, since when some class files are not found by the Java runtime, the problem may be that the CLASSPATH variable has the wrong value. 4.1 Setting the environment variables in Windows After installing the JDK it is recommended to do the following steps. Open Control Panel and type environment variables in the search box in the upper right corner: 3

4 Click on the Edit the system environment variables link and the following window will open: Click on Environment Variables...: 4

5 If there is no JAVA_HOME in the list under User variables for... then add it to the list with the New... button! If it is already set use the Edit... button to correct its value if necessary! Make sure to include the appropriate version number in the path, e.g.: Look for the PATH environment variable in the list under System variables, and append the path of the JDK bin folder to the end separated by a semicolon, e.g.: To apply these changes you may have to restart your computer, but it is usually enough to close and reopen all the applications. 4.2 Setting the environment variables for a single command line The environment variables can also be set in the command line, e.g.: In this case these variables will only apply to this specific console and these settings live only until this window is closed. 5

6 5 Compiling and running from the command line 5.1 Simple Hello World In Java it is important that the name of the file and the name of the class implemented in the file must be the same! In notepad or in any other text editor write and save the following Java program as Hello.java: public class Hello { public static void main(string[] args) { System.out.println("Hello World!"); } } Enter the same library from the command line and issue the following command: javac Hello.java This results in a new Hello.class file. This file contains the compiled Java byte code. This file cannot be executed, however the Java Virtual Machine (JVM) can run it. To do this run the following command from the command line: java Hello Make sure to specify only the name of the class. The.class extension must not be given! The result will be: Hello World! It is possible that our program won t run and we receive an error message like: Exception in thread "main" java.lang.noclassdeffounderror: Hello Caused by: java.lang.classnotfoundexception: Hello at java.net.urlclassloader$1.run(unknown Source) at java.security.accesscontroller.doprivileged(native Method) at java.net.urlclassloader.findclass(unknown Source) at java.lang.classloader.loadclass(unknown Source) at sun.misc.launcher$appclassloader.loadclass(unknown Source) at java.lang.classloader.loadclass(unknown Source) at java.lang.classloader.loadclassinternal(unknown Source) Could not find the main class: Hello. Program will exit. This means that the Hello class is not found. This can have one of the following reasons: 1. There is an error in the Hello.java program and it won t compile. Correct the errors in the Java code so that it can compile. 2. The java Hello command was issued from the wrong directory, and the Hello.class does not exist in this directory. Make sure to issue this command from the same directory where the Hello.class file is. 3. The CLASSPATH environment variable has a wrong value and does not contain the current directory (denoted by a dot). To add the current directory to the CLASSPATH variable issue the following command: set CLASSPATH=%CLASSPATH%;. 6

7 5.2 Using packages Packages in Java can be used for structuring Java programs. Packages are mapped to folders in the file system. As it is important for files to have the same name as the implemented class, it is also important for packages to have the same name as the folder in the file system. This convention must be also followed in deeper folder- and package hierarchies. Create the following folder and file hierarchy ( > denotes the current directory): > o sample calc echo prog Calculator.java Echo.java Program.java The contents of the files should be the following: Calculator.java package sample.calc; public class Calculator { public int add(int a, int b) { return a+b; } } Echo.java package sample.echo; public class Echo { public int number(int a) { return a; } } 7

8 Program.java package sample.prog; import sample.echo.*; // imports all classes from the package import sample.calc.calculator; // imports only the Calculator class public class Program { public static void main(string[] args) { int x = 5; int y = 8; Calculator c = new Calculator(); int sum = c.add(x, y); Echo e = new Echo(); int sumecho = e.number(sum); System.out.println("sumEcho=" + sumecho); } } Notice that every file contains its package declaration at the beginning. The hierarchy is denoted by dots. If classes from other packages are required they can be imported by the import keyword. See the Program.java as an example. It is important to know how to compile and run programs with package hierarchies. The most important thing is to issue the commands from the directory denoted by >! To compile the source codes above run the following: javac sample\calc\*.java sample\echo\*.java sample\prog\*.java In this command we have to list all the directories since the javac command cannot discover them recursively. The compilation works also with slashes instead of backslashes: javac sample/calc/*.java sample/echo/*.java sample/prog/*.java After the compilation is successful, we have to specify the class file containing the main function for the java command. In our case it is the Program class. However, we also have to specify the fully qualified name containing also the packages. The separator is the dot: java sample.prog.program The result is: sumecho=13 If the commands are not issued from the folder denoted by > then we may encounter NoClassDefFoundError error messages. That s why it is so important to use the above rules. 8

9 5.3 Using jar files Since copying a lot of.class files is inconvenient, it is possible to couple them together in a single file. A coupling file like this is called a JAR file, which is basically a.zip file with a.jar extension. Such.jar files can be created with the jar.exe command. This can also be found in the bin folder of the JDK. Continuing with the previous example issue the following command from the folder denoted by > : jar cf hello.jar sample/calc/*.class sample/echo/*.class sample/prog/*.class The cf option means that we would like to create a new.jar file. The hello.jar is the name of the.jar file. The remaining parameters specify the files to be included in the.jar file. After this only the.jar has to be copied. The program can be started using the.jar file as follows: java -cp hello.jar sample.prog.program The -cp argument defines the CLASSPATH for the Java virtual machine. This is where the.class filed are looked for. In this case it means that the.class files should be loaded from the.jar file. This method is important because whole API libraries can be wrapped into.jar files. For example, the basic Java API is also installed this way under the JRE and JDK folders. The rt.jar contains most of the Java API. It is also possible to omit the class containing the main function from the command line. To do this we have to create a manifest description file. Create a file called MANIFEST.mf under the folder denoted by > with the following content: Main-Class: sample.prog.program Important: make sure to hit a return at the end of the line so that the file contains an empty line at the end of the file! After this issue the following command: jar cfm hello.jar MANIFEST.mf sample/calc/*.class sample/echo/*.class sample/prog/*.class The m option means that we are also passing a manifest file as a parameter. This file must be specified right after the.jar file. Now the program can be started as: java -jar hello.jar This.jar can also be executed from the operating system by a double click just like an ordinary.exe file. 9

10 6 The Eclipse development environment A development environment can hide the inconveniences of the command line. We will use Eclipse in the laboratory. 6.1 Download and install Eclipse can be downloaded from the following website: There are multiple editions here. The reason for this is that Eclipse can be extended with plugins, and for different tasks different extended Eclipse editions are available. Always make sure to download the Eclipse with the same architecture as the architecture of your JDK. For 32-bit JDK download Eclipse with 32-bit, for 64-bit JDK download Eclipse with 64-bit support. Otherwise, Eclipse won t start. We will use the Eclipse IDE for Java Developers edition. With this we can create simple standalone Java applications. For more complex server applications the Eclipse IDE for Java EE Developers edition is recommended. There are a lot of other editions of Eclipse, too. It is important to note that Eclipse uses the same commands in the background as we used in the previous chapters. Eclipse only hides these commands by its graphical user interface. So in order to develop applications in Eclipse, the JDK has to be installed and the JAVA_HOME environment variable must be properly set (see section 4.1). It is very easy to install Eclipse. The downloaded zip file has to be extracted and Eclipse can be run with the eclipse.exe program. 6.2 Using workspaces Applications in Eclipse are represented as projects. Dependencies can also be defined between projects, i.e. projects can use resources from other projects. The current set of projects is called a workspace. For multiple simple applications it is usually enough to create a single workspace, as it is enough for us, too. 10

11 When Eclipse is executed for the first time it asks which folder should be the workspace folder. Specify a folder you like and tick Use this as the default and do not ask again so that you won t be bothered with this question any more: 6.3 The development environment When Eclipse is run for the first time the following window is displayed: 11

12 Click on the arrow on the right! From now on we will meet the following window: The left side of the windows shows the projects, packages and classes in the workspace. The Problems tab shows the compile errors and warnings. The center of the windows contains the editors. The icons of the two most important commands can be found at the top: debug and run. In the right hand corner we can select the perspective. A perspective defines a set of tabs (windows) in Eclipse organized in a specific way aiding a specific kind of work. The Java perspective is shown in the picture above. The Debug perspective shown at debugging is a bit different. There are other perspectives, too. If a window we are looking for is not shown, it can be made visible by the menu Window > Show View >... where the three dots denotes the name of the window. If you cannot find the window here, make sure to select the appropriate perspective through the menu Window > Open Perspective >... 12

13 6.4 Creating a Java application To create a new application select the File > New > Project... menu. The following dialog box will be shown: This shows a list of project types supported by this edition of Eclipse. In other editions the list may be longer. If you cannot find the project type you need, check the selected perspective. We need the Java perspective. 13

14 To create a simple Java application select the Java Project under the Java folder, then click on the Next button. Here you can give the name of the project. Then click on Finish. After this the project is created: 14

15 6.5 Simple Hello World application Create a new Java project! Then select the File > New > Class menu and the following dialog will be shown: Here we can give the package name (package line), the class name (name line) and other options like super classes, implemented interfaces, whether to have an automatically generated main function, etc. Set the package name to hello and the name of the class to HelloWorld. Then click on Finish. The result is: 15

16 Modify the source code in the editor so that it looks like this: package hello; public class HelloWorld { public static void main(string[] args) { System.out.println("Hello World!"); } } Now we have completed our first Java application in Eclipse. 6.6 Running the application Open the black arrow next to the Run icon and select Run Configurations...: The following window is shown: 16

17 Select Java Application on the left side then click on the New launch configuration icon. After this Eclipse recognizes the class HelloWorld as the main class since it contains the main function: On the Arguments tab we can set other options such as command line arguments for our program and for the Java virtual machine (VM), but for now leave these empty: 17

18 On the other tabs even more options can be set, however, we do not need these now. Click on the Run button and the application will execute. In the Console tab we can see the result: After making changes to the program it can be executed again by opening the black arrow next to the Run icon and selecting the appropriate configuration: 18

19 6.7 Debugging the application Eclipse also supports debugging which makes finding and fixing bugs in our programs easier. To create a break point right click at the beginning of the line and select Toggle Breakpoint: After this a small sphere appears at the beginning of the line. This is where the execution of the program will pause during debugging: 19

20 To debug the program open the black arrow next to the Debug icon and select the appropriate configuration: After this the following message asks whether we would like to switch to the Debug perspective: 20

21 Tick the option Remember my decision and click on Yes. The Eclipse window will be rearranged: In the Debug window we can see where we are in the call hierarchy (call stack). In the Variables window we can see the current value of the variables. In the source code window we can see where we are in the program code. The Console window shows the output of the program until the current state. 21

22 Next to the Debug tab there are some useful icons: The Resume button resumes the execution until the next break point. The Terminate button terminates the execution. The Step into button enters the next function. The Step over runs the next function without entering and stops again at the next line. Press the Resume button! Then the program finishes and the Console window shows the output: To switch back to the original arrangement of the Eclipse windows click on the Java perspective in the upper right corner. 22

23 6.8 Handling Jar files Creating Jar files It is possible to crate.jar files under Eclipse. To create a.jar from the current project select the File > Export... menu, and select JAR file under the Java folder: Click on Next! On this page we can set the name of the.jar file and we can select which files of the projects we want to include in the.jar file: 23

24 Click on Next! On the next page select Save the description of this JAR in workspace and specify a Description file, too! This is useful because we won t need to run the wizard again to recreate the.jar file. After the changes the page should look like this: Click on Next again! Select the Generate the manifest file option and set the following on this page: 24

25 Finally click on Finish! After this the manifest, the jardesc and the jar file are created: To summarize again: The MANIFEST.mf contains the qualified name of the main program, i.e. the qualified name of the class containing the main function. The hello.jardesc is a description with which the.jar file can be easily recreated without running the wizard again. This can be done by right clicking the hello.jardesc and selecting the Create JAR menu. The hello.jar contains the.class files. When later we add new source files to the project they also have to be added to the.jardesc. To do this double click on the hello.jardesc file and make the required modifications. 25

26 6.8.2 Using Jar files It is very common that we need to use third party libraries. These usually come as.jar files. To use these.jar files in our project, right click on the project in the Package Explorer and select the Properties menu: In this window select Java Build Path. Find the Libraries tab where you can add.jar files to the project: 26

27 6.9 Configuring Eclipse The Eclipse environment can be customized. The configuration options can be changed under the Window > Preferences menu: Here we can set a lot of things. E.g. the colors and formatting of the source code, the hot keys, etc. There is a very important option that is turned off by default. This is line numbering which can be useful for finding errors. To turn on line numbering tick Show line numbers under General > Editors > Text Editors: 27