1. Java Class Structure

2. Class Structure package declaration import statements class declaration class (static) variable declarations* instance variable declarations* constructor* class (static) methods* instance methods* * order immaterial

3. Package Declaration package packageName; first statement in the.java file (excepting comments) package components separated by dot; e.g., package uwt.css142.examples; packaged class files must live in a parallel directory structure; e.g., C:\java\classes\uwt\css142\examples CLASSPATH environment variable must point to parent directory; e.g., set CLASSPATH=.;C:\java\classes

4. Import Statements import packageName.className; import packageName.*; OR use fully-qualified name of class java.lang.* is imported automatically classes in the same package as the class being written don’t need to be imported import java.awt.Font; import java.awt.*; java.awt.Font f = new java.awt.Font(...);

5. Class Declaration [VisibilityModifier] class ClassName [extends SuperClassName] [implements SomeInterface[, AnotherInterface]] { visibility: public, default a public class must live in a file of the same name, with a.java suffix –this implies only one public class per file a class extends java.lang.Object by default public class MyClass extends Applet implements ActionListener, ItemListener

6. Visibility Modifiers public - visible everywhere protected - visible in subclasses and within the package default - visible within the package (no keyword) private - visible within the class only

7. Variable Declarations [visibility][static][final]type name [= value]; visibility: public, protected, private, default kinds of variables –class (static) variables –instance variables –local variables (visibility modifiers do not apply) final keyword indicates that the initial value of the variable cannot be changed –Can only be assigned to once –naming convention: all uppercase, with underscores –e.g, final double METERS_PER_FOOT =.3048;

8. Class (static) Variables not associated with an instance of the class (i.e, an object) are declared within a class but not inside any method are declared with the static keyword only one copy exists, no matter how many objects accessible to all objects private static int count; private static int nextAcctNo; public class (static) constants: public static final int BOLD = 1; public static final int ITALIC = 2; public static final int PLAIN = 4; – accessed through the class name: Font.BOLD

9. Instance Variables Hold the instance data for objects are declared within a class but not inside any method do not have the static keyword each object has its own copy are available throughout the class are usually hidden private String text; // hidden data public void setText (String s) // setter public String getText() // getter

10. Local Variables are defined inside the body of a method, loop, or other statement block ({}), or in a parameter list, or in for statement have no visibility modifier known only within the code block where defined can shadow instance variables of same name public class BankAccount { private double balance; // instance variable public BankAccount (double initBalance) { double balance = initBalance; // error }...

11. Method Definition [visibility] [static] returnType methodName ([Type param1], [Type param2],...) the body of the method is delineated by { } parameters are only known within the method (local variables) a return type must be declared; if the method returns nothing, use void if not returning void, every path through the method must have a return statement which returns data of the specified type There is an implied return statement at the end of a method that returns void; return statements may be inserted at other points e.g., public static int computeSum (int a, int b) { return a + b; } to invoke the above method from within the same class: int sum = computeSum (2*count, 145); int ans = computeSum (computeSum(4,9), 145);

12. Instance Methods the default; no static keyword must be invoked on an instance of the class, i.e., an object purpose is to access instance data e.g., public class BankAccount { private double balance; public double deposit (double amount) { balance = balance + amount; return balance; } invoked via an object of that class: BankAccount myAcct = new BankAccount (1000); double bal = myAcct.deposit (500);

13. Class (static) Methods identified by the static keyword NOT associated with an object e.g., public class Utilities { public static double centToFahr(double cent) { return cent * 9 / 5. + 32; } invoked via the class name: double f = Utilities.centToFahr (20.) all data must be hard-coded or passed as parameter (or static) cannot access instance data

14. Method Overloading Suppose you want methods to operate on different parameter types: –void printInt (int i) –void printDouble (double d) –void printString (String s) Another way: methods of the same name are distinguished by their parameter types –void print (int i) –void print (double d) –void print (String s) Same name, but no compiler error as long as parameters are different in number and/or type; (return type not part of signature) Often used in the java API; e.g, valueOf(), indexOf() in String class have several variations

15. Constructors Invoked by the new operator to create an object Definition similar to method syntax, except no static option and no return type Constructor name is same as that of class Constructors may take parameters May be more than one constructor with different parameters (overloaded) Should generally be public Supply only if needed to initialize instance data public class Student { public Student () {...} public Student(String name) {...} public Student(String name, String major) {...} public Student(String name, String major, double gpa, int credits) {...} }

16. Constructors (continued) With overloaded constructors, it is common to have one constructor do all the work; the other constructors simply call it with the required parameters this (…); when used in a constructor, invokes another constructor of the same class public class Student { public Student(String name, String major){ this (name, major, 0.0, 0) } public Student(String name, String major, double gpa, int credits){ this.name = name;... }

17. Constructors (cont.) Every class must have a constructor The first thing a constructor must do is invoke its superclass constructor super(); or another constructor of the same class this(); If the author does not supply a constructor, the compiler will create one that takes no arguments and just calls its superclass constructor If the author supplies any constructor, the compiler does not create the no-args constructor If the author’s constructor does not invoke the superclass constructor, the compiler inserts an invocation of the no-args superclass constructor; if the superclass doesn’t have such a constructor, the class won’t compile In this way, the compiler assures the chaining of constructor invocations, from superclass to subclass supply a constructor if there is data to pass, or if the superclass doesn’t have a no-args constructor