defining your own classes part 3. class { } template for class definition import statements class...

Defining Your Own Classes

Part 3

class {

}

Template for Class Definition

Import StatementsImport Statements

Class CommentClass Comment

Class NameClass Name

Data MembersData Members

Methods(incl. Constructor)

Methods(incl. Constructor)

Data Member Declaration

<modifiers> <data type> <name> ;

private String ownerName ;

ModifiersModifiers Data TypeData Type NameName

Note: There’s only one modifier in this example.

Note: There’s only one modifier in this example.

Method Declaration

<modifier> <return type> <method name> ( <parameters> ){

<statements>

}

public void setOwnerName ( String name ) {

ownerName = name;

}

StatementsStatements

ModifierModifier Return TypeReturn Type Method NameMethod Name ParameterParameter

Constructor• A constructor is a special method that is executed when a new is executed when a new

instance of the class is created.instance of the class is created.

public <class name> ( <parameters> ){ <statements> }

public Bicycle ( ) {

ownerName = "Unassigned";

}StatementsStatements

ModifierModifier Class NameClass Name ParameterParameter

First Example: Using the Bicycle Class

class BicycleRegistration {

public static void main(String[] args) {

Bicycle bike1, bike2;

String owner1, owner2;

bike1 = new Bicycle( ); //Create and assign values to bike1

bike1.setOwnerName("Adam Smith");

bike2 = new Bicycle( ); //Create and assign values to bike2

bike2.setOwnerName("Ben Jones");

owner1 = bike1.getOwnerName( ); //Output the information

owner2 = bike2.getOwnerName( );

System.out.println(owner1 + " owns a bicycle.");

System.out.println(owner2 + " also owns a bicycle.");

}

}

The Definition of the Bicycle Class

class Bicycle {

// Data Member private String ownerName;

//Constructor: Initialzes the data memberpublic void Bicycle( ) {

ownerName = "Unknown";}

//Returns the name of this bicycle's owner public String getOwnerName( ) { return ownerName; }

//Assigns the name of this bicycle's owner public void setOwnerName(String name) { ownerName = name; } }

Multiple Instances

• Once the Bicycle class is defined, we can create multiple instances.

Bicycle bike1, bike2;

bike1 bike2

: Bicycle

ownerName

: Bicycle

ownerName

“Adam Smith” “Ben Jones”

bike1 = new Bicycle( ); bike1.setOwnerName("Adam Smith");

bike2 = new Bicycle( );

bike2.setOwnerName("Ben Jones");

Sample Code

The Program Structure and Source Files

BicycleRegistration Bicycle

There are two source files. Each class definition is stored in a separate file.

There are two source files. Each class definition is stored in a separate file.BicycleRegistration.java Bicycle.java

To run the program: 1. javac Bicycle.java (compile)

2. javac BicycleRegistration.java (compile)

3. java BicycleRegistration (run)

Class Diagram for Bicycle

Method ListingWe list the name and the data type of an argument passed to the method.

Method ListingWe list the name and the data type of an argument passed to the method.

Bicycle

+ setOwnerName(String)

+ Bicycle( )

+ getOwnerName( )

- String ownerName- String ownerName

public – plus symbol (+)private – minus symbol (-)

The Account Class

class Account {

private String ownerName; private double balance; public Account( ) {

ownerName = "Unassigned"; balance = 0.0;

}

public void add(double amt) { balance = balance + amt; } public void deduct(double amt) { balance = balance - amt; } public double getCurrentBalance( ) { return balance; } public String getOwnerName( ) { return ownerName; }

public void setInitialBalance (double bal) { balance = bal; } public void setOwnerName (String name) { ownerName = name; } }

Page 1 Page 2

Second Example: Using Bicycle and Account

class SecondMain {

//This sample program uses both the Bicycle and Account classes

public static void main(String[] args) { Bicycle bike; Account acct; String myName = "Jon Java"; bike = new Bicycle( ); bike.setOwnerName(myName); acct = new Account( ); acct.setOwnerName(myName); acct.setInitialBalance(250.00); acct.add(25.00); acct.deduct(50); //Output some information System.out.println(bike.getOwnerName() + " owns a bicycle and"); System.out.println("has $ " + acct.getCurrentBalance() +

" left in the bank"); }}

The Program Structure for SecondMain

SecondMain

Bicycle

SecondMain.java Bicycle.java

To run the program: 1. javac Bicycle.java (compile) 2. javac Account.java (compile) 2. javac SecondMain.java (compile) 3. java SecondMain (run)

Account.java

Account

Note: You only need to compile the class once. Recompile only when you made changes in the code.

Note: You only need to compile the class once. Recompile only when you made changes in the code.

Arguments and Parameters

