Object-Oriented Programming with Java Lecture Notes

15 April 2008 • Java Programs

Outline

• Review.

• Jar files.

Naming

• A class is named both by its class name and its package.

  • Class C in package A.B is called class A.B.C

  • The name C is a declared nickname (via import) for A.B.C

Packages

• A package is a set of conceptually related class files.

  • The class files are actually related by the package name.

• A package usualy isn't a program, but may be a significant part of a program.

  • Also, package classes don't have to define main().

• Package names are hierarchical, with sub-packages making up the hierarchy.

Java Programs

• A Java program is a set of one or more class files.

  • At least one of which defines

    public static void main(String[])
    

• A program's class files don't have to be bundled together, and don't even have to be gathered together.

  • Given packages, they couldn't be.

Package Location

• Packages can be widely dispersed.

  • javac and java have to be told package location via the classpath.

  

Jar Files

• A jar file (Java archive) is a collection of packages.

  • A jar file provides a single location for dispersed packages.

  

Using Jar Files

• The Java compiler and run-time can search jar files when looking for class files.

• Jar files are added to the class path along with the paths to packages.

  $ java -classpath A.jar:B.jar:C.jar A.main

• Jar files are searched as found while working through the class path.

Locating Jar Files

• Unlike package names, jar-file names must appear in the classfile.

  -classpath P finds view but not j.jar. -classpath P/j.jar finds j.jar but not view.

  -classpath P:P/j.jar finds both, searching view first.
  -classpath P/j.jar:P finds both, searching j.jar first.

Making Jar Files

• The jar command manipulates jar files.

  • Including making them and listing their contents.

  • jar is similar to Unixoid archiving tools like ar and tar.

• The general command format is

  $ jar options arguments
  

• See the jar man page more details.

Listing Jar Files

• The t jar option lists a jar file’s (table of) contents.

• The general command format is

  

List Example

$ jar tf solitaireGUI.jar
META-INF/
META-INF/MANIFEST.MF
shared/Card.class
shared/CardList.class
[ blah blah blah ]
shared/Talon.class
shared/VarStack.class
solitaireGUI/AppletFrame.class
solitaireGUI/BadCardPileException.class
[ blah blah blah ]
solitaireGUI/TSApr141811.class
solitaireGUI/utils.class

$ 

Reading The Listing

• What does the

  solitaireGUI/utils.class
  

  entry in the jar listing mean?

• It means the jar file contains the utils class in the solitaireGUI package.

• The general interpretation is

  pkg/.../pkg/x.class
  

Creating Jar Files

• The c jar option creates a jar file.

  • c gets all arguments unused by other options.

• The general command format is

  

Create Example

$ ls
blue  red

$ jar cf j.jar blue/*.class red/*.class

$ ls
blue  j.jar  red

$ jar tf j.jar
META-INF/
META-INF/MANIFEST.MF
blue/m.class
red/m.class

$ 

Program-Like Jars

• Putting everything a program needs in one jar file essentially makes the jar file the program.

  • Except for one thing.

    $ java -classpath eagles-wing.jar ???
    

    Where's the class with main()?

  • And maybe the -classpath too.

Manifests

• A manifest is a simply structured text file containing information about a jar file and its contents.

  • A jar's manifest is related to the first few lines of the jar's listing.

    $ jar tf j.jar
    META-INF/
    META-INF/MANIFEST.MF
    [ blah blah blah ]
    
    $

Adding Manifests

• The m jar option adds a manifest to a jar file.

  

• Make sure the mf option order matches the argument order.

  

Main-Class Entries

• Every manifest starts with the line

  Manifest-Version: 1.0
  

• The Main-Class: x manifest line tells the JVM to run x.main() to start execution.

• Main-Class:-enabled jar files can be run with the -jar java option.

  $ java -jar eagles-wing.jar
  # execuion begins...
  

Example

$ cat red/m.java
package red;

class hw {
  public static void
  main(String args[]) {
    System.out.println("hello world!");
    }
  }

$ javac red/m.java

$ java red.hw
hello world!

$ 

Example..

$ jar cf hw.jar red/*class

$ jar tf hw.jar
META-INF/
META-INF/MANIFEST.MF
red/hw.class

$ mv red /tmp

$ java red.hw
Exception in thread "main" 
java.lang.NoClassDefFoundError: red/hw

$ java -classpath hw.jar red.hw
hello world!

$ java -jar hw.jar
Failed to load Main-Class manifest attribute from
hw.jar

$ 

Example...

$ cat manifest
Manifest-Version: 1.0
Main-Class: red.hw

$ jar cmf manifest hw.jar red/*class
red/*class : no such file or directory

$ jar xf hw.jar

$ jar cmf manifest hw.jar red/*class

$ java -jar hw.jar
hello world!

$