1 / 42

Object-Oriented Programming (Java) Unit 21

Object-Oriented Programming (Java) Unit 21. Kirk Scott. Applets and Self-Executable .jar Files. 21.1 Turning an Application into an Applet and Putting It into a Web Page 21.2 Turning an Application into a Self-Executable .jar File.

maddox
Download Presentation

Object-Oriented Programming (Java) Unit 21

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Object-Oriented Programming (Java) Unit 21 Kirk Scott

  2. Applets and Self-Executable .jar Files • 21.1 Turning an Application into an Applet and Putting It into a Web Page • 21.2 Turning an Application into a Self-Executable .jar File

  3. 21.1 Turning an Application into an Applet and Putting It into a Web Page • Simple applets were introduced in Unit 5. • It is possible to turn a graphical application into an applet. • This is illustrated here with the ClickHand application. • To turn an application into an applet, take the following steps:

  4. 1. import java.awt.* and javax.swing.*. • 2. Change the class to an applet by having it extend JApplet. • 3. Replace the main() method with an init() method.

  5. The init() method should contain the code from the frame class constructor that creates the contents of the frame. • It cannot contain any code that refers to the frame, such as giving it a title or a size. • 4. Remove the frame class and all references to it from the code.

  6. An illustration follows • Here are the main() method and the frame class of the ClickHand application before being changed to an applet • It is not necessary to show the rest of the code, because it is not affected by the conversion

  7. import java.awt.*; • import java.awt.event.*; • import javax.swing.*; • import java.awt.Graphics2D; • import java.awt.Rectangle; • import java.awt.geom.Ellipse2D; • import java.awt.geom.Point2D; • import java.lang.*; • import java.util.*;

  8. public class ClickHandBefore • { • public static void main(String[] args) • { • ClickHandFrame myframe = new ClickHandFrame(); • myframe.setVisible(true); • } • }

  9. class ClickHandFrame extends JFrame • { • private ClickHandPanel myPanel; • private final int FRAMEW = 500; • private final int FRAMEH = 500; • public ClickHandFrame() • { • setTitle("ClickHand Frame"); • setSize(FRAMEW, FRAMEH); • myPanel = new ClickHandPanel(); • Container contentPane = getContentPane(); • contentPane.add(myPanel, "Center"); • addWindowListener(new WindowCloser()); • }

  10. private class WindowCloser extends WindowAdapter • { • public void windowClosing(WindowEvent event) • { • System.exit(0); • } • } • }

  11. This is how the code looks after the conversion • Things are shown as commented rather than being completed removed • A complete, runnable version of this code is available separately.

  12. import java.awt.*; • import java.awt.event.*; • import javax.swing.*; • import java.awt.Graphics2D; • import java.awt.Rectangle; • import java.awt.geom.Ellipse2D; • import java.awt.geom.Point2D; • import java.lang.*; • import java.util.*;

  13. public class ClickHandAfter extends JApplet • { • /* • public static void main(String[] args) • { • ClickHandFrame myframe = new ClickHandFrame(); • myframe.setVisible(true); • } • } • class ClickHandFrame extends JFrame • { • private ClickHandPanel myPanel; • private final int FRAMEW = 500; • private final int FRAMEH = 500; • public ClickHandFrame() • { • setTitle("ClickHand Frame"); • setSize(FRAMEW, FRAMEH); • */

  14. public void init() • { • ClickHandPanel myPanel = new ClickHandPanel(); • Container contentPane = getContentPane(); • contentPane.add(myPanel, "Center"); • } • } • /* • addWindowListener(new WindowCloser()); • } • private class WindowCloser extends WindowAdapter • { • public void windowClosing(WindowEvent event) • { • System.exit(0); • } • } • } • */

  15. To get the applet into a Web page, you need to have an html file with the correct codes in it • Here is a simple example for ClickHand • The html requires the existence of a compiled class file for the applet • The html shown below is written under the assumption that the class file is in the same folder as the html file • Notice that sizing the applet in the Web page is done in the html since the applet does not have a frame.

  16. <html> • <title>ClickHand as an Applet</title> • <body> • Here is ClickHandApplet. • <applet code="ClickHandApplet.class" width="500" height="500"> • </applet> • </body> • </html>

  17. 21.2 Turning an Application into a Self-Executable jar File • It is convenient to be able to group together the components of an application in a single file which can be run without having to open it as source code and compile it first • Such a file is known as a self-executable • jar files, which have the extension .jar, can be used for this purpose in Java

  18. The abbreviation jar stands for Java Archive. • In general, jar files are compressed, although the compression option can be turned off. • It is possible to create a jar file simply for the sake of compression as well as creating one for the sake of self-execution

  19. When making a self-executable jar file it is easy to make a small mistake and end up with something that doesn’t work • Remember to check your results to make sure you got what you wanted • To turn an application into a self-executable jar file, take the following steps:

  20. 1. Compile the source code of the application so that .class files are produced • Compilation of a given set of source files might result in more than that number of class files, depending on how many classes were defined in the source files. • All of the resulting class files are needed

  21. 2. Make sure that you are doing this with an application, not an applet. • Applets have init() methods instead of main() methods • A self-executable has to have a class containing a main() method in order to work

  22. 3. Write a manifest file • A manifest file should have the extension .mf • The file can be given any name

  23. In the manifest file you specify which class in the application is the main class • The manifest file for this example has the name mainclass.mf, and it has these contents: • Main-Class: ClickHand

  24. It is important to note three things about the contents of this file • 1) The file name ClickHand does not take an extension • 2) The file name ClickHand is followed by a new line. • The manifest file won’t work correctly if its contents are not followed by a new line. • 3) There is only one space between the colon and the file name ClickHand

  25. There is also one other word of warning: • Depending on the editor you use to make the file and the operating system environment, it is possible to create a file which has a .mf extension, but which has been saved as a .txt file. • If later on the jar utility claims that it can’t find the manifest file, double check whether or not the file was saved with the right extension and type.

  26. Assume that the path on your system is set up so that you can run executables from the Java bin folder at any location • Also assume that all of the class files resulting from compilation are sitting together in a single folder along with the manifest file

  27. Then you create the self-executable jar file by entering the following command at a command prompt for that folder: • jar cvfm ClickHand.jar mainclass.mf *.class

  28. If desired, it would be possible to list all of the class files rather than using the wildcard expression *.class • The successful outcome of this command is a new file, ClickHand.jar, in the same folder.

  29. In case you’re curious, the options cvfm stand respectively for the following: • c: Create. This says that you are using the jar command to create a jar file. • v: Verbose. This says that an informational message will be printed at the command prompt as each class file is added to the jar file.

  30. f: File. This says that the name of the jar file, ClickHand.jar, is specified after the options. • m: Manifest. This says that the name of the needed manifest file is specified after the name of the jar file.

  31. It is also possible to add a 0 (zero) to the option list. • This will cause the jar file to be created without compression. • There are other options, but they are not needed at this time.

  32. If the jar file is successfully created and the operating system is cooperative, it should be possible to run the self-executable by double clicking on its icon • Even if the operating system isn’t cooperative, if the jar file has been successfully created, it should be possible to run it from the command prompt by entering the command shown on the next overhead

  33. This will work at a location where it is possible to run commands in the Java bin folder • If you have to spend much time at the command prompt, it can be convenient to use this command to check your work from the keyboard without having to switch back to the mouse. • java –jar ClickHand.jar

  34. You may have problems running the jar command for creating a jar file and the java command for running a jar file depending on how Java was installed on your system • It is possible that they won’t run from the folder where you have compiled your application • The general solution to this problem is to make sure that the Java bin folder, the one containing commands like jar and java, is part of the path on your system

  35. These are the steps for accomplishing this: • 1. Go to: Start/Settings/Control Panel • 2. Click this icon/link: Performance and Maintenance • 3. Click this icon/link: System • 4. Click on this tab: Advanced

  36. 5. Click this button at the bottom: Environment Variables • 6. Highlight the PATH entry and click on the edit button • 7. Add this PATH entry: C:\Program Files\Java\jdk1.6.0\bin

  37. Notice that the different entries in the PATH are separated by semicolons • You don't want to mess up any entry that's already there • Also, point 7 above assumes that you have a standard installation of Java on your system • You should double check the path to the bin folder • You may also have a different version of Java installed, so you would want to look that up and use that version rather than jdk1.6.0 in the PATH

  38. If you don't want to mess with the PATH environment variable, there is a quick and dirty solution to the problem • The jar and java commands are located in the Java bin folder and they will run from a command prompt there • You can copy all of the files needed for making the jar file into the bin folder of the Java installation on your computer

  39. This includes both the class files from a successful compilation and the manifest file • Alternatively, you might decide to copy all of the source files to that folder and compile the application there • Then you can run the commands to create the jar file

  40. The shortcoming of this solution is that you clutter up the Java program folder with your files and you have to be careful when cleaning up so that you don’t delete any of the Java system files • There are two last words to the wise concerning this approach • You will probably find the Java folder in the Program Files folder • In the Java folder you will probably find both a jdk folder and a jre folder

  41. Each will probably have a bin folder • You want the jdk folder, not the jre folder • By default this folder may be set to “read only” • If you will be producing class or jar files there, you will need to remove this restriction.

  42. The End

More Related