• An argument is a value we pass to a method

class Account {

. . .

public void add(double amt) {

balance = balance + amt; }

. . . }

class Sample {

public static void main(String[] arg) { Account acct = new Account(); . . . acct.add(400); . . . }

. . . }

argument

parameter

• A parameter is a placeholder in the called method to hold the value of the passed argument.

Matching Arguments and Parameters

• The number or arguments and the parameters must be the same

class Demo {

public void compute(int i, int j, double x) { . . . } }

Demo demo = new Demo( );

int i = 5; int k = 14;

demo.compute(i, k, 20);3 arguments

3 parameters

• The matched pair must be assignment-compatible (e.g. you cannot pass a double argument to a int parameter)

• Arguments and parameters are paired left to right

Passing Side

Receiving Side

Memory Allocation

• Separate memory space is allocated for the receiving method.

Passing Side

i 5

k 14

20

Receiving Side

i

j

x

5

14

20.0• Values of

arguments are passed into memory allocated for parameters.Literal constant

has no name

Information Hiding and Visibility Modifiers

• The modifiers public and private designate the accessibility of data members and methods.

• If a class component (data member or method) is declared private, client classes cannot access it.

• If a class component is declared public, client classes can access it.

• Internal details of a class are declared private and hidden from the clients. This is information hiding.

Accessibility Example

class Service { public int memberOne; private int memberTwo;

public void doOne() {

…

} private void doTwo() {

…

}

}

…

Service obj = new Service();

obj.memberOne = 10;

obj.memberTwo = 20;

obj.doOne();

obj.doTwo();

…

Client Service

Data Members Should Be privateData Members Should Be private

• Data members are the implementation details of the class, so they should be invisible to the clients. they should be invisible to the clients. Declare them Declare them privateprivate .

• Exception: Constants can (should) be declared public if they are meant to be used directly by the outside methods.

Guideline for Visibility Modifiers

• Guidelines in determining the visibility of data members and methods: – Declare the class and instance variables private.– Declare the class and instance methods private if they

are used only by the other methods in the same class. – Declare the class constants public if you want to make

their values directly readable by the client programs. If the class constants are used for internal purposes only, then declare them private.

Diagram Notation for Visibility

public – plus symbol (+)private – minus symbol (-)

Class Constants

• In Chapter 3, we introduced the use of constants. • We illustrate the use of constants in programmer-

defined service classes here.• Remember, the use of constants

– provides a meaningful description of what the values stand for. number = UNDEFINED; is more meaningful than number = -1;

– provides easier program maintenance. We only need to change the value in the constant declaration instead of locating all occurrences of the same value in the program code

A Sample Use of Constants

class Dice {

private static final int MAX_NUMBER = 6; private static final int MIN_NUMBER = 1; private static final int NO_NUMBER = 0; private int number; public Dice( ) { number = NO_NUMBER; } //Rolls the dice public void roll( ) { number = (int) (Math.floor((Math.random() * (MAX_NUMBER - MIN_NUMBER + 1)))) + MIN_NUMBER); } //Returns the number on this dice public int getNumber( ) { return number; } }

Local Variables

• Local variables are declared within a method declaration and used for temporary services, such as storing intermediate computation results.

public double convert(int num) {

double result;

result = Math.sqrt(num * num);

return result; }

local variable

Local, Parameter & Data Member

• An identifier appearing inside a method can be a local variable, a parameter, or a data member.

• The rules are– If there’s a matching local variable declaration or a

parameter, then the identifier refers to the local variable or the parameter.

– Otherwise, if there’s a matching data member declaration, then the identifier refers to the data member.

– Otherwise, it is an error because there’s no matching declaration.

Sample Matching

class MusicCD {

private String artist;private String title;private String id;

public MusicCD(String name1, String name2) {

String ident;

artist = name1;

title = name2;

ident = artist.substring(0,2) + "-" +

title.substring(0,9);

id = ident;}...

}

Calling Methods of the Same Class

• So far, we have been calling a method of another class (object).

• It is possible to call method of a class from another method of the same class.– in this case, we simply refer to a method without dot notation

Changing Any Class to a Main Class

• Any class can be set to be a main class.• All you have to do is to include the main method.

class Bicycle {

//definition of the class as shown before comes here

//The main method that shows a sample //use of the Bicycle class public static void main(String[] args) { Bicycle myBike;

myBike = new Bicycle( );

myBike.setOwnerName("Jon Java");

System.out.println(myBike.getOwnerName() + "owns a bicycle"); }}

2005 Pearson Education, Inc. All rights reserved.

29

Methods: A Deeper Look


30

Object-oriented approach to modular design

2005 Pearson Education, Inc. All rights reserved.31

