Transcript D.3 static Methods, static Fields and Class Math

1
expanded by J. Goetz, 2016
Credits:  2092-2016 Pearson Education, Inc. All rights reserved.
Jozef Goetz 2016
1
Jozef Goetz 2016
2
Jozef Goetz 2016
3
D.1 Introduction
 Topics in this appendix





static methods
Declare a method with more than one parameter
Method-call stack
Simulation techniques with random-number generation.
How to declare values that cannot change (i.e., constants) in
your programs.
 Method overloading.
Jozef Goetz 2016
4
D.2 Program Modules in Java
 Java programs combine new methods and classes
that you write with predefined methods and
classes available in the Java Application
Programming Interface and in other class
libraries.
 Related classes are typically grouped into
packages so that they can be imported into
programs and reused.
 You’ll learn how to group your own classes into packages in
Appendix F.
Jozef Goetz 2016
5
Jozef Goetz 2016
6
D.2 Program Modules in Java
 Methods help you modularize a program by separating its tasks into selfcontained units.
 Statements in method bodies
 Written only once
 Hidden from other methods
 Can be reused from several locations in a program
 Divide-and-conquer approach
 Constructing programs from small, simple pieces
 Software reusability
 Use existing methods as building blocks to create new pro-grams.
 Dividing a program into meaningful methods makes the program easier to
debug and maintain.
Jozef Goetz 2016
7
D.3 static Methods, static Fields and Class Math

Sometimes a method performs a task that does not depend on the contents of
any object.





Applies to the class in which it’s declared as a whole
Known as a static method or a class method
It’s common for classes to contain convenient static methods to perform
common tasks.
To declare a method as static, place the keyword static before the return
type in the method’s declaration.
Calling a static method
 ClassName.methodName( arguments )


Class Math provides a collection of static methods that enable you to perform
common mathematical calculations.
Method arguments may be constants, variables or expressions.
Jozef Goetz 2016
8
Jozef Goetz 2016
9
Jozef Goetz 2016
10
Jozef Goetz 2016
11
D.3 static Methods, static Fields and Class Math
 Math fields for common mathematical constants
 Math.PI (3.141592653589793)
 Math.E (2.718281828459045)
 Declared in class Math with the modifiers
public, final and static
 public allows you to use these fields in your own classes.
 A field declared with keyword final is constant—its value
cannot change after the field is initialized.
 PI and E are declared final because their values never
change.
Jozef Goetz 2016
12
D.3 static Methods, static Fields and Class Math
 A field that represents an attribute is also known
as an instance variable—each object (instance) of
the class has a separate instance of the variable in
memory.
 Fields for which each object of a class does not
have a separate instance of the field are declared
static and are also known as class variables.
 All objects of a class containing static fields
share one copy of those fields.
 Together the class variables (i.e., static
variables) and instance variables represent the
fields of a class.
Jozef Goetz 2016
13
D.3 static Methods, static Fields and Class Math
 Why is method main declared static?
 The JVM attempts to invoke the main method of the class
you specify—when no objects of the class have been
created.
 Declaring main as static allows the JVM to invoke main
without creating an instance of the class.
Jozef Goetz 2016
14
D.4 Declaring Methods with Multiple Parameters
 Multiple parameters are specified as a commaseparated list.
 There must be one argument in the method call
for each parameter in the method declaration.
 Each argument must be consistent with the type
of the corresponding parameter.
Jozef Goetz 2016
15
Jozef Goetz 2016
16
Jozef Goetz 2016
17
D.4 Declaring Methods with Multiple Parameters
 Implementing method maximum by reusing
method Math.max
 Two calls to Math.max, as follows:
 return Math.max( x, Math.max( y, z ) );
 The first specifies arguments x and Math.max( y, z ).
 Before any method can be called, its arguments must be
evaluated to determine their values.
 If an argument is a method call, the method call must be
performed to determine its return value.
 The result of the first call is passed as the second argument
to the other call, which returns the larger of its two
arguments.
Jozef Goetz 2016
18
D.4 Declaring Methods with Multiple Parameters
 String concatenation
 Assemble String objects into larger strings with operators + or +=.
 When both operands of operator + are Strings, operator + creates a
new String object
 characters of the right operand are placed at the end of those in the left
operand
 Every primitive value and object in Java has a String representation.
 When one of the + operator’s operands is a String, the other is
converted to a String, then the two are concatenated.
 If a boolean is concatenated with a String, the boolean is
converted to the String "true" or "false".
 All objects have a toString method that returns a String
representation of the object.
Jozef Goetz 2016
19
Jozef Goetz 2016
20
D.5 Notes on Declaring and Using Methods
 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
 Using the class name and a dot (.) to call a static method
of a class
Jozef Goetz 2016
21
D.5 Notes on Declaring and Using Methods
 A non-static method can call any method of
the same class directly and can manipulate any of
the class’s fields directly.
 A static method can call only other static
