290 likes | 365 Views
EE2E1. JAVA Programming. Lecture 3 Java Programs and Packages. Contents. Java source files and class files Packages public/package/private scope The CLASSPATH environment variable. Java source files and class files.
E N D
EE2E1. JAVA Programming Lecture 3 Java Programs and Packages
Contents • Java source files and class files • Packages • public/package/private scope • The CLASSPATH environment variable
Java source files and class files • Java progams execute on the Java Virtual Machine (JVM) which is usually implemented as an interpreter and executed with the java command • Java source code is compiled to bytecode by the compiler executed with the javac command
Java source file Test.java public class Test{ public static void main(String[] args) { System.out.println(“Hi!”);} } Java compiler Java class file Test.class Java bytecode Hi! Java interpreter (JVM)
The name of the source file (Test.java)matches the name of the public class(Test) and produces a bytecode file Test.class • Only one public class per file is allowed (see later - public/package/private scope) • A source file can contain any number of classes and compilation produces a .class file for each class in the source file
Packages • Java groups classes into packages • The standard Java library is distributed over a number of packages including java.lang, java.util indicating sub-packages • We can create our own packages using the package keyword • In the following example, classes A and B are in the package my_package
package my_package; class A { // A’s public & private members } class B { // B’s public & private members }
The default package • If a source file does not begin with the package statement, the classes contained in the source file reside in the default package • The java compiler automatically looks in the default package to find classes (see later) • It then searches all imported packages to find the remaining classes (see later)
Importing packages • The import statement imports packages by directing the compiler where to look • The import statement in a Java program must occur before any class definition • Either the whole package or a sub-package can be imported • Either all of the classes in a package can be imported or just a particular class from the package
public/package/private scope • Scope is concerned with the visibility of program elements such as classes and members • Both classes and class members (methods or instance fields) can be defined with public, package or private scope • A class with public scope means it is visible outside its containing package
A class member with publicscope means it is visible anywhere its class is visible • A class member with privatescope means it is visible only within its encapsulating class • A class with package scope means it is visible only inside its containing package
Example 1 package my_package; class A // package scope { // A’s public & private members } public class B // public scope { // B’s public and private members }
class A has no private/public label and thus has, by default, package scope • class B has public scope • class A is visible only within the package but class B is visible outside the package also
package another_package; import my_package.*; class C { // C’s public & private members // class C ‘knows’ about class B private B b; // OK – class B has public scope }
package my_package; class D { // D’s public & private members // Class D ‘knows’ about classes A and B private B b; // OK – class B has public scope private A a; // OK – class A has package scope }
Example 2 package my_package; class A { int get() { return data; } // package scope public A(int d) { data=d;} private int data; // private scope } class B { void f() { A a=new A(d); int d=a.get(); // OK – get() has package scope int d1=a.data; // Error! – data is private } }
Example 3 package my_package; class A { public int get() { return data; } // public scope public A(int d) { data=d;} private int data; // private scope }
Even though member function get() has public scope, because class A only has package scope, the class and hence all of its member functions are only visible inside the package • If member functions are to be publicly visible, the class itself has to have public scope • In general, classes and their members should be given the narrowest possible scope appropriate to their functionality
The CLASSPATH environment variable • The compiler and runtime interpreter know how to find standard packages such as java.lang and java.util • The CLASSPATH environment variable is used to direct the compiler and interpreter to where programmer defined imported packages can be found • The CLASSPATH environment variable is an ordered list of directories and files
.;C:\java\my_package;C:\java\my_jar_file.jar • Example CLASSPATH’s • Windows • UNIX • A jar file is a Java archive file and is a collection of java class files (with the .class extension) • ‘.’ means the current directory. In some Java implementations, this is part of the CLASSPATH by default .; /home/java/my_package; /home/java/my_jar_file.jar
The above directories and jar files are searched in the order they appear in the CLASSPATH list for imported packages • The CLASSPATH list can be overridden with the –classpath option to the compiler : (javac –classpath …) and the interpreter (java –classpath …) • All files in a package must be in a sub-directory that matches the full package name • Eg. all files in package my_package.sub-package are in a sub-directory my_package/sub-package (Unix) which branches off one of the directories in the CLASSPATH
// source file “my_package/A.java” package my_package; public class A { int get() { return data; } public A(int d) { data=d;} private int data; } // source file “TestA.java” import my_package.A; class TestA { public static void main(String[] args){ A a=new A(100); } }
class TestA is in the default package • Package/sub-package directory matches the directory/sub-directory structure Package . (current directory) Default package Directory Package my_package Sub-directory ./my_package Sub-package
Example • We can create a Polygon class which represents a polygon as an array of points (vertices) • The Point class is imported as part of a (programmer defined) geometrical package geom • A method perimeter() computes the polygon’s perimiter • class PolygonTest contains a main method to test the Polygon class
package geom; public class Point { public Point(int x, int y) { xpos=x; ypos=y;} public int getX() { return xpos;} public int getY() { return ypos; } private int xpos, ypos; }
import geom.Point; public class Polygon { public Polygon(int n, Point[] v) { numVertices=n; vertices=new Point[n]; System.arraycopy(v,0,vertices,0,n); } public double perimeter() { double pm=0; int nn; for (int n=1; n<numVertices; n++) { int xv1= vertices[n-1].getX(); int yv1=vertices[n-1].getY(); nn=n%numVertices; int xv=vertices[nn].getX(); int yv=vertices[nn].getY(); pm+=(Math.sqrt((xv1-xv)*(xv1-xxv)+(yv1-yv)*(yv1-yv))); } return pm; } private Point[] vertices; private int numVertices; }
import geom.Point; public class PolygonTest { public static void main(String[] args) { Point[] pointArray={new Point(0,0), new Point(0,1), new Point(1,1), new Point(1,0)}; Polygon square=new Polygon(4,pointArray); double perim=square.perimeter(); System.out.println(“The perimeter is ” + perim); } }
class Point is in the geom package whereas classes Polygon and PolygonTest are in the default package • File Point.java will reside in a sub-directory geom or the current directory • class Point is made public so it is visible outside of its package • The geom package could be expanded to include other basic geometrical entities (line, curve etc) Default package Polygon.java PolygonTest.java Directory ‘.’ Sub-package geom Sub-directory geom Point.java
And finally…. • When writing seriously large Java applications, you will create many classes and several packages • Related classes will be grouped into packages • When you use a Java API, you normally have to set up the CLASSPATH environment variable so that its classes can be imported • Its important to understand the use of CLASSPATH • However, for your lab exercises, keeping all of your public classes in files with the same name as the class in the current directory will ensure all public classes are visible