Notes on Declaring and Using Methods

• Three ways to call a method:1. Use a method name by itself to call another method of the

same class

double result = maximum( number1, number2, number3 );

2- Use a variable containing a reference to an object, followed by a dot (.) and the method name to call a method of the referenced object

maximumFinder.determineMaximum();

3- Use the class name and a dot (.) to call a static method of a class

ClassName.methodName( arguments )

• static methods cannot call non-static methods of the same class directly


Notes on Declaring and Using Methods (Cont.)

• Three ways to return control to the calling statement:

– If method does not return a result: (void)• Program flow reaches the method-ending right brace } or

• Program executes the statement return;

– If method does return a result:• Program executes the statement return expression;

– expression is first evaluated and then its value is returned to the caller


Declaring Methods with Multiple Parameters

• Multiple parameters can be declared by specifying a comma-separated list.

– Arguments passed in a method call must be consistent with the numbernumber, typestypes and orderorder of the parameters

• Sometimes called formal parameters

class Demo {



int i = 5; int k = 14;

demo.compute(i, k, 20);


• The number or arguments and the parameters must be the same

class Demo {



int i = 5; int k = 14;

demo.compute(i, k, 20);3 arguments

3 parameters

• The matched pair must be assignment-compatible (e.g. you cannot pass a double argument to a int parameter)

• Arguments and parameters are paired left to right

Passing Side

Receiving Side


35

Outline

MaximumFinder.java

(1 of 2)

1 // MaximumFinder.java

2 // Programmer-declared method maximum.

3 import java.util.Scanner;

4

5 public class MaximumFinder

6 {

7 // obtain three floating-point values and locate the maximum value

8 public void determineMaximum()

9 {

10 // create Scanner for input from command window

11 Scanner input = new Scanner( System.in );

12

13 // obtain user input

14 System.out.print(

15 "Enter three floating-point values separated by spaces: " );

16 double number1 = input.nextDouble(); // read first double

17 double number2 = input.nextDouble(); // read second double

18 double number3 = input.nextDouble(); // read third double

19

20 // determine the maximum value

21 double result = maximum( number1, number2, number3 );

22

23 // display maximum value

24 System.out.println( "Maximum is: " + result );

25 } // end method determineMaximum

26

Prompt the user to enter and read three double values

Call method maximum

Display maximum value


36

Outline

MaximumFinder.java(2 of 2)

27 // returns the maximum of its three double parameters

28 public double maximum( double x, double y, double z )

29 {

30 double maximumValue = x; // assume x is the largest to start

31

32 // determine whether y is greater than maximumValue

33 if ( y > maximumValue )

34 maximumValue = y;

35

36 // determine whether z is greater than maximumValue

37 if ( z > maximumValue )

38 maximumValue = z;

39

40 return maximumValue;

41 } // end method maximum

42 } // end class MaximumFinder

Declare the maximum method

Compare y and maximumValue

Compare z and maximumValue

Return the maximum value


37

Outline

MaximumFinderTest.java

1 // MaximumFinderTest.java

2 // Application to test class MaximumFinder.

3

4 public class MaximumFinderTest

5 {

6 // application starting point

7 public static void main( String args[] )

8 {

9 MaximumFinder maximumFinder = new MaximumFinder();

10 maximumFinder.determineMaximum();

11 } // end main

12 } // end class MaximumFinderTest Enter three floating-point values separated by spaces: 9.35 2.74 5.1 Maximum is: 9.35 Enter three floating-point values separated by spaces: 5.8 12.45 8.32 Maximum is: 12.45 Enter three floating-point values separated by spaces: 6.46 4.12 10.54 Maximum is: 10.54

Create a MaximumFinder object

Call the determineMaximum method


Common Programming Error

Declaring method parameters of the same type as float x, y is a syntax error

instead of

float x, float y

-a type is required for each parameter in the parameter list.


Call-by-Value Parameter Passing

• When a method is called, – the value of the argument is passed to the matching

parameter, and

– separate memory space is allocated to store this value.

• This way of passing the value of arguments is called a pass-by-value or call-by-value scheme.

• Since separate memory space is allocated for each parameter during the execution of the method,

– the parameter is local to the method, and therefore

– changes made to the parameter will not affect the value of the corresponding argument.

Call-by-Value Example

class Tester {public void myMethod(int one, double two ) {

one = 25;two = 35.4;

}}

Tester tester;int x, y;tester = new Tester();x = 10;y = 20;tester.myMethod(x, y);System.out.println(x + " " + y);

produces

10 20

4th Ed Chapter 7 - 41

Memory Allocation for Parameters


Memory Allocation for Parameters (cont'd)


Passing Objects to a Method

• As we can pass int and double values, we can also pass an object to a method.

• When we pass an object, we are actually passing the reference (name) of an object

– it means a duplicate of an object is NOT created in the called method

Passing a Student Object

class LibraryCard { private Student owner; public void setOwner(Student st) {

owner = st; }}

LibraryCard card2;

card2 = new LibraryCard();

card2.setOwner(student);

Passing Side

Receiving Side

: LibraryCard

owner

borrowCnt

0

: Student

name

“Jon Java”

email

“[email protected]”

student

card2

st1

1

Argument is passed1

2

2 Value is assigned to thedata member

2

State of Memory


Sharing an Object

• We pass the same Student object to card1 and card2

• Since we are actually passing a reference to the same object, it results in owner of two LibraryCard objects pointing to the same Student object


Returning an Object from a Method

• As we can return a primitive data value from a method, we can return an object from a method also.

• We return an object from a method, we are actually returning a reference (or an address) of an object.

– This means we are not returning a copy of an object, but only the reference of this object


Object-Returning Method

• Here's a sample method that returns an object:

public Fraction simplify( ) {

Fraction simp;

int num = getNumberator();int denom = getDenominator();int gcd = gcd(num, denom);

simp = new Fraction(num/gcd, denom/gcd);

return simp;}

Return type indicates the class of an object we're returning from the method.

Return type indicates the class of an object we're returning from the method.

Return an instance of the Fraction class

Return an instance of the Fraction class

gcd method Return the Greatest Number Divisor

gcd method Return the Greatest Number Divisor

A Sample Call to simplify

f1 = new Fraction(24, 36);

f2 = f1.simplify();


int num = getNumerator(); int denom = getDenominator(); int gcd = gcd(num, denom); Fraction simp = new Fraction(num/gcd, denom/gcd); return simp;}

f1

: Fraction

numerator

denominator36

24

f2

simp

: Fraction

numerator

denominator3

2


A Sample Call to simplify (cont'd)


int num = getNumerator(); int denom = getDenominator(); int gcd = gcd(num, denom); Fraction simp = new Fraction(num/gcd, denom/gcd); return simp;}

f1 = new Fraction(24, 26);

: Fraction

numerator

denominator3

2

f2 = f1.simplify();

f1

: Fraction

numerator

denominator36

24

f2 simp

: Fraction

numerator

denominator3

2The value of simp, which is a reference, is returned and assigned to f2.

The value of simp, which is a reference, is returned and assigned to f2.


50

Common Programming Error Confusing the + operator used for string concatenation with the + operator used for addition can lead to strange results. Java evaluates the operands of an operator from left to right. For example, if integer variable yy has the value has the value 55, the expression "y + 2 = " + y + 2 results in the string "y + 2 = 52", not "y + 2 = 7", because first the value of y (5) is concatenated with the string "y + 2 = ", then the value 2 is concatenated with the new larger string "y + 2 = 5". The expression "y + 2 = " + (y + 2) produces the desired result "y + 2 = 7".


51


Omitting the return-value-type in a method declaration is a syntax error.

public maximum( double x, double y, double z ) double


52


Placing a semicolon after the right parenthesis enclosing the parameter list of a method declaration is a syntax error.

public double maximum( double x, double y, double z ) ;

{

public double maximum( double x, double y, double z )


53


Redeclaring a method parameter as a local variable in the method’s body is a compilation error.

public double maximum( double x, double y, double z )

{

double y;


54


Forgetting to return a value from a method that should return a value is a compilation error. If a return value type other than voidvoid is specified, the the method must containmethod must contain a returnreturn statement that returns a value consistent with the method’s return-value-type.

Returning a value from a method whose return type has been declared void is a compilation error.


Method Call Stack and Activation Records

• Stacks– Last-in, first-out (LIFO) data structures

• Items are pushed (inserted) onto the top

• Items are popped (removed) from the top

• Program execution stack– Also known as the method call stack

– Return addresses of calling methods are pushed onto this stack when they call other methods and popped off when control returns to them


Method Call Stack and Activation Records (Cont.)

– A method’s local variables are stored in a portion of this stack known as the method’s activation record or stack frame

• When the last variable referencing a certain object is popped off this stack, that object is no longer accessible by the program

– Will eventually be deleted from memory during “garbage collection”

• Stack overflow occurs when the stack cannot allocate enough space for a method’s activation record


Argument Promotion and Casting

• Argument promotion– Java will promote a method call argument to match its

corresponding method parameter according to the promotion rules

– Values in an expression are promoted to the “highest” type in the expression (a temporary copy of the value is made)

– Converting values to lower typesConverting values to lower types results in a compilation results in a compilation errorerror, unless the programmer explicitly forces the conversion to occur

• Place the desired data type in parentheses before the value

– example: ( int ) 4.5


58

Fig. 6.5 | Promotions allowed for primitive types.

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)


59


Converting a primitive-type value to another primitive type may change the value if the new type is not a valid promotion.


60

Java API packages (a subset). (Part 1 of 2)

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. (Applets are discussed in Chapter 20,

Introduction to Java Applets; interfaces are discussed in Chapter 10, Object_-Oriented

Programming: Polymorphism.)

java.awt The Java Abstract Window Toolkit Package contains the classes and interfaces required

to create and manipulate GUIs in Java 1.0 and 1.1. In current versions of Java, the Swing

GUI components of the javax.swing packages are often used instead. (Some elements

of the java.awt package are discussed in Chapter 11, GUI Components: Part 1,

Chapter 12, Graphics and Java2D, and Chapter 22, GUI Components: Part 2.)

java.awt.event The Java Abstract Window Toolkit Event Package contains classes and interfaces that

enable event handling for GUI components in both the java.awt and javax.swing

packages. (You will learn more about this package in Chapter 11, GUI Components: Part

1 and Chapter 22, GUI Components: Part 2.)

java.io The Java Input/Output Package contains classes and interfaces that enable programs to

input and output data. (You will learn more about this package in Chapter 14, Files and

Streams.)

java.lang The Java Language Package contains classes and interfaces (discussed throughout this

text) that are required by many Java programs. This package is imported by the compiler

into all programs, so the programmer does not need to do so.


61

Java API packages (a subset). (Part 2 of 2)

Package Description java.net The Java Networking Package contains classes and interfaces that enable programs to

communicate via computer networks like the Internet. (You will learn more about this in

Chapter 24, Networking.)

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 locale (e.g., a program may display strings

in different languages, based on the user’s country).

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). (You will learn more about the features of this package in Chapter 19,

Collections.)

javax.swing The Java Swing GUI Components Package contains classes and interfaces for Java’s Swing

GUI components that provide support for portable GUIs. (You will learn more about this

package in Chapter 11, GUI Components: Part 1 and Chapter 22, GUI Components: Part 2.)

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. (You will learn

more about this package in Chapter 11, GUI Components: Part 1 and Chapter 22, GUI

Components: Part 2.)


Scope of Declarations

• Basic scope rules– Scope of a parameter declaration is the body of the method

in which appears

– Scope of a local-variable declaration is from the point of declaration to the end of that block

– Scope of a local-variable declaration in the initialization section of a for header is the rest of the for header and the body of the for statement

– Scope of a method or field of a class is the entire body of the class


Scope of Declarations (Cont.)

• Shadowing– A data member is shadowed (or hidden) if a local variable

or parameter has the same name as the field• This lasts until the local variable or parameter goes out of

scope


64


A compilation error occurs when a local variable is declared more than once in a method.


65

Error-Prevention Tip

Use different names for data members and local variables to help prevent subtle logic errors that occur when a method is called and a local variable of the method shadows a field of the same name in the class.

2005 Pearson Education, Inc. All rights

reserved.

66

Outline

Scope.java

(1 of 2)

1 // Scope.java

2 // Scope class demonstrates field and local variable scopes.

3

4 public class Scope

5 {

6 // field that is accessible to all methods of this class

7 private int x = 1;

8

9 // method begin creates and initializes local variable x

10 // and calls methods useLocalVariable and useField

11 public void begin()

12 {

13 int x = 5; // method's local variable x shadows field x

14

15 System.out.printf( "local x in method begin is %d\n", x );

16

17 useLocalVariable(); // useLocalVariable has local x

18 useField(); // useField uses class Scope's field x

19 useLocalVariable(); // useLocalVariable reinitializes local x

20 useField(); // class Scope's field x retains its value 21

Shadows field x

Display value of local variable x


reserved.

67

Outline

Scope.java

(2 of 2)

22 System.out.printf( "\nlocal x in method begin is %d\n", x );

23 } // end method begin

24

25 // create and initialize local variable x during each call

26 public void useLocalVariable()

27 {

28 int x = 25; // initialized each time useLocalVariable is called

29

30 System.out.printf(

31 "\nlocal x on entering method useLocalVariable is %d\n", x );

32 ++x; // modifies this method's local variable x


34 "local x before exiting method useLocalVariable is %d\n", x );

35 } // end method useLocalVariable

36

37 // modify class Scope's field x during each call

38 public void useField()

39 {


41 "\nfield x on entering method useField is %d\n", x );

42 x *= 10; // modifies class Scope's field x


44 "field x before exiting method useField is %d\n", x );

45 } // end method useField