methods of the same class directly and can
manipulate only static fields in the same class
directly.
 To access the class’s non-static members, a static
method must use a reference to an object of the class.
Jozef Goetz 2016
22
D.5 Notes on Declaring and Using Methods
 Three ways to return control to the statement
that calls a method:
 When the program flow reaches the method-ending right
brace
 When the following statement executes
return;
 When the method returns a result with a statement like
return expression;
Jozef Goetz 2016
23
D.6 Method-Call Stack and Activation Records
 Stack data structure
 Analogous to a pile of dishes
 A dish is placed on the pile at the top (referred to as
pushing the dish onto the stack).
 A dish is removed from the pile from the top (referred to as
popping the dish off the stack).
 Last-in, first-out (LIFO) data structures
 The last item pushed (inserted) on the stack is the first item
popped (removed) from the stack.
Jozef Goetz 2016
24
D.6 Method-Call Stack and Activation Records
 When a program calls a method, the called
method must know how to return to its caller
 The return address of the calling method is pushed onto the
program-execution (or method-call) stack.
 If a series of method calls occurs, the successive
return addresses are pushed onto the stack in
last-in, first-out order.
 The program-execution stack also contains the
memory for the local variables used in each
invocation of a method during a program’s
execution.
 Stored as a portion of the program-execution stack known
as the activation record or stack frame of the method call.
Jozef Goetz 2016
25
D.6 Method-Call Stack and Activation Records
 When a method call is made, the activation
record for that method call is pushed onto the
program-execution stack.
 When the method returns to its caller, the
method’s activation record is popped off the
stack and those local variables are no longer
known to the program.
 If more method calls occur than can have their
activation records stored on the programexecution stack, an error known as a stack
overflow occurs.
Jozef Goetz 2016
26
D.7 Argument Promotion and Casting
 Argument promotion
 Converting an argument’s value, if possible, to the type that the method expects to
receive in its corresponding parameter.
 Conversions may lead to compilation errors if Java’s promotion rules are
not satisfied.
 Promotion rules
 specify which conversions are allowed.
 apply to expressions containing values of two or more primitive types and to
primitive-type values passed as arguments to methods.
 Each value is promoted to the “highest” type in the expression.
 Figure D.3 lists the primitive types and the types to which each can be
promoted.
Jozef Goetz 2016
27
Jozef Goetz 2016
28
D.7 Argument Promotion and Casting
 Converting values to types lower in the table of
Fig. D.3 will result in different values if the lower
type cannot represent the value of the higher
type
 In cases where information may be lost due to
conversion, the Java compiler requires you to use
a cast operator to explicitly force the conversion
to occur—otherwise a compilation error occurs.
Jozef Goetz 2016
29
D.8 Java API Packages
 Java contains many predefined classes that are
grouped into categories of related classes called
packages.
 A great strength of Java is the Java API’s
thousands of classes.
 Some key Java API packages used in this book are
described in Fig. D.4.
 Many other packages in are also available for
download at java.sun.com.
 Java API documentation
 download.oracle.com/javase/6/docs/api/
Jozef Goetz 2016
30
Jozef Goetz 2016
31
D.9 Introduction to Random-Number Generation
 Simulation and game playing
 element of chance
 Class Random (package java.util)
 static method random of class Math.
 A Random object can produce random boolean,
byte, float, double, int, long and Gaussian
values
 Math method random can produce only double
values in the range 0.0  x < 1.0.
 Documentation for class Random
 download.oracle.com/javase/6/docs/api/java/
util/Random.html
Jozef Goetz 2016
32
D.9 Case Study: Random-Number Generation
 Class Random produces pseudorandom numbers
 A sequence of values produced by a complex mathematical
calculation.
 The calculation uses the current time of day to seed the
random-number generator.
 The range of values produced directly by Random
method nextInt often differs from the range of
values required in a particular Java application.
 Random method nextInt that receives an int
argument returns a value from 0 up to, but not
including, the argument’s value.
Jozef Goetz 2016
33
D.9.1 Scaling and Shifting of Random Numbers
 Rolling a Six-Sided Die
 face = 1 + randomNumbers.nextInt( 6 );
 The argument 6—called the scaling factor—represents the
number of unique values that nextInt should produce (0–5)
 This is called scaling the range of values
 A six-sided die has the numbers 1–6 on its faces, not 0–5.
 We shift the range of numbers produced by adding a shifting
value—in this case 1—to our previous result, as in
 The shifting value (1) specifies the first value in the desired
range of random integers.
Jozef Goetz 2016
34
D.9.1 Scaling and Shifting of Random Numbers
 Generalize the scaling and shifting of random numbers:
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.
 It’s also possible to choose integers at random from sets of
values other than ranges of consecutive integers:
number = shiftingValue + differenceBetweenValues *
randomNumbers.nextInt( scalingFactor );
where shiftingValue specifies the first number in the desired
range of values, differenceBetweenValues represents the
constant difference between consecutive numbers in the
sequence and scalingFactor specifies how many numbers are in
the range.
Jozef Goetz 2016
35
D.9.2 Random-Number Repeatability for Testing and Debugging
 When debugging an application, it’s sometimes
