•

There are three kinds of modules in Java – methods, classes, and packages. Methods are declared within classes. Classes are typically grouped into packages so that they can be imported into programs and reused.
Methods allow you to modularize a program by separating its tasks into self-contained units. The statements in a method are written only once and hidden from other methods.
A class may contain static methods to perform common tasks that do not require an object of the class. Any data a static method might require to perform its tasks can be sent to the method as arguments in a method call. A static method is called by specifying the name of the class in which the method is declared followed by a dot (.) and the method name, as in
ClassName.methodName( arguments )
Math.PI and Math.E are declared with the modifiers public, final, and static. Making them public allows other programmers to use these fields in their own classes. Any field declared with keyword final is constant – its value cannot be changed after the field is initialized. Both PI and E are declared final because their values never change. Making these fields static allows them to be accessed via the class name Math and a dot (.) separator, just like the class Math’s methods.
When objects of a class containing static fields (class variables) are created, all the objects of that class share one copy of the class’s static fields. Together the class variables and instance variables represent the fields of a class.
When you execute the JVM with the java command, the JVM attempts to invoke the main method of the class you specify. The JVM loads the class specified by Class-Name and uses that class name to invoke method main. You can specify an optional list of Strings (separated by spaces) as command-line arguments that the JVM will pass to your application.
When a method is called, the program makes a copy of the method’s argument values and assigns them to the method’s corresponding parameters, which are created and initialized when the method is called. When program control returns to the point in the program where the method was called, the method’s parameters are removed from memory.
A method can return at most one value, but the returned value could be a reference to an object that contains many values.
Variables should be declared as fields of a class only if they are required for use in more than one method of the class or if the program should save their values between calls to the class’s methods.
Example method with multiple parameters, call – double result = maximum(number1, number2, number3):
public double maximum(double x, double y, double z)
{
double maximumValue = x
if (y>maximumValue)
maximumValue = y;
if (z>maximumValue)
maximumValue = z;
return maximumValue;
}
There are three ways to call a method – using a method name by itself to call another method of the same class; using a variable that contains a reference to an object, followed by a dot (.) and the method name to call a method of the referenced object; and using the class name and a dot (.) to call a static method of a class.
Every primitive value and object in Java has a String representation. When an object is concatenated with a String, the object is converted to a String, then the two Strings are concatenated.
For primitive values used in string concatenation, the JVM handles the conversion of the primitive values to Strings. If a Boolean is concatenated with a String, the word “true” or the word “false” is used to represent the Boolean value. If there are any trailing zeros in a floating-point value, these will be discarded when the number is concatenated to a String.
All objects in Java have a special method named toString that returns a String representation of the object’s toString method to obtain the string representation of the object.
Stacks are known as last-in, first-out(LIFO) data structures – the last item pushed (inserted) on the stack is the first item popped (removed) from the stack.
Argument promotion: converting an argument’s value to the type that the method expects to receive in its corresponding parameter.
Promotion Rules:

Type	Valid Promotions
double	none
float	double
long	float or double
int	long, float or double
char	int, long, float, or double
short	int, long, float, or double, but not char
byte	short, int, long, float, or double, but not char
Boolean	None (Boolean values are not considered to be numbers in Java)

Java API Packages

Package	Description
java.applet	The Java Applet Package contains a class and several interfaces required to create Java applets – programs that execute in Web browsers.
java.awt	The Java Abstract Windows Toolkit Package contains the classes and interfaces required to create and manipulate GUIs in Java. In current versions of Java, the Swing GUI components of the javax.swing packages are often used instead.
java.awt.event	The Java Abstract Windows Toolkit Event Package contains classes and interfaces that enable event handling for GUI components in both the java.awt and javax.swing packages.
java.io	The Java Input/Output Package contains classes and interfaces that enable programs to input and output data.
java.lang	The Java Language Package contains classes and interfaces that are required by many Java programs. This package is imported by the compiler into all programs, so you do not need to do so.
java.net	The Java Networking package contains classes and interfaces that enable programs to communicate via computer networks like the Internet.
java.text	The Java Text Package contains classes and interfaces that enable programs to manipulate numbers, dates, characters and strings. The package provides internationalization capabilities that enable a program to be customized to a specific local.
java.util	The Java Utilities Package contains utility classes and interfaces that enable such actions as date and time manipulations, random-number processing (class Random), the storing and processing of large amounts of data and the breaking of strings into smaller pieces called tokens (class StringTokenizer).
javax.swing	The Java Swing GUI Components Package contains classes and interfaces for Java’s Swing GUI components that provide support for portable GUIs.
javax.swing.event	The Java Swing Event Package contains classes and interfaces that enable event handling (e.g. responding to button clicks) for GUI components in package javax.swing.

Objects of class Random (package java.util) can produce random int, long, float or double values. Math method random can produce double values in the range 0.0 <= x < 1.0, where x is the value returned by method random.
Random numbers in a range can be generated with
number = shiftingValue + randomNumbers.nextInt( scalingFactor);
where shiftingValue specifies the first number in the desired range of consecutive integers, and scalingFactor specifies how many numbers are in the range.
Random numbers can be chosen from nonconsecutive integer ranges, as in
number = shiftingValue + differenceBetweenValues * randomNumbers.nextInt( scalingFactor );
where shiftingValue specifies the first number in the range of values, differenceBetweenValues represents the difference between consecutive numbers in the sequence and scalingFactor specifies how many numbers are in the range.
An enumeration is introduced by the keyword enum and a type name. As with any class, braces ({ and }) delimit the body of an enum declaration. Inside the braces is a comma-seperated list of enumeration constants, each representing a unique value. The identifiers in an enum must be unique. Variables of an enum type can be assigned only constants of that enum type.
Constants can also be declared as public final static variables. Such constants are declared with all capital letters by convention to make them stand out in the program.
A method is invoked with a method call.
The program execution stack contains the memory for local variables on each invocation of a method during a program’s execution. This data, stored as a portion of the program stack, is known as the activation record or stack frame of the method call.
Method hypotenuse, which takes two double-precision, floating-point arguments side1 and side1 and returns a double-precision, floating-point result: double hypotenuse( double side1, double side2 )
Method instructions, which does not take any arguments and does not return a value: void instructions()