46 } // end class Scope

Shadows field x

Display value of local variable x

Display value of field x


reserved.

68

Outline

ScopeTest.java

1 // Fig. 6.12: ScopeTest.java

2 // Application to test class Scope.

3

4 public class ScopeTest

5 {

6 // application starting point


8 {

9 Scope testScope = new Scope();

10 testScope.begin();

11 } // end main

12 } // end class ScopeTest local x in method begin is 5 local x on entering method useLocalVariable is 25 local x before exiting method useLocalVariable is 26 field x on entering method useField is 1 field x before exiting method useField is 10 local x on entering method useLocalVariable is 25 local x before exiting method useLocalVariable is 26 field x on entering method useField is 10 field x before exiting method useField is 100 local x in method begin is 5


reserved.69

static Methods, static Fields and Class Math

• static method (or class method)

–Call a static method by using the method call:ClassName.methodName( arguments )–All methods of the Math class are static

•example: Math.sqrt( 900.0 )


reserved.70

Software Engineering Observation

Class Math is part of the java.lang package, which is implicitly imported by the compiler,

so it is not necessary to import class Math to use its methods.


reserved.71

static Methods, static Fields and Class Math (Cont.)

• Constants

–Keyword final–Cannot be changed after initialization •static fields (or class variables)

–Are fields where one copy of the variable is shared among all objects of the class•Math.PI and Math.E are final static fields of the Math class


