• Statement:
  • A smallest syntactically valid construct that conveys a complete command
• Program:
  • A collection of statements to solve a particular problem in a particular imperative programming language

• Some Observations about Programs:
  • Understanding is inversely proportional to size
  • Reusability is inversely proportional to size
  • Small (and simple) components are easier to debug and fix than large (and complex) components
  • Portability is inversely proportional to size
• The Implication:
  • Programs should be modular (i.e., organized into small components)

• Method (Function, Procedure, Subroutine):
  • Loosely, an encapsulation of a "standalone" computation/algorithm
• Class (File):
  • Loosely, a collection of related methods (functions/procedures/subroutines) and information they use
• Package (Directory, Folder):
  • Loosely, a collection of related classes (files)

• All Programs:
  • Every program must consist of at least one class (called the "main" class)
  • The "main" class of all applications (one kind of Java program) must have a method that is the "entry point of the program" with the signature
    
    public static void main(String[] identifier)
    that is passed the command line arguments when the program is executed. Note: The formal parameter can have any identifier (though args is common) but must be a String[].
• Well-Designed Programs:
  • Consist of classes containing methods that are closely related to each other (i.e., are cohesive)
  • Use small methods, each of which serves a well-defined and easily-understood purpose

• Classes:
  • accessibility class name { [attributes]... [methods]... }
• File/Class Names:
  • The name of the file containing a class must be exactly the same as the name of the class (with .java appended)
  • A common style requirement is that class names must start with an uppercase letter
• For Now:
  • All of your classes must be public (more on this in CS159)

• Syntax:
  • accessibility [static] type name([type formal_parameter], ...)
• Style:
  • A common style requirement is that method names must start with a lowercase letter
• For Now:
  • All of your methods must be static indicating that the method "belongs to" the class (more on this later)
• Examples:
  • public static double circleArea(double diameter)
  • private static boolean isPrime(int n)

• Syntax:
  • class|object.name([actual_parameter], ...)
• For Now:
  • Since all methods "belong to" a class, they must all be invoked using the class name (again, more on this later)

• A Subtlety:
  • The class (or object) that the method "belongs to" can sometimes be inferred and, hence, can sometimes be omitted (which can be confusing to beginning programmers)
• Examples:
  • From a different class: Geometry.circleArea(5.0)
  • From the same class: circleArea(5.0)

• Another Subtlety:
  • When executing an application (e.g., from the command line or inside of an IDE) the name of the entry point is omitted (because it must be main())
• Example:
  • From the command line: java GradeCalculator

• Definition:
  • A named space that allows information to be passed to a method
• Types:
  • Formal - the named parameters in the declaration of a method (that are said to specify the interface to the method)
  • Actual - the parameters (which can be variables or literals) that are passed to a method when it is invoked
• Associating Actual and Formal Parameters:
  • In Java, the actual parameters are associated with the formal parameters based on their position
    

• An Important Detail of Java:
  • A copy of the actual parameter is passed
• An Implication:
  • The value of the actual parameter can't be changed in a method (though the value of the copy can be)
• Be Careful:
  • Remember that Java has reference types as well as atomic/primitive/fundamental types and a copy of an address can be used in ways that are very similar to the original address

• Definition:
  • The result of executing the statements in a method (a.k.a. evaluating the method) that is "returned to" the caller
• Number of Returned Values:
  • In Java, a method can return zero values (in which case it is said to be void) or one value

• Typed Methods:
  • The returned value has a type and the method is often said to be of that type
  • In the calling statement, the method evaluates to the returned value (if there is one), making it an expression
• void Methods:
  • The method changes the state of the system in some useful way (e.g., displays output, changes a global variable)

• A Simple Class with One Method:
  • public class Geometry { public static double rectangleArea(double width, double height) { return (width * height); } }
• Invoking/Calling this Method from Another Class:
  • area = Geometry.rectangleArea(300.0, 10.0);
• Invoking/Calling this Method from the Geometry Class:
  • area = rectangleArea(10.0, 10.0);

Review Questions

• What are the formal and actual parameters?
• What is the correspondence between the formal and actual parameters?
• Can the actual parameters be variables (not literals)?
• If they are, do the identifiers have to be the same? Can they be?

• In the Math Class:
  • double abs(double d), int abs(int i), ...
  • double sin(double d), ...
  • double log(double d), double log10(double d), ...
  • double min(double d, double e), double max(double d, double e), ...
  • double pow(double d, double p)
  • double sqrt(double d)
• In the Integer Class:
  • int parseInt(String s)
• In the Double Class:
  • double parseDouble(String s)
• In the Array Class:
  • int getLength(double[] a), ...

• The Need for Class Constants:
  • We frequently need to use the same constant in multiple methods (e.g., \(\pi\) is used in the calculation of the circumference and the area of a circle)
• An Observation:
  • Such constants can't be declared within a method (because they won't be accessible outside of that method)
• The Solution:
  • Declare and initialize them outside of any method (adding the static modifier)
  • If they are declared to be public they can even be used outside of the class (e.g., Math.PI)
  • If they are declared to be final they can't be changed

• Syntax:
  • accessibility static final type identifier = value;
• Examples:
  • public static final boolean CORRECT = true;
  • public static final double BUDGET = 100000.0;
  • private static final int CAPACITY = 5;
• When Are These Statements Executed?
  • Once, when the class is loaded

• In the Math Class:
  • E (base of the natural log)
  • PI
• In the Integer Class:
  • MIN_VALUE
  • MAX_VALUE
• In the Double Class:
  • NEGATIVE_INFINITY
  • POSITIVE_INFINITY
  • MIN_VALUE
  • MAX_VALUE

Make sure you can trace the execution of the above program assuming it is executed with a single command-line parameter (e.g., the String 10).

• The Concept:
  • The region of a program within which an entity can be referred to by name
• Some Common Types:

  Block	Within a block of code (i.e., between a { and })
  Method	Within a method (which includes both formal parameters and variables declared within the method)
  Class	Everywhere within a class
  Global	Everywhere