useful to repeat the exact same sequence of
pseudorandom numbers.
 To do so, create a Random object as follows:
 Random randomNumbers =
new Random( seedValue );
 seedValue (of type long) seeds the random-number
calculation.
 You can set a Random object’s seed at any time
during program execution by calling the object’s
set method.
Jozef Goetz 2016
36
Jozef Goetz 2016
37
D.10 Case Study: A Game of Chance; Introducing Enumerations
 Basic rules for the dice game Craps:
 You roll two dice. Each die has six faces, which contain one,
two, three, four, five and six spots, respectively.
 After the dice have come to rest, the sum of the spots on the
two upward faces is calculated.
 If the sum is 7 or 11 on the first throw, you win. If the sum is
2, 3 or 12 on the first throw (called “craps”), you lose (i.e.,
the “house” wins).
 If the sum is 4, 5, 6, 8, 9 or 10 on the first throw, that sum
becomes your “point.”
 To win, you must continue rolling the dice until you “make
your point” (i.e., roll that same point value). You lose by
rolling a 7 before making your point.
Jozef Goetz 2016
38
Jozef Goetz 2016
39
Jozef Goetz 2016
40
D.10 Case Study: A Game of Chance; Introducing Enumerations
 Notes:
 myPoint is initialized to 0 to ensure that the application
will compile.
 If you do not initialize myPoint, the compiler issues an
error, because myPoint is not assigned a value in every
case of the switch statement, and thus the program
could try to use myPoint before it is assigned a value.
 gameStatus is assigned a value in every case of the
switch statement—thus, it’s guaranteed to be initialized
before it’s used and does not need to be initialized.
Jozef Goetz 2016
41
D.10 Case Study: A Game of Chance; Introducing Enumerations
 enum type Status
 An enumeration in its simplest form declares a set of
constants represented by identifiers.
 Special kind of class that is introduced by the keyword enum
and a type name.
 Braces delimit an enum declaration’s body.
 Inside the braces is a comma-separated 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 the
constants declared in the enumeration.
Jozef Goetz 2016
42
Jozef Goetz 2016
43
Jozef Goetz 2016
44
D.10 Case Study: A Game of Chance; Introducing Enumerations
 Why Some Constants Are Not Defined as enum
Constants
 Java does not allow an int to be compared to an
enumeration constant.
 Java does not provide an easy way to convert an int value
to a particular enum constant.
 Translating an int into an enum constant could be done
with a separate switch statement.
 This would be cumbersome and not improve the readability
of the program (thus defeating the purpose of using an
enum).
Jozef Goetz 2016
45
D.11 Scope of Declarations
 Declarations introduce names that can be used to
refer to such Java entities.
 The scope of a declaration is the portion of the
program that can refer to the declared entity by
its name.
 Such an entity is said to be “in scope” for that portion of the
program.
Jozef Goetz 2016
46
D.11 Scope of Declarations
 Basic scope rules:
 The scope of a parameter declaration is the body of the method in which the
declaration appears.
 The scope of a local-variable declaration is from the point at which the declaration
appears to the end of that block.
 The scope of a local-variable declaration that appears in the initialization section of
a for statement’s header is the body of the for statement and the other
expressions in the header.
 A method or field’s scope is the entire body of the class.
 Any block may contain variable declarations.
 If a local variable or parameter in a method has the same name as a field
of the class, the field is “hidden” until the block terminates execution—
this is called shadowing.
Jozef Goetz 2016
47
Jozef Goetz 2016
48
Jozef Goetz 2016
49
Jozef Goetz 2016
50
Jozef Goetz 2016
51
Jozef Goetz 2016
52
D.12 Method Overloading

Method overloading






Methods of the same name declared in the same class
Must have different sets of parameters
Compiler selects the appropriate method to call by examining the number, types
and order of the arguments in the call.
Used to create several methods with the same name that perform the same or
similar tasks, but on different types or different numbers of arguments.
Literal integer values are treated as type int, so the method call in line 9 invokes
the version of square that specifies an int parameter.
Literal floating-point values are treated as type double, so the method call in
line 10 invokes the version of square that specifies a double parameter.
Jozef Goetz 2016
53
Jozef Goetz 2016
54
Jozef Goetz 2016
55
Jozef Goetz 2016
56
D.12 Method Overloading
 Distinguishing Between Overloaded Methods
 The compiler distinguishes overloaded methods by their signatures—the methods’
names and the number, types and order of their parameters.
 Return types of overloaded methods
 Method calls cannot be distinguished by return type.
 Overloaded methods can have different return types if the methods have
different parameter lists.
 Overloaded methods need not have the same number of parameters.
Jozef Goetz 2016
57
Jozef Goetz 2016
58