reserved.72

Math class methods.

Method Description Example

abs( x ) absolute value of x abs( 23.7 ) is 23.7 abs( 0.0 ) is 0.0 abs( -23.7 ) is 23.7

ceil( x ) rounds x to the smallest integer not less than x

ceil( 9.2 ) is 10.0 ceil( -9.8 ) is -9.0

cos( x ) trigonometric cosine of x (x in radians) cos( 0.0 ) is 1.0

exp( x ) exponential method ex exp( 1.0 ) is 2.71828 exp( 2.0 ) is 7.38906

floor( x ) rounds x to the largest integer not greater than x

Floor( 9.2 ) is 9.0 floor( -9.8 ) is -10.0

log( x ) natural logarithm of x (base e) log( Math.E ) is 1.0 log( Math.E * Math.E ) is 2.0

max( x, y ) larger value of x and y max( 2.3, 12.7 ) is 12.7 max( -2.3, -12.7 ) is -2.3

min( x, y ) smaller value of x and y min( 2.3, 12.7 ) is 2.3 min( -2.3, -12.7 ) is -12.7

pow( x, y ) x raised to the power y (i.e., xy) pow( 2.0, 7.0 ) is 128.0 pow( 9.0, 0.5 ) is 3.0

sin( x ) trigonometric sine of x (x in radians) sin( 0.0 ) is 0.0

sqrt( x ) square root of x sqrt( 900.0 ) is 30.0

tan( x ) trigonometric tangent of x (x in radians) tan( 0.0 ) is 0.0


reserved.73

static Methods, static Fields and Class Math (Cont.)

• Method main

–main is declared static so it can be invoked without creating an object of the class containing main

–Any class can contain a main method

•The JVM invokes the main method belonging to the class specified by the first command-line argument to the java command


reserved.74

• Reusing method Math.max

–The expression Math.max(Math.max( x,x, Math.max(Math.max( y,y, zz )) )) determines the maximum of y and z, and then determines the maximum of x and that value

• String concatenation

–Using the + operator with two Strings concatenates them into a new String•Ex: ident = artist.substring(0,2) + "-" + title.substring(0,9);ident = artist.substring(0,2) + "-" + title.substring(0,9);

–Using the + operator with a String and a value of another data type concatenates the String with a String representation of the other value

•When the other value is an object, its toString method is called to generate its String representation


Method Overloading • Method overloading

– Multiple methods with the same name, but different types, number or order of parameters in their parameter lists

– Compiler decides which method is being called by matching the method call’s argument list to one of the overloaded methods’ parameter lists

• A method’s name and number, type and ordername and number, type and order of its parameters form its signaturesignature

– Differences in return type are irrelevant Differences in return type are irrelevant in method overloading• Overloaded methods can have different return types• Methods with different return types but the same signature cause

a compilation error


Overloaded Methods

• Methods can share the same name as long as

– they have a different number of parameters (Rule 1) or

– their parameters are of different data types when the number of parameters is the same (Rule 2)

public void myMethod(int x, int y) { ... }

public void myMethod(int x) { ... } Rule 1

public void myMethod(double x) { ... }

public void myMethod(int x) { ... }Rule 2


reserved.

77

Outline

MethodOverload.java

1 // Fig. 6.13: MethodOverload.java 2 // Overloaded method declarations. 3 4 public class MethodOverload 5 { 6 // test overloaded square methods 7 public void testOverloadedMethods() 8 { 9 System.out.printf( "Square of integer 7 is %d\n", square( 7 ) ); 10 System.out.printf( "Square of double 7.5 is %f\n", square( 7.5 ) ); 11 } // end method testOverloadedMethods 12 13 // square method with int argument 14 public int square( int intValue ) 15 { 16 System.out.printf( "\nCalled square with int argument: %d\n", 17 intValue ); 18 return intValue * intValue; 19 } // end method square with int argument 20 21

Label1// square method with double argument

22 public double square( double doubleValue ) 23 { 24 System.out.printf( "\nCalled square with double argument: %f\n", 25 doubleValue ); 26 return doubleValue * doubleValue; 27 } // end method square with double argument 28 } // end class MethodOverload

Correctly calls the “square of int” method

Correctly calls the “square of double” method

Declaring the “square of int” method

Declaring the “square of double” method


reserved.

78

Outline

MethodOverloadTest.java

1 // Fig. 6.14: MethodOverloadTest.java

2 // Application to test class MethodOverload.

3

4 public class MethodOverloadTest

5 {


7 {

8 MethodOverload methodOverload = new MethodOverload();

9 methodOverload.testOverloadedMethods();

10 } // end main

11 } // end class MethodOverloadTest Called square with int argument: 7 Square of integer 7 is 49 Called square with double argument: 7.500000 Square of double 7.5 is 56.250000


reserved.

79

Outline

MethodOverload

Error.java

1 // Fig. 6.15: MethodOverloadError.java

2 // Overloaded methods with identical signatures

3 // cause compilation errors, even if return types are different.

4

5 public class MethodOverloadError

6 {

7 // declaration of method square with int argument

8 public int square( int x )

9 {

10 return x * x;

11 }

12

13 // second declaration of method square with int argument

14 // causes compilation error even though return types are different

15 public double square( int y )

16 {

17 return y * y;

18 }

19 } // end class MethodOverloadError MethodOverloadError.java:15: square(int) is already defined in MethodOverloadError public double square( int y ) ^ 1 error

ERROR:

Same method signature

Compilation error


80


Declaring overloaded methods with identical parameter lists is a compilation error regardless of whether the return types are different.


Boolean Variables

• The result of a boolean expression is either true or false. These are the two values of data type boolean.

• We can declare a variable of data type boolean and assign a boolean value to it.

boolean pass, done;pass = 70 < x;done = true;if (pass) {

…} else {

…}

2005 Pearson Education, Inc. All rights reserved.4th Ed Chapter 5 - 82

Boolean Methods• A method that returns a boolean value, such as

private boolean isValid(int value) {if (value < MAX_ALLOWED)

return true;} else {

return false;}

}

Can be used asif (isValid(30)) {

…} else {

…}

2005 Pearson Education, Inc. All rights reserved.4th Ed Chapter 5 - 83

Comparing Objects

• With primitive data types, we have only one way to compare them, but with objects (reference data type), we have two ways to compare them.

1. We can test whether two variables point to the same object (use ==), or

2. We can test whether two distinct objects have the same contents.


Using == With Objects (Sample 1)

String str1 = new String("Java");String str2 = new String("Java");

if (str1 == str2) {System.out.println("They are equal");

} else {System.out.println("They are not equal");

}

They are not equal

Not equal because str1 and str2 point to different String objects.


Using == With Objects (Sample 2)

String str1 = new String("Java");String str2 = str1;

if (str1 == str2) {System.out.println("They are equal");


}

They are equal It's equal here because str1 and str2 point to the same object.


Using equals with String

String str1 = new String("Java");String str2 = new String("Java");

if (str1.equals(str2)) {System.out.println("They are equal");


}

They are equal It's equal here because str1 and str2 have the same sequence of characters.


The Semantics of ==


In Creating String Objects


89

Initializing Objects with Constructors

• Constructors–Initialize an object of a class

–Java requires a constructor for every class

–Java will provide a default no-argument constructor if none is provided

–Called when keyword new is followed by the class name and parentheses

90

Outline

•GradeBook.java•(1 of 2)

1 // GradeBook.java

2 // GradeBook class with a constructor to initialize the course name.

3

4 public class GradeBook

5 {

6 private String courseName; // course name for this GradeBook

7

8 // constructor initializes courseName with String supplied as argument

9 public GradeBook( String name )

10 {

11 courseName = name; // initializes courseName

12 } // end constructor

13

14 // method to set the course name

15 public void setCourseName( String name )

16 {

17 courseName = name; // store the course name

18 } // end method setCourseName

19

20 // method to retrieve the course name

21 public String getCourseName()

22 {

23 return courseName;

24 } // end method getCourseName

Constructor to initialize courseName variable

91

Outline

•GradeBook.java•(2 of 2)

25

26 // display a welcome message to the GradeBook user

27 public void displayMessage()

28 {

29 // this statement calls getCourseName to get the

30 // name of the course this GradeBook represents

31 System.out.printf( "Welcome to the grade book for\n%s!\n",

32 getCourseName() );

33 } // end method displayMessage

34

35 } // end class GradeBook

92

Outline

•GradeBookTest.java

1 // GradeBookTest.java

2 // GradeBook constructor used to specify the course name at the

3 // time each GradeBook object is created.

4

5 public class GradeBookTest

6 {

7 // main method begins program execution


9 {

10 // create GradeBook object

11 GradeBook gradeBook1 = new GradeBook(

12 "CS111 Introduction to Java Programming" );

13 GradeBook gradeBook2 = new GradeBook(

14 "CSC222 Computer Organization and Assembly Language" );

15

16 // display initial value of courseName for each GradeBook

17 System.out.printf( "gradeBook1 course name is: %s\n",

18 gradeBook1.getCourseName() );

19 System.out.printf( "gradeBook2 course name is: %s\n",

20 gradeBook2.getCourseName() );

21 } // end main

22

23 } // end class GradeBookTest

gradeBook1 course name is: CSC111 Introduction to Java Programming gradeBook2 course name is: CSC222 Computer Organization and assembly Language

Call constructor to create first grade

book object

Create second grade book object

93

Outline

•Account.java

1 // Account.java

2 // Account class with a constructor to

3 // initialize instance variable balance.

4

5 public class Account

6 {

7 private double balance; // instance variable that stores the balance

8

9 // constructor

10 public Account( double initialBalance )

11 {

12 // validate that initialBalance is greater than 0.0;

13 // if it is not, balance is initialized to the default value 0.0

14 if ( initialBalance > 0.0 )

15 balance = initialBalance;

16 } // end Account constructor

17

18 // credit (add) an amount to the account

19 public void credit( double amount )

20 {

21 balance = balance + amount; // add amount to balance

22 } // end method credit

23

24 // return the account balance

25 public double getBalance()

26 {

27 return balance; // gives the value of balance to the calling method

28 } // end method getBalance

29

30 } // end class Account

double variable balance

94

Outline

•AccountTest.java•(1 of 3)

1 // AccountTest.java

2 // Create and manipulate an Account object.

3 import java.util.Scanner;

4

5 public class AccountTest

6 {

7 // main method begins execution of Java application


9 {

10 Account account1 = new Account( 50.00 ); // create Account object

11 Account account2 = new Account( -7.53 ); // create Account object

12

13 // display initial balance of each object

14 System.out.printf( "account1 balance: $%.2f\n",

15 account1.getBalance() );

16 System.out.printf( "account2 balance: $%.2f\n\n",


18

95

Outline

•AccountTest.java

19 // create Scanner to obtain input from command window

20 Scanner input = new Scanner( System.in );

21 double depositAmount; // deposit amount read from user

22

23 System.out.print( "Enter deposit amount for account1: " ); // prompt

24 depositAmount = input.nextDouble(); // obtain user input

25 System.out.printf( "\nadding %.2f to account1 balance\n\n",

26 depositAmount );

27 account1.credit( depositAmount ); // add to account1 balance

28

29 // display balances



32 System.out.printf( "account2 balance: $%.2f\n\n",


34

35 System.out.print( "Enter deposit amount for account2: " ); // prompt

36 depositAmount = input.nextDouble(); // obtain user input

37 System.out.printf( "\nadding %.2f to account2 balance\n\n",

38 depositAmount );

39 account2.credit( depositAmount ); // add to account2 balance

40


Input a double value

Input a double value

96Outline

•AccountTest.java

41 // display balances





46 } // end main

47

48 } // end class AccountTest account1 balance: $50.00 account2 balance: $0.00 Enter deposit amount for account1: 25.53 adding 25.53 to account1 balance account1 balance: $75.53 account2 balance: $0.00 Enter deposit amount for account2: 123.45 adding 123.45 to account2 balance account1 balance: $75.53 account2 balance: $123.45


Output a double value

Lines 14 - 17

Lines 23 - 25

Lines 30 - 33

Lines 35 - 38

Lines 42 - 45


97

UML class diagram indicating that class Account has a private balance attribute of UML type Double, a constructor (with a parameter of UML type Double) and two public operations—credit (with an amount parameter of UML type Double) and getBalance (returns UML type Double).

defining your own classes part 3. class { } template for class definition import statements class...

Documents

public bicycle

bicycle method

new bicycle bike1

new bicycle bike2

account class class

return ownername

class diagram

constructor slide