java introduction chapter 1 overview 1. 2 chapter objectives examine how a java program is processed...

Java Introduction

Chapter 1Overview

Chapter Objectives

• Examine how a Java program is processed• Learn what an algorithm is and explore

problem-solving techniques• Become aware of structured and object-

oriented programming design methodologies

Evolution of Programming Languages

• High-level languages make programming easier

• Closer to spoken languages• Examples

– Basic – FORTRAN– COBOL– C/C++– Java

Evolution of Programming Languages (continued)

• To run a Java program:1. Java instructions need to be translated into an

intermediate language called bytecode

2. Then the bytecode is interpreted into a particular machine language

Evolution of Programming Languages (continued)

• Compiler: a program that translates a program written in a high-level language into the equivalent machine language

– In the case of Java, this machine language is the bytecode

• Java Virtual Machine (JVM): hypothetical computer developed to make Java programs machine independent

A Java Program

Output:

Processing a Java Program

• Two types of Java programs: applications and applets

• Source program: written in a high-level language• Loader: transfers the compiled code (bytecode)

into main memory• Interpreter: reads and translates each bytecode

instruction into machine language and then executes it

Processing a Java Program (continued)

Figure 1-3

Programming Methodologies

• Two basic approaches to programming design– Structured design – Object-oriented design

Structured Design

1. A problem is divided into smaller subproblems

2. Each subproblem is solved

3. The solutions of all subproblems are then combined to solve the problem

Object-Oriented Design (OOD)

• In OOD, a program is a collection of interacting objects

• An object consists of data and operations

• Steps in OOD1. Identify objects

2. Form the basis of the solution

3. Determine how these objects interact

Java Introduction

Chapter 2Basic Elements of Java

Chapter Objectives

• Become familiar with the basic components of a Java program, including methods, special symbols, and identifiers

• Explore primitive data types• Discover how to use arithmetic operators• Examine how a program evaluates arithmetic

expressions• Explore how mixed expressions are evaluated

Chapter Objectives (continued)

• Learn about type casting• Become familiar with the String type• Learn what an assignment statement is and what it

does• Discover how to input data into memory by using

input statements• Become familiar with the use of increment and

decrement operators

• Examine ways to output results using output statements

• Learn how to import packages and why they are necessary

• Discover how to create a Java application program• Explore how to properly structure a program,

including using comments to document a program

Introduction

• Computer program: a sequence of statements whose objective is to accomplish a task

• Programming: process of planning and creating a program

A Java Program

Sample Run:

18Java Introduction

The Basics of a Java Program

• Java program: collection of classes

• There is a main method in every Java application program

• Token: smallest individual unit of a program

Special Symbols

Reserved Words (Keywords)

• int• float• double• char

• void• public• static• throws • return

Java Identifiers

• Names of things

• Consist of: – Letters– Digits– The underscore character (_)– The dollar sign ($)

• Must begin with a letter, underscore, or the dollar sign

Illegal Identifiers

Data Types

• Data type: set of values together with a set of operations

Primitive Data Types

• Integral, which is a data type that deals with integers, or numbers without a decimal part (and characters)

• Floating-point, which is a data type that deals with decimal numbers

• Boolean, which is a data type that deals with logical values

Integral Data Types

•char•byte •short •int•long

Values and Memory Allocation for Integral Data Types

Primitive Data Types

• Floating-point data types– float: precision = 6 or 7– double: precision = 15

• boolean: two values– true– false

28Java Introduction

Literals (Constants)

• Integer literals, integer constants, or integers: 23 and -67

• Floating-point literals, floating-point constants, floating-point numbers: 12.34 and 25.60

• Character literals, character constants, or characters: 'a' and '5'

Arithmetic Operators and Operator Precedence

• Five arithmetic operators– + addition– - subtraction– * multiplication– / division– % mod (modulus)

• Unary operator: operator that has one operand• Binary operator: operator that has two operands

Order of Precedence

1. * / % (same precedence)

2. + - (same precedence)

• Operators in 1 have a higher precedence than operators in 2

• When operators have the same level of precedence, operations are performed from left to right

Expressions

• Integral expressions

• Floating-point or decimal expressions

• Mixed expressions

Integral Expressions

• All operands are integers

• Examples2 + 3 * 5

3 + x – y / 7

x + 2 * (y – z) + 18

Floating-Point Expressions

• All operands are floating-point numbers

• Examples

12.8 * 17.5 – 34.50

x * 10.5 + y - 16.2

Mixed Expressions

• Operands of different types• Examples2 + 3.56 / 4 + 3.9

• Integer operands yield an integer result; floating-point numbers yield floating-point results

• If both types of operands are present, the result is a floating-point number

• Precedence rules are followed

Type Conversion (Casting)

• Used to avoid implicit type coercion

• Syntax

(dataTypeName) expression• Expression evaluated first, then type

converted to dataTypeName• Examples

(int)(7.9 + 6.7) = 14

(int)(7.9) + (int)(6.7) = 13

The class String

• Used to manipulate strings• String

– Sequence of zero or more characters– Enclosed in double quotation marks– Null or empty strings have no characters– Numeric strings consist of integers or decimal

numbers– Length is the number of characters in a string

Strings and the Operator +• Operator + can be used to concatenate

two strings or a string and a numeric value or character

• Example"The sum = " + 12 + 26

-After this statement executes, the string assigned to str is:"The sum = 1226";

Strings and the Operator + (continued)

• Consider the following statement:"The sum = " + (12 + 26)

• In this statement, because of the parentheses, you first evaluate num1 + num2– Because num1 and num2 are both int

variables, num1 + num2 = 12 + 26 = 38

– After this statement executes, the string assigned to str is:

"The sum = 38";

Example2_1

// This program illustrates how the String concatenation works.

public class Example2_1

public static void main(String[] args)

System.out.println("The sum = " + 12 + 26);

System.out.println("The sum = " + (12 + 26));

System.out.println(12 + 26 + " is the sum");

System.out.println("The sum of " + 12 + " and " + 26

+ " = " + (12 + 26));

Input• Named constant

– Cannot be changed during program execution– Declared by using the reserved word final– Initialized when it is declared

• Example final double CENTIMETERS_PER_INCH = 2.54;

final int NO_OF_STUDENTS = 20;

final char BLANK = ' ';

final double PAY_RATE = 15.75;

Input (continued)• Variable (name, value, data type, size)

– Content may change during program execution– Must be declared before it can be used– May not be automatically initialized – If new value is assigned, old one is destroyed– Value can only be changed by an assignment

statement or an input (read) statement• Example double amountDue;int counter;char ch;int num1, num2;

Input (continued)• The assignment statement

variable = expression;

• Example int num1;int num2;double sale;char first;String str;

num1 = 4;num2 = 4 * 5 - 11;sale = 0.02 * 1000;first = 'D';str = "It is a sunny day.";

Example2_2

// This program illustrates how data in the variables are

// manipulated.

int num1;

int num2;

double sale;

char first;

String str;

num1 = 4;

System.out.println("num1 = " + num1);

Example2_2 num2 = 4 * 5 - 11;

System.out.println("num2 = " + num2);

sale = 0.02 * 1000;

System.out.println("sale = " + sale);

first = 'D';

System.out.println("first = " + first);

str = "It is a sunny day.";

System.out.println("str = " + str);

45Java Introduction

Input (continued)

• Example1. num1 = 18;

2. num1 = num1 + 27;

3. num2 = num1;

4. num3 = num2 / 5;

5. num3 = num3 / 4;

46Java Introduction

Input (continued)

47Java Introduction

Input (continued)

• Standard input stream object: System.in• Input numeric data to program

– Separate by blanks, lines, or tabs

• To read data:1. Create an input stream object of the class

Scanner

2. Use the methods such as next, nextLine, nextInt, and nextDouble

Input (continued)static Scanner console = new Scanner(System.in);

• Example static Scanner console = new Scanner(System.in);

int feet;int inches;

Suppose the input is

feet = console.nextInt(); //Line 1inches = console.nextInt(); //Line 2

Example2_3// This program illustrates how input statements work.

import java.util.*;

static Scanner console = new Scanner(System.in);

int feet;

int inches;

System.out.println("Enter two integers separated by spaces.");

feet = console.nextInt();

inches = console.nextInt();

System.out.println("Feet = " + feet);

System.out.println("Inches = " + inches);

Increment and Decrement Operators

• ++ increments the value of its operand by 1• -- decrements the value of its operand by 1

• SyntaxPre-increment: ++variable

Post-increment: variable++

Pre-decrement: --variable

Post-decrement: variable--

Output

• Standard output object: System.out• Methods

printprintln

• SyntaxSystem.out.print(stringExp);System.out.println(stringExp);

System.out.println();

Commonly Used Escape Sequences

Packages, Classes, Methods, and the import Statement

• Package: collection of related classes

• Class: consists of methods

• Method: designed to accomplish a specific task

import Statement

• Used to import the components of a package into a program

• Reserved word• import java.io.*;

– Imports the (components of the) package java.io into the program

• Primitive data types and the class String– Part of the Java language– Don’t need to be imported

Creating a Java Application Program

• Syntax of a class

• Syntax of the main method

Debugging: Understanding and Fixing Syntax Errors

• When you type a program, typos and unintentional syntax errors are likely to occur

• Therefore, when you compile a program, the compiler will identify the syntax error

58Java Introduction 58

59Java Introduction

• The compiler produces the following errors:

ProgramNum.java:9: ';' expected

int num

ProgramNum.java:16: reached end of file while parsing

2 errors

65Java Introduction

Programming Style and Form

• Know common syntax errors and rules

• Use blanks appropriately

• Semicolon: statement terminator

• Important to have well-documented code

• Good practice to follow traditional rules for naming identifiers

66Java Introduction

Avoiding Bugs: Consistent, Proper Formatting and Code Walkthrough

• Java is a free-format language in the sense that programming instructions need not be typed in specific columns

• As you will discover, consistent and proper formatting will make it easier to develop, debug, and maintain programs

• Throughout the book, you will see consistent and predictable use of blanks, tabs, and newline characters to separate the elements of a program

• When you write programs, unintentional typos and errors are unavoidable

• The Java compiler will find the syntax rules and give some hints how to correct them; however, the compiler may not find logical (semantic) errors

67Java Introduction

Avoiding Bugs: Consistent, Proper Formatting and Code Walk-Through

(continued) • Typically, programmers try to find and fix these problems

themselves by walking carefully through their programs • Sometimes after multiple readings, a programmer may not be able

to find the bug because the programmer may overlook the piece of the code that contains the bug and therefore may seek outside help

• If your program is properly formatted and you have used good names for identifiers, the person reading your program will have an easier time reading and debugging the program

Avoiding Bugs: Consistent, Proper Formatting and Code Walk-Through

(continued)

• Before you seek outside help, you should be prepared to explain what your program intended to do and answer questions raised by the person reading your program

• The examination of your program by yourself, by another person, or a group of persons is a walk-through; a walk-through is helpful for all phases of the software development process

More on Assignment Statements

variable = variable * (expression);is equivalent to

variable *= expression;

Similarly,

variable = variable + (expression);is equivalent to

variable += expression;

Programming Examples

• Convert Length program– Input: length in feet and inches– Output: equivalent length in centimeters

• Make Change program– Input: change in cents– Output: equivalent change in half-dollars,

quarters, dimes, nickels, and pennies

Chapter Summary

• Basic elements of a Java program include:– The main method

– Reserved words

– Special symbols

– Identifiers

– Data types

– Expressions

– Input

– Output

– Statements

Chapter Summary (continued)

• To create a Java application, it is important to understand:– Syntax rules– Semantic rules– How to manipulate strings and numbers– How to declare variables and named constants– How to receive input and display output– Good programming style and form

Java Introduction

Chapter 3

Introduction to Objects and Input/Output

Chapter Objectives

• Learn about objects and reference variables

• Explore how to use predefined methods in a program

• Become familiar with the class String• Learn how to use input and output dialog

boxes in a program

• Explore how to format the output of decimal numbers with the String method format

• Become familiar with file input and output

Object and Reference Variables

• Declare a reference variable of a class type– Allocate memory space for data– Instantiate an object of that class type

• Store the address of the object in a reference variable

int x; //Line 1

String str; //Line 2

x = 45; //Line 3

str = "Java Programming"; //Line 4

Object and Reference Variables (continued)

78Java Introduction

Object and Reference Variables (continued)

• Primitive type variables directly store data into their memory space

• Reference variables store the address of the object containing the data

• An object is an instance of a class, and the operator new is used to instantiate an object

Objects and Reference Variables (continued)

Using Predefined Classes and Methods in a Program

• There are many predefined packages, classes, and methods in Java

• Library: collection of packages

• Package: contains several classes

• Class: contains several methods

• Method: set of instructions

(continued)• To use a method, you must know:

– Name of the class containing method (Math)– Name of the package containing class

(java.lang)– Name of the method - (pow), it has two

parameters– Math.pow(x, y) = xy

(continued)• Example method call

import java.lang; //imports package

Math.pow(2, 3); //calls power method // in class Math

• Dot (.) operator: used to access the method in the class

The class String

• String variables are reference variables

• Given:

String name; – Similar statements:name = new String("Lisa Johnson");

name = "Lisa Johnson";

The class String (continued)

• A String object is an instance of class String

• The address of a String object with the value "Lisa Johnson" is stored in name

• String methods are called using the dot operator

87Java Introduction

The class String (continued)

sentence = "Programming with Java";

Some Commonly Used String Methods

Some Commonly Used String Methods (continued)

92Java Introduction

Some Commonly Used String Methods (continued)

Input/Output

• Input data

• Format output

• Output results

• Format output

• Read from and write to files

Formatting Output with printf• A syntax to use the method printf to produce

output on the standard output device is:

System.out.printf(formatString);

System.out.printf(formatString, argumentList);

• formatString is a string specifying the format of the output, and argumentList is a list of arguments

Formatting Output with printf (continued)

• argumentList is a list of arguments that consists of constant values, variables, or expressions

• If there is more than one argument in argumentList, then the arguments are separated with commas

System.out.printf("Hello there!");

consists of only the format string, and the statement:

System.out.printf("There are %.2f inches in %d centimeters.%n",

centimeters / 2.54, centimeters);

consists of both the format string and argumentList

• %.2f and %d are called format specifiers • By default, there is a one-to-one

correspondence between format specifiers and the arguments in argumentList

• The first format specifier %.2f is matched with the first argument, which is the expression centimeters / 2.54

• The second format specifier %d is matched with the second argument, which is centimeters

• The format specifier %n positions the insertion point at the beginning of the next line

• A format specifier for general, character, and numeric types has the following syntax:

• The expressions in square brackets are optional; they may or may not appear in a format specifier

• The option argument_index is a (decimal) integer indicating the position of the argument in the argument list– The first argument is referenced by "1$", the second

by "2$", etc. • The option flags is a set of characters that modify

the output format • The option width is a (decimal) integer indicating

the minimum number of characters to be written to the output

• The option precision is a (decimal) integer usually used to restrict the number of characters

• The required conversion is a character indicating how the argument should be formatted

107Java Introduction

The output of these statements is:

Sample Run:123456789012345678901234567890763 658.75 Java Program. ***Java Program. 763 658.75 ***658.75 763 Java Program. ***num = 763 ***x = 658.75 ***str = Java Program. ***Program No.4 ***

Parsing Numeric Strings

• A string consisting of only integers or decimal numbers is called a numeric string

1. To convert a string consisting of an integer to a value of the type int, we use the following expression:Integer.parseInt(strExpression)

Integer.parseInt("6723") = 6723Integer.parseInt("-823") = -823

Parsing Numeric Strings (continued)

2. To convert a string consisting of a decimal number to a value of the type float, we use the following expression: Float.parseFloat(strExpression)

Float.parseFloat("34.56") = 34.56Float.parseFloat("-542.97") = -542.97

3.To convert a string consisting of a decimal number to a value of the type double, we use the following expression:Double.parseDouble(strExpression)

Double.parseDouble("345.78") = 345.78Double.parseDouble("-782.873") = -782.873

• Integer, Float, and Double are classes designed to convert a numeric string into a number

• These classes are called wrapper classes • parseInt is a method of the class Integer, which converts a numeric integer string into a value of the type int

• parseFloat is a method of the class Float and is used to convert a numeric decimal string into an equivalent value of the type float

• parseDouble is a method of the class Double, which is used to convert a numeric decimal string into an equivalent value of the type double

Using Dialog Boxes for Input/Output

• Use a graphical user interface (GUI)• class JOptionPane

– Contained in package javax.swing– Contains methods showInputDialog and showMessageDialog

• Syntaxstr = JOptionPane.showInputDialog(strExpression)

• Program must end with System.exit(0);

Using Dialog Boxes for Input/Output (continued)

Parameters for the Method showMessageDialog

JOptionPane Options for the Parameter messageType

JOptionPane Example

Formatting the Output Using the String Method format

Example 3-12double x = 15.674; double y = 235.73; double z = 9525.9864;int num = 83;String str;

File Input/Output

• File: area in secondary storage used to hold information

• You can also initialize a Scanner object to input sources other than the standard input device by passing an appropriate argument in place of the object System.in

• We make use of the class FileReader

File Input/Output (continued)

• Suppose that the input data is stored in a file, say prog.dat, and this file is on the floppy disk A

• The following statement creates the Scanner object inFile and initializes it to the file prog.dat

• Scanner inFile = new Scanner

(new FileReader("prog.dat"));

• Next, you use the object inFile to input data from the file prog.dat just the way you used the object console to input data from the standard input device using the methods next, nextInt, nextDouble, and so on

The statement in Line 1 assumes that the file prog.dat is in the same directory (subdirectory) as your program. However, if this is in a different directory (subdirectory), then you must specify the path where the file is located, along with the name of the file. For example, suppose that the file prog.dat is on a flash memory in drive H. Then the statement in Line 1 should be modified as follows:Scanner inFile = new Scanner(new FileReader("h:\\prog.dat"));Note that there are two \ after h:. Recall that in Java \ is the escape character. Therefore, to produce a \ within a string you need \\. (Moreover, to be absolutely sure about specifying the source where the input file is stored, such as the flash memory in drive h:\\, check your system’s documentation.)

• Java file I/O process1. Import necessary classes from the packages

java.util and java.io into the program

2. Create and associate appropriate objects with the input/output sources

3. Use the appropriate methods associated with the variables created in Step 2 to input/output data

4. Close the files

Example 3-16Suppose an input file, say employeeData.txt, consists of the following data:

Emily Johnson 45 13.50

Scanner inFile = new Scanner (new FileReader("employeeData.txt"));String firstName; String lastName; double hoursWorked; double payRate; double wages; firstName = inFile.next(); lastName = inFile.next(); hoursWorked = inFile.nextDouble(); payRate = inFile.nextDouble(); wages = hoursWorked * payRate;

inFile.close(); //close the input file

Storing (Writing) Output to a File

• To store the output of a program in a file, you use the class PrintWriter

• Declare a PrintWriter variable and associate this variable with the destination

• Suppose the output is to be stored in the file prog.out

Storing (Writing) Output to a File (continued)

• Consider the following statement:PrintWriter outFile = new PrintWriter("prog.out");

• This statement creates the PrintWriter object outFile and associates it with the file prog.out

• You can now use the methods print, println, and printf with outFile just the same way they have been used with the object System.out

• The statement:

outFile.println("The paycheck is: $" + pay);

stores the output—The paycheck is: $565.78—in the file prog.out-This statement assumes that the value of the variable pay is 565.78

• Step 4 requires closing the file; you close the input and output files by using the method close inFile.close();outFile.close();

• Closing the output file ensures that the buffer holding the output will be emptied; that is, the entire output generated by the program will be sent to the output file

• During program execution, various things can happen; for example, division by zero or inputting a letter for a number

• In such cases, we say that an exception has occurred

• If an exception occurs in a method, the method should either handle the exception or throw it for the calling environment to handle

• If an input file does not exist, the program throws a FileNotFoundException

throws Clause

throws Clause (continued)• If an output file cannot be created or accessed, the

program throws a FileNotFoundException • For the next few chapters, we will simply throw

the exceptions• Because we do not need the method main to

handle the FileNotFoundException exception, we will include a command in the heading of the method main to throw the FileNotFoundException exception

Skeleton of I/O Program

Programming Example: Movie Ticket Sale and Donation to Charity

• Input: movie name, adult ticket price, child ticket price, number of adult tickets sold, number of child tickets sold, percentage of gross amount to be donated to charity

• Output:

Programming Example: Movie Ticket Sale and Donation to Charity

(continued)• Import appropriate packages

• Get inputs from user using JOptionPane.showInputDialog

• Perform appropriate calculations

• Display output using JOptionPane.showMessageDialog

import javax.swing.JOptionPane;

public class MovieTicketSale

//Step 1

String movieName;

String inputStr;

String outputStr;

double adultTicketPrice;

double childTicketPrice;

int noOfAdultTicketsSold;

int noOfChildTicketsSold;

double percentDonation;

double grossAmount;

double amountDonated;

double netSaleAmount;

movieName = JOptionPane.showInputDialog

("Enter the movie name"); //Step 2

inputStr = JOptionPane.showInputDialog

("Enter the price of an adult ticket"); //Step 3

adultTicketPrice = Double.parseDouble(inputStr); //Step 4

("Enter the price of a child ticket"); //Step 5

childTicketPrice = Double.parseDouble(inputStr); //Step 6

("Enter the number of adult tickets sold"); //Step 7

noOfAdultTicketsSold = Integer.parseInt(inputStr); //Step 8

("Enter the number of child tickets sold"); //Step 9

noOfChildTicketsSold = Integer.parseInt(inputStr); //Step 10

("Enter the percentage of the donation"); //Step 11

percentDonation = Double.parseDouble(inputStr); //Step 12

grossAmount = adultTicketPrice * noOfAdultTicketsSold +

childTicketPrice * noOfChildTicketsSold; //Step 13

amountDonated = grossAmount * percentDonation / 100; //Step 14

netSaleAmount = grossAmount - amountDonated; //Step 15

outputStr = "Movie Name: " + movieName + "\n"

+ "Number of Tickets Sold: "

+ (noOfAdultTicketsSold +

noOfChildTicketsSold) + "\n"

+ "Gross Amount: $"

+ String.format("%.2f", grossAmount) + "\n"

+ "Percentage of the Gross Amount Donated: "

+ String.format("%.2f%%", percentDonation) + "\n"

+ "Amount Donated: $"

+ String.format("%.2f", amountDonated) + "\n"

+ "Net Sale: $"

+ String.format("%.2f", netSaleAmount); //Step 16

JOptionPane.showMessageDialog(null, outputStr,

"Theater Sales Data",

JOptionPane.INFORMATION_MESSAGE); //Step 17

System.exit(0); //Step 18

Programming Example: Student Grade

• Input: file containing student’s first name, last name, five test scores

• Output: file containing student’s first name, last name, five test scores, average of five test scores

Programming Example:Student Grade (continued)

• Import appropriate packages• Get input from file using the classes Scanner and FileReader

• Read and calculate the average of test scores

• Write to output file using the class PrintWriter

• Close files

import java.io.*;

import java.util.*;

public class StudentGrade

public static void main(String[] args) throws

FileNotFoundException

//declare and initialize the variables //Step 1

double test1, test2, test3, test4, test5;

double average;

String firstName;

String lastName;

Scanner inFile =

new Scanner(new FileReader("test.txt")); //Step 2

PrintWriter outFile = new

PrintWriter("testavg.out"); //Step 3

firstName = inFile.next(); //Step 4

lastName = inFile.next(); //Step 4

outFile.println("Student Name: "

+ firstName + " " + lastName); //Step 5

//Step 6 - retrieve the five test scores

test1 = inFile.nextDouble();

outFile.printf("Test scores: %5.2f %5.2f %5.2f "

+ "%5.2f %5.2f %n", test1, test2,

test3, test4, test5); //Step 7

average = (test1 + test2 + test3 + test4

+ test5) / 5.0; //Step 8

outFile.printf("Average test score: %5.2f %n",

average); //Step 9

inFile.close(); //Step 10

outFile.close(); //Step 10

Chapter Summary

• Primitive type variables store data into their memory space

• Reference variables store the address of the object containing the data

• An object is an instance of a class

Chapter Summary (continued)• Operator new is used to instantiate an object

• Garbage collection is reclaiming memory not being used

• To use a predefined method, you must know its name and the class and package it belongs to

• The dot (.) operator is used to access a certain method in a class

• Methods of the class String are used to manipulate input and output data

• Dialog boxes can be used to input data and output results

• Data can be read from and written to files• Data can be formatted using the String

method format

Java Introduction

Chapter 4Control Structures I: Selection

Chapter Objectives

• Learn about control structures

• Examine relational and logical operators

• Explore how to form and evaluate logical (Boolean) expressions

• Learn how to use the selection control structures if, if…else, and switch in a program

Control Structures

• Three methods of processing a program– In sequence– Branching– Looping

• Branch: altering the flow of program execution by making a selection or choice

• Loop: altering the flow of program execution by repetition of statement(s)

Flow of Execution

Relational Operators

• Relational operator– Allows you to make comparisons in a program– Binary operator

• Condition is represented by a logical expression in Java

• Logical expression: expression that has a value of either true or false

Relational Operators in Java

Relational Operators and Primitive Data Types

• Can be used with integral and floating-point data types

• Can be used with the char data type

• Unicode collating sequence

Relational Operators and the Unicode Collating Sequence

Logical (Boolean) Operators

Logical (Boolean) Operators (continued)

Precedence of Operators

Precedence of Operators (continued)

Selection

• One-way selection

• Two-way selection

• Compound (block of) statements

• Multiple selections (nested if)

• Conditional operator• switch structures

One-Way Selection

• Syntaxif (expression)

statement

• Expression referred to as decision maker

• Statement referred to as action statement

One-Way Selection (continued)

Example 4-7

//Program to determine the absolute value of an integer

public class AbsoluteValue

int number;

int temp;

String numString;

numString =

JOptionPane.showInputDialog

("Enter an integer:"); //Line 1

number = Integer.parseInt(numString); //Line 2

temp = number; //Line 3

if (number < 0) //Line 4 number = -number; //Line 5

JOptionPane.showMessageDialog(null, "The absolute value of " + temp + " is " + number, "Absolute Value", JOptionPane.INFORMATION_MESSAGE); //Line 6 System.exit(0); }

if (number < 0) //Line 4 number = -number; //Line 5

JOptionPane.showMessageDialog(null, "The absolute value of " + temp + " is " + number, "Absolute Value", JOptionPane.INFORMATION_MESSAGE); //Line 6 System.exit(0); }

Two-Way Selection

• Syntax

if (expression)

statement1

statement2• else statement must be paired with an if

Two-Way Selection (continued)

Example 4-10

if (hours > 40.0) wages = 40.0 * rate + 1.5 * rate * (hours - 40.0); else wages = hours * rate;

Example 4-11

if (hours > 40.0); //Line 1 wages = 40.0 * rate + 1.5 * rate * (hours - 40.0); //Line 2else //Line 3 wages = hours * rate; //Line 4

• Because a semicolon follows the closing parenthesis of the if statement (Line 1), the else statement stands alone • The semicolon at the end of the if statement (see Line 1) ends the if statement, so the statement at Line 2 separates the else clause from the if statement; that is, else is by itself • Since there is no separate else statement in Java, this code

generates a syntax error

Compound (Block of) Statements• Syntax

Compound (Block of) Statements (continued)

if (age > 18){ System.out.println("Eligible to vote."); System.out.println("No longer a minor.");} else{ System.out.println("Not eligible to vote."); System.out.println("Still a minor.");}

Multiple Selection: Nested if

• Syntax

if (expression1)

statement1

else if (expression2)

statement2

statement3

• Else associated with most recent incomplete if

• Multiple if statements can be used in place of if…else statements

• May take longer to evaluate

Multiple Selection: Nested if (continued)

To avoid excessive indentation, the code in Example 4-15 can be rewritten as follows:

• Definition: a process in which the computer evaluates a logical expression from left to right and stops as soon as the value of the expression is known

Short-Circuit Evaluation

Short-Circuit Evaluation (continued)

• The preceding program and its output show that you should be careful when comparing floating-point numbers for equality.

• One way to check whether two floating-point numbers are equal is to check whether the absolute value of their difference is less than a certain tolerance. For example, suppose the tolerance is .000001.

• Then x and y are equal if the absolute value of (x – y) is less than 0.000001. To find the absolute value, you can use the function Math.abs of the class Math, as shown in the program.

• Therefore, the expression Math.abs(x – y) < 0.000001 determines whether the absolute value of (x – y) is less than 0.000001.

Conditional (? :) Operator

• Ternary operator

• Syntaxexpression1 ? expression2 : expression3

• If expression1 = true, then the result of the condition is expression 2; otherwise, the result of the condition is expression 3

switch Structures

switch Structures (continued)

• In Java, switch, case, break, and default are reserved words

• In a switch structure, the expression is evaluated first

• The value of the expression is then used to perform the actions specified in the statements that follow the reserved word case

• The expression is usually an identifier • The value of the identifier or the expression can be only of type int, byte, short, or char

Java Introduction 201

• The expression is sometimes called the selector; its value determines which statements are selected for execution

• A particular case value must appear only once• One or more statements may follow a case

label, so you do not need to use braces to turn multiple statements into a single compound statement

• The break statement may or may not appear after each statements1, statements2, ..., statementsn

• A switch structure may or may not have the default label

Example 4-20

switch (grade){case 'A': System.out.println("The grade is A."); break;

case 'B': System.out.println("The grade is B."); break;

case 'C': System.out.println("The grade is C."); break;

case 'D': System.out.println("The grade is D."); break;

case 'F': System.out.println("The grade is F."); break;

default: System.out.println("The grade is invalid.");}

To output results correctly, the switch structure must include a break statement after each println statement, except the last println statement.

Programming Example: Cable Company Billing

• Input: customer’s account number, customer code, number of premium channels to which customer subscribes, number of basic service connections (in case of business customers)

• Output: customer’s account number and the billing amount

Programming Example: Cable Company Billing (continued)

• Solution – Prompt user for information– Use switch statements based on customer’s

type– Use an if statement nested within a switch

statement to determine amount due by each customer

Comparing Strings

• class String – Method compareTo– Method equals

• Given string str1 and str2

str2str1 0

reTo(str2)str1.compa

string ifinteger an

string toequal is string if

string ifinteger an

Comparing Strings (continued)String str1 = "Hello";

String str2 = "Hi";

String str3 = "Air";

String str4 = "Bill";

String str5 = "Bigger";

Comparing Strings (continued)

Code Example//***********************************************************

// Program: Cable Company Billing

// This program calculates and prints a customer’s bill for

// a local cable company. The program processes two types of

// customers: residential and business.

//***********************************************************

import java.util.*;

public class CableCompanyBilling

static Scanner console = new Scanner(System.in);

//Named constants - residential customers

static final double R_BILL_PROC_FEE = 4.50;

static final double R_BASIC_SERV_COST = 20.50;

static final double R_COST_PREM_CHANNEL = 7.50;

//Named constants - business customers

static final double B_BILL_PROC_FEE = 15.00;

static final double B_BASIC_SERV_COST = 75.00;

static final double B_BASIC_CONN_COST = 5.00;

static final double B_COST_PREM_CHANNEL = 50.00;

//Variable declaration

int accountNumber;

char customerType;

int noOfPremChannels;

int noOfBasicServConn;

double amountDue;

System.out.println("This program computes "

+ "a cable bill.");

System.out.print("Enter the account "

+ "number: "); //Step 1

accountNumber = console.nextInt(); //Step 2

System.out.print("Enter the customer type: "

+ "R or r (Residential), "

+ "B or b(Business): "); //Step 3

customerType = console.next().charAt(0); //Step 4

switch (customerType)

case 'r': //Step 5

case 'R':

System.out.print("Enter the number of "

+ "premium channels: "); //Step 5a

noOfPremChannels = console.nextInt(); //Step 5b

amountDue = R_BILL_PROC_FEE + //Step 5c

R_BASIC_SERV_COST +

noOfPremChannels *

R_COST_PREM_CHANNEL;

System.out.println("Account number = "

+ accountNumber); //Step 5d

System.out.printf("Amount due = $%.2f %n",

amountDue); //Step 5e

break;

case 'b': //Step 6

case 'B':

+ "basic service "

+ "connections: "); //Step 6a

noOfBasicServConn = console.nextInt(); //Step 6b

+ "premium channels: "); //Step 6c

noOfPremChannels = console.nextInt(); //Step 6d

if (noOfBasicServConn <= 10) //Step 6e

amountDue = B_BILL_PROC_FEE +

B_BASIC_SERV_COST +

noOfPremChannels *

B_COST_PREM_CHANNEL;

amountDue = B_BILL_PROC_FEE +

B_BASIC_SERV_COST +

(noOfBasicServConn - 10) *

B_BASIC_CONN_COST +

noOfPremChannels *

B_COST_PREM_CHANNEL;

System.out.println("Account number = "

+ accountNumber); //Step 6f

System.out.printf("Amount due = $%.2f %n",

amountDue); //Step 6g

break;

default: //Step 7

System.out.println("Invalid customer type.");

}//end switch

Chapter Summary

• Control structures are used to process programs• Logical expressions and order of precedence of

operators are used in expressions• If statements• if…else statements• switch structures• Proper syntax for using control statements• Compare strings

Java Introduction

Chapter 5Control Structures II: Repetition

Chapter Objectives

• Learn about repetition (looping) control structures• Explore how to construct and use count-

controlled, sentinel-controlled, flag-controlled, and EOF-controlled repetition structures

• Examine break and continue statements• Discover how to form and use nested control

structures

Why Is Repetition Needed?

• There are many situations in which the same statements need to be executed several times

• Example– Formulas used to find average grades for

students in a class

The while Looping (Repetition) Structure

• Syntaxwhile (expression)

statement

• Expression is always true in an infinite loop

• Statements must change value of expression to false

The while Looping (Repetition) Structure (continued)

Example 5-1

i = 0; //Line 1while (i <= 20) //Line 2{

System.out.print(i + " "); //Line 3 i = i + 5; //Line 4

System.out.println(); //Line 5

Output:

0 5 10 15 20

The while Looping (Repetition) Structure (continued)

• Typically, while loops are written in the following form:

Counter-Controlled while Loop• Used when exact number of data or entry pieces is

known• General form:

Sentinel-Controlled while Loop

• Used when exact number of entry pieces is unknown but last entry (special/sentinel value) is known

• General form:

Java Introduction

Flag-Controlled while Loop

• Boolean value used to control loop

• General form:

EOF (End of File)-Controlled while Loop

• Used when input is from files• Sentinel value is not always appropriate• In an EOF-controlled while loop that uses

the Scanner object console to input data, console acts at the loop control variable

• The method hasNext, of the class Scanner, returns true if there is an input in the input stream; otherwise it returns false

EOF (End of File)-Controlled while Loop (continued)

• The expression console.hasNext() evaluates to true if there is an input in the input stream; otherwise it returns false

• Expressions such as console.nextInt() act as the loop condition

• A general form of the EOF-controlled while loop that uses the Scanner object console to input data is of the form:

EOF (End of File)-Controlled while Loop (continued)

• Suppose that inFile is a Scanner object initialized to the input file; in this case, the EOF-controlled while loop takes the following form:

Programming Example: Fibonacci Number

• Fibonacci formula for any Fibonacci sequence:an = an-1 + an-2

• Input: first two Fibonacci numbers in sequence, position in sequence of desired Fibonacci number (n)– int previous1 = Fibonacci number 1– int previous2 = Fibonacci number 2– int nthFibonacci = position of nth Fibonacci number

• Output: nth Fibonacci number

Programming Example: Fibonacci Number (Solution)

if (nthFibonacci == 1) current = previous1; else if (nthFibonacci == 2) current = previous2; else { counter = 3;

while (counter <= nthFibonacci) { current = previous2 + previous1; previous1 = previous2; previous2 = current; counter++; } }

• Final result found in last value of current

The for Looping (Repetition) Structure

• Specialized form of while loop

• Simplifies the writing of count-controlled loops

• Syntaxfor (initial expression; logical expression;

update expression)

statement

The for Looping (Repetition) Structure (continued)

• Execution– Initial statement executes – The loop condition is evaluated– If loop condition evaluates to true, execute for loop statement and execute update statement

– Repeat until loop condition is false

Example 5-9The following for loop prints the first 10 nonnegative integers:

for (i = 0; i < 10; i++)

System.out.print(i + " ");

Example 5-101. The following for loop outputs the word Hello and a star (on separate

lines) five times:

for (i = 1; i <= 5; i++){

System.out.println("Hello"); System.out.println("*");

for (i = 1; i <= 5; i++) System.out.println("Hello"); System.out.println("*");

This loop outputs the word Hello five times and the star only once

• Does not execute if initial condition is false

• Update expression changes value of loop control variable, eventually making it false

• If logical expression is always true, result is an infinite loop

• Infinite loop can be specified by omitting all three control statements

• If logical expression is omitted, it is assumed to be true

• for statement ending in semicolon is empty

Programming Example: Classify Numbers

• Input: N integers (positive, negative, and zeros)

int N = 20; //N easily modified

• Output: number of 0s, number of even integers, number of odd integers

Programming Example: Classify Numbers (Solution)

for (counter = 1; counter <= N; counter++){ number = console.nextInt(); System.out.print(number + " "); switch (number % 2) { case 0: evens++; if (number == 0) zeros++; break; case 1: case -1: odds++; } //end switch} //end for loop

Programming Example: Classify Numbers (Solution) (continued)

• The switch statement in Step 3c can also be written as an if...else statement as follows:

The do…while Loop (Repetition) Structure

• Syntax

• Statements executed first, and then logical expression evaluated

• Statement(s) executed at least once and then continued if logical expression is true

do…while Loop (Post-test Loop)

do…while Loop (Post-test Loop) (continued)

• A do...while loop can be used for input validation. • Suppose that a program prompts a user to enter a test score, which

must be greater than or equal to 0 and less than or equal to 50. • If the user enters a score less than 0 or greater than 50, the user

should be prompted to re-enter the score. • The following do...while loop can be used to accomplish this

objective:

Choosing the Right Looping Structure

• All three loops have a place in Java

• If you know or the program can determine in advance the number of repetitions needed, the for loop is the correct choice

• If you do not know and the program cannot determine in advance the number of repetitions needed, and it could be zero, the while loop is the right choice

• If you do not know and the program cannot determine in advance the number of repetitions needed, and it is at least one, the do...while loop is the right choice

break Statements

• Used to exit early from a loop

• Used to skip remainder of switch structure

• Can be placed within if statement of a loop– If condition is met, loop exited immediately

continue Statements

• Used in while, for, and do...while structures

• When executed in a loop, the remaining statements in the loop are skipped; proceeds with the next iteration of the loop

• When executed in a while/do…while structure, expression evaluated immediately after continue statement

• In a for structure, the update expression is executed after the continue statement; then the loop condition executes

The objective is to find the sum of the numbers in each line. For each line, output the numbers together with their sum. Let us consider the following program:

• The Sample Run shows that there is a bug in the program because after correctly producing the three lines of output, the program crashes with error messages.

• This is an example of a run (execution) time error. That is, the program compiled correctly, but crashed during execution.

• The last line of output shows that the error is in line 23 of the code, which is the put statement: num = infile.nextInt();.

• The program is trying to read data from the input file, but there is no more input in the file.

• At this point the value of the outer loop variable i is 4. Clearly, there is a bug in the program and we must fix the code. Some programmers, especially some beginners, address the symptom of the problem by adding a software patch.

• A beginning programmer might fix the code by adding a software patch as shown in the following modified program:

• The programmer merely observed the symptom and addressed the problem by adding a software patch.

• Not only will the program execute extra statements, it is also an example of a partially understood concept.

• It appears that the programmer does not have a good grasp of why the earlier program produced four lines rather than three. Adding a patch eliminated the symptom, but it is a poor programming practice.

• The programmer must resolve why the program produced four lines.

• Looking at the program closely, we can see that the four lines are produced because the outer loop executes four times.

• The values assigned to loop control variable i are 1, 2, 3, and 4. • This is an example of the classic ‘‘off by one’’ problem. (In the

‘‘off by one’’ problem, either the loop executes one too many or one too few times.)

• We can eliminate this problem by correctly setting the values of the loop control variable. For example, we can rewrite the loops as follows:

• If there are syntax errors, the compiler will identify them. • If there are logical errors, we must carefully look at the code or

even maybe at the design to try to find the errors. • To increase the reliability of the program, errors must be

discovered and fixed before the program is released to the users. • Once an algorithm is written, the next step is to verify that it

works properly. • If the algorithm is a simple sequential flow or contains a branch,

it can be hand traced or you can use the debugger, if any, provided by the IDE.

• Typically, loops are harder to debug. The correctness of a loop can be verified by using loop invariants.

• A loop invariant is a set of statements that remains true each time the loop body is executed. Let p be a loop invariant and q be the (logical) expression in a loop statement.

• Then p && q remains true before each iteration of the loop and p && not(q) is true after the loop terminates.

• The most common error associated with loops is off by one. • If a loop turns out to be an infinite loop, the error is most likely in

the logical expression that controls the execution of the loop. • Check the logical expression carefully and see if you have reversed

an inequality, an assignment statement symbol appears in place of the equality operator, or && appears in place of ||.

• If the loop changes the values of variables, you can print the values of the variables before and/or after each iteration or you can use your IDE’s debugger, if any, and watch the values of variables during each iteration.

• Debugging can be a tiresome process. • If your program is very bad, do not debug; throw it away and start

Nested Control Structure

• Provides new power, subtlety, and complexity

• if, if…else, and switch structures can be placed within while loops

• for loops can be found within other for loops

Nested Control Structure (Example)

for (i = 1; i <= 5; i++){ for (j = 1; j <= i; j++) System.out.print(" *");

System.out.println();}• Output:***************

Code Example//********************************************************

// Program: Telephone Digits

// This is an example of a sentinel-controlled while loop.

// This program converts uppercase letters to their

// corresponding telephone digits.

//********************************************************

public class TelephoneDigitProgram

public static void main (String[] args)

char letter; //Line 1

String inputMessage; //Line 2

String inputString; //Line 3

String outputMessage; //Line 4

Code Example inputMessage = "Program to convert uppercase "

+ "letters to their corresponding "

+ "telephone digits.\n"

+ "To stop the program enter #.\n"

+ "Enter a letter:"; //Line 5

inputString =

JOptionPane.showInputDialog(inputMessage); //Line 6

letter = inputString.charAt(0); //Line 7

while (letter != '#' ) //Line 8

outputMessage = "The letter you entered is: "

+ letter + "\n"

+ "The corresponding telephone "

+ "digit is: "; //Line 9

Code Example if (letter >= 'A' && letter <= 'Z') //Line 10

switch (letter) //Line 11

case 'A':

case 'B':

case 'C':

outputMessage = outputMessage

+ "2"; //Line 12

break; //Line 13

case 'D':

case 'E':

case 'F':

+ "3"; //Line 14

break; //Line 15

case 'G':

case 'H':

case 'I':

+ "4"; //Line 16

break; //Line 17

case 'J':

case 'K':

case 'L':

+ "5"; //Line 18

break; //Line 19

case 'M':

case 'N':

case 'O':

+ "6"; //Line 20

break; //Line 21

case 'P':

case 'Q':

case 'R':

case 'S':

+ "7"; //Line 22

break; //Line 23

case 'T':

case 'U':

case 'V':

+ "8"; //Line 24

break; //Line 25

case 'W':

case 'X':

case 'Y':

case 'Z':

+ "9"; //Line 26

Code Example case 'J':

case 'K':

case 'L':

+ "5"; //Line 18

break; //Line 19

case 'M':

case 'N':

case 'O':

+ "6"; //Line 20

break; //Line 21

case 'P':

case 'Q':

case 'R':

case 'S':

+ "7"; //Line 22

break; //Line 23

case 'T':

case 'U':

case 'V':

+ "8"; //Line 24

break; //Line 25

case 'W':

case 'X':

case 'Y':

case 'Z':

+ "9"; //Line 26

Code Example case 'T':

case 'U':

case 'V':

+ "8"; //Line 24

break; //Line 25

case 'W':

case 'X':

case 'Y':

case 'Z':

+ "9"; //Line 26

Code Example else //Line 27

+ "Invalid input"; //Line 28

JOptionPane.showMessageDialog(null, outputMessage,

"Telephone Digit",

JOptionPane.PLAIN_MESSAGE); //Line 29

inputMessage = "Enter another uppercase letter "

+ "to find its corresponding "

+ "telephone digit.\n"

+ "To stop the program enter #.\n"

+ "Enter a letter:"; //Line 30

inputString =

JOptionPane.showInputDialog(inputMessage); //Line 31

letter = inputString.charAt(0); //Line 32

}//end while

System.exit(0); //Line 33

Chapter Summary

• Looping mechanisms– Counter-controlled while loop– Sentinel-controlled while loop– Flag-controlled while loop– EOF-controlled while loop– for loop– do…while loop

• break statements• continue statements• Nested control structures

Java Introduction

Chapter 6

Graphical User Interface (GUI) and Object-Oriented Design (OOD)

Chapter Objectives

• Learn about basic GUI components

• Explore how the GUI components JFrame, JLabel, JTextField, and JButton work

• Become familiar with the concept of event-driven programming

• Discover events and event handlers

• Explore object-oriented design

• Learn how to identify objects, classes, and members of a class

Graphical User Interface (GUI) Components

• View inputs and outputs simultaneously

• One graphical window

• Input values in any order

• Change input values in window

• Click on buttons to get output

Java GUI Components

Code Example// This Java Program determines the area and

// perimeter of a rectangle.

public class Rectangle

double width, length, area, perimeter; //Line 1

String lengthStr, widthStr, outputStr; //Line 2

lengthStr =

JOptionPane.showInputDialog("Enter the length: "); //Line 3

length = Double.parseDouble(lengthStr); //Line 4

widthStr =

JOptionPane.showInputDialog("Enter the width: "); //Line 5

width = Double.parseDouble(widthStr); //Line 6

Code Example area = length * width; //Line 7

perimeter = 2 * (length + width); //Line 8

outputStr = "Length: " + length + "\n" +

"Width: " + width + "\n" +

"Area: " + area + " square units\n" +

"Perimeter: " + perimeter + " units\n"; //Line 9

JOptionPane.showMessageDialog(null, outputStr,

"Rectangle",

JOptionPane.INFORMATION_MESSAGE); //Line 10

System.exit(0); //Line 11

Graphical User Interface (GUI) Components (continued)

• GUI components placed in content pane

• GUI components– Windows– Labels– Text areas– Buttons

GUI Components

• Added to content pane of window

• Not added to window itself

• Pixel: picture element

Windows

• Can be created using a JFrame object• The class JFrame provides various

methods to control attributes of a window• Measured in pixels of height and width• Attributes associated with windows

– Title– Width– Height

class JFrame

• GUI window instance created as instance of JFrame

• Provides various methods to control window attributes

Methods Provided by the class JFrame

Methods Provided by the class Jframe (continued)

Two Ways to Create a Window

• First way – Declare object of type JFrame– Instantiate object– Use various methods to manipulate window

• Second way– Create class containing application program by

extending definition of class JFrame– Utilizes mechanism of inheritance

Content Pane

• Inner area of GUI window (below title bar, inside border)

• To access content pane:– Declare reference variable of type Container– Use method getContentPane of class JFrame

Methods Provided by the class Container

class JLabel

• Labels: objects of particular class type• class JLabel: used to create labels• Label attributes

– Title– Width– Height

• To create a label:– Instantiate object of type JLabel – Modify attributes to control display of labels

class Jlabel (continued)

class JTextField

• Text fields: objects belonging to class JTextField

• To create text field:– Declare reference variable of type JTextField

– Instantiate object

class JTextField (continued)

class JButton

• Provided to create buttons in Java

• To create button:– Same technique as creating JLabel and JTextField

class Jbutton (continued)

Handling an Event

• Action event: event created when JButton is clicked

• Event listener: object that receives message when JButton is clicked

• In Java, you must register the listener

Handling an Event (continued)

• class ActionListener– Handles action event – Part of package java.awt.Event– The class ActionListener is a special

type of class (interface)– Must contain actionPerformed method

Rectangle Program: Sample Run

Programming Example: Temperature Conversion

• Input: temperature in Fahrenheit or Celsius

• Output: temperature in Celsius if input is Fahrenheit; temperature in Fahrenheit if input is Celsius

Programming Example: Temperature Conversion (continued)

• Solution– Create the appropriate JLabels, JTextFields, JButtons

– Add them to the created content pane – Calculate the appropriate conversions when the

buttons are clicked and an event is triggered

//*************************************************************

//Java program to convert the temperature between Celsius and

//Fahrenheit.

//*************************************************************

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class TempConversion extends JFrame

private JLabel celsiusLabel;

private JLabel fahrenheitLabel;

private JTextField celsiusTF;

private JTextField fahrenheitTF;

private CelsHandler celsiusHandler;

private FahrHandler fahrenheitHandler;

private static final int WIDTH = 500;

private static final int HEIGHT = 50;

private static final double FTOC = 5.0 / 9.0;

private static final double CTOF = 9.0 / 5.0;

private static final int OFFSET = 32;

public TempConversion()

setTitle("Temperature Conversion");

Container c = getContentPane();

c.setLayout(new GridLayout(1, 4));

celsiusLabel = new JLabel("Temp in Celsius: ",

SwingConstants.RIGHT);

fahrenheitLabel = new JLabel("Temp in Fahrenheit: ",

SwingConstants.RIGHT);

celsiusTF = new JTextField(7);

fahrenheitTF = new JTextField(7);

c.add(celsiusLabel);

c.add(celsiusTF);

c.add(fahrenheitLabel);

c.add(fahrenheitTF);

celsiusHandler = new CelsHandler();

fahrenheitHandler = new FahrHandler();

celsiusTF.addActionListener(celsiusHandler);

fahrenheitTF.addActionListener(fahrenheitHandler);

setSize(WIDTH, HEIGHT);

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible(true);

private class CelsHandler implements ActionListener

public void actionPerformed(ActionEvent e)

double celsius, fahrenheit;

celsius =

Double.parseDouble(celsiusTF.getText());

fahrenheit = celsius * CTOF + OFFSET;

fahrenheitTF.setText(String.format("%.2f",

fahrenheit));

private class FahrHandler implements ActionListener

public void actionPerformed(ActionEvent e)

double celsius, fahrenheit;

fahrenheit =

Double.parseDouble(fahrenheitTF.getText());

celsius = (fahrenheit - OFFSET) * FTOC;

celsiusTF.setText(String.format("%.2f",

celsius));

TempConversion tempConv = new TempConversion();

Sample Run for TempConversion

Object-Oriented Design

• Simplified methodology1. Write down detailed description of problem

2. Identify all (relevant) nouns and verbs

3. From list of nouns, select objects

4. Identify data components of each object

5. From list of verbs, select operations

Object-Oriented Design Example 1

• Problem statement– Write a program to input the length and width

of a rectangle, and calculate and print the perimeter and area of the rectangle

• Nouns– Length, width, rectangle, perimeter, area

class Rectangle with Data Members and Operations

Object-Oriented Design Example 2

• An inoperable candy machine has a cash register and four dispensers to hold and release items sold by the machine

• The machine sells: candies, chips, gum, and cookies

• Write a program for this candy machine so that it can be put into operation

Object-Oriented Design Example 2 (continued)

• The program should do the following:– Show the customer the different products sold by the

candy machine– Let the customer make the selection– Show the customer the cost of the item selected– Accept money from the customer– Return change– Release the item; that is, make the sale

Object-Oriented Design Example 2 (continued)

Implementing Classes and Operations

• Algorithms are used to implement operations

• Construct and implement your own methods

• Classes Integer, Double, Character, Long, Float – Known as wrapper classes

– Provided so that values of primitive data types can be treated as objects

– Have limitations (cannot change value stored in objects)

The class Integer

The class Integer (continued)

Integer num; num = new Integer(86)

int x; Integer num;

num = 25;

For the most part, this statement is similar to the statement:

num = new Integer(25);

The expression:

num = 25;

is referred to as autoboxing of the int type

int x;

Integer num;

The statement:

x = num;

This statement is equivalent to the statement:

x = num.intValue();

This statement is referred to as auto-unboxing of the int type

• To compare the values of two Integer objects, you can use the method compareTo

• If you want to compare the values of two Integer objects only for equality, then you can use the method equals

Chapter Summary• Every GUI contains a window• Various components are added to content pane of

window• class JFrame is used to create windows• JLabel is used to label GUI components and

display information to user• JTextFiled is used for input/output• JButton generates action event• Action event is sent to action listener

Chapter Summary (continued)• Action listener must have method called actionPerformed

• class: collection of data members and methods associated with those members

• Object-oriented design (OOD)– Starts with a problem statement– Identifies classes required with nouns in problem statement– Identifies methods required with verbs in problem

specification

Java Introduction

Chapter 7User-Defined Methods

Chapter Objectives

• Understand how methods are used in Java programming

• Learn about standard (predefined) methods and discover how to use them in a program

• Learn about user-defined methods

• Examine value-returning methods, including actual and formal parameters

• Explore how to construct and use a value-returning, user-defined method in a program

• Learn how to construct and use user-defined void methods in a program

• Explore variables as parameters

• Learn about the scope of an identifier

• Become aware of method overloading

Predefined Classes

• Methods already written and provided by Java

• Organized as a collection of classes (class libraries)

• To use: import package

• Method type: data type of value returned by method

Predefined Classes (continued)

class Character (Package: java.lang)

class Character (Package: java.lang) (continued)

To simplify the use of (public) static methods of a class, Java 5.0 introduces the following import statements:

These are called static import statements. After including such statements in your program, when you use a (public) static method (or any other public static member) of a class, you can omit the name of the class and the dot operator.

Syntax: Value-Returning Method

User-Defined Methods

• Value-returning methods– Used in expressions– Calculate and return a value– Can save value for later calculation or print value

• modifiers: public, private, protected, static, abstract, final

• returnType: type of the value that the method calculates and returns (using return statement)

• methodName: Java identifier; name of method

Syntax

• Syntax: formal parameter list-The syntax of the formal parameter list is:

• Method call-The syntax to call a value-returning method is:

Syntax (continued)

• Syntax: return statement -The return statement has the following syntax:

return expr;

• Syntax: actual parameter list-The syntax of the actual parameter list is:

Equivalent Method Definitions

public static double larger(double x, double y){ double max;

if (x >= y) max = x; else max = y;

return max;}

Equivalent Method Definitions (continued)

public static double larger(double x, double y){ if (x >= y) return x; else return y;}

Equivalent Method Definitions (continued)

public static double larger(double x, double y){ if (x >= y) return x; return y;}

The int variable num contains the desired sum to be rolled

Palindrome Number

• Palindrome: integer or string that reads the same forward and backward

• The method isPalindrome takes a string as a parameter and returns true if the string is a palindrome, false otherwise

Solution: isPalindrome Method

public static boolean isPalindrome(String str){ int len = str.length(); int i, j; j = len - 1;

for (i = 0; i <= (len - 1) / 2; i++) { if (str.charAt(i) != str.charAt(j)) return false; j--; } return true; }

Flow of Execution• Execution always begins with the first statement

in the method main• User-defined methods execute only when called

• Call to method transfers control from caller to called method

• In method call statement, specify only actual parameters, not data type or method type

• Control goes back to caller when method exits

Programming Example: Largest Number

• Input: set of 10 numbers

• Output: largest of 10 numbers

• Solution– Get numbers one at a time– Method largest number: returns the larger of two

numbers– For loop: calls method largest number on each number

received and compares to current largest number

Solution: Largest Numberstatic Scanner console = new Scanner(System.in);

public static void main(String[] args){ double num; double max; int count; System.out.println("Enter 10 numbers."); num = console.nextDouble(); max = num; for (count = 1; count < 10; count++) { num = console.nextDouble(); max = larger(max, num); } System.out.println("The largest number is " + max); }

Sample Run: Largest Number

• Sample Run

Enter 10 numbers:10.5 56.34 73.3 42 22 67 88.55 26 62 11The largest number is 88.55

Void Methods

• Similar in structure to value-returning methods

• Call to method is always stand-alone statement

• Can use return statement to exit method early

Void Methods with Parameters: Syntax

Void Methods with Parameters: Syntax (continued)

Primitive Data Type Variables as Parameters

• A formal parameter receives a copy of its corresponding actual parameter

• If a formal parameter is a variable of a primitive data type:– Value of actual parameter is directly stored– Cannot pass information outside the method– Provides only a one-way link between actual

parameters and formal parameters

Reference Variables as Parameters

• If a formal parameter is a reference variable:– Copies value of corresponding actual parameter– Value of actual parameter is address of the object

where actual data is stored– Both formal and actual parameter refer to same

object

Uses of Reference Variables as Parameters

• Can return more than one value from a method

• Can change the value of the actual object

• When passing address, would save memory space and time, relative to copying large amount of data

Reference Variables as Parameters: type String

Reference Variables as Parameters: type String (continued)

String str = "Hello"; //Line 5

stringParameter(str); //Line 7

pStr = "Sunny Day"; //Line 14

Variables before the statement in Line 8 executes

• The class StringBuffer contains the method append, which allows you to append a string to an existing string, and the method delete, which allows you to delete all the characters of the string

• The assignment operator cannot be used with StringBuffer variables; you must use the operator new (initially) to allocate memory space for a string

Primitive Type Wrapper Classes as Parameters

• If a formal parameter is of the primitive data type and the corresponding actual parameter is a variable, then the formal parameter cannot change the value of the actual parameter

• Only reference variables can pass values outside the method (except, of course, for the return value)

• Corresponding to each primitive data type, Java provides a class so that the values of primitive data types can be wrapped in objects

• The class Integer does not provide a method to change the value of an existing Integer object

• The same is true of other wrapper classes

Primitive Type Wrapper Classes as Parameters (continued)

• If we want to pass a String object as a parameter and also change that object, we can use the class StringBuffer

• Java does not provide any class that wraps primitive type values in objects and when passed as parameters changes their values

• If a method returns only one value of a primitive type, then you can write a value-returning method

• If you encounter a situation that requires you to write a method that needs to pass more than one value of a primitive type, then you should design your own classes

• Appendix D provides the definitions of such classes and shows how to use them in a program

Scope of an Identifier within a Class

• Local identifier: identifier declared within a method or block, which is visible only within that method or block

• Java does not allow the nesting of methods; you cannot include the definition of one method in the body of another method

• Within a method or a block, an identifier must be declared before it can be used; a block is a set of statements enclosed within braces

Scope of an Identifier within a Class (continued)

• A method’s definition can contain several blocks – The body of a loop or an if statement also

form a block• Within a class, outside of every method

definition (and every block), an identifier can be declared anywhere

• Within a method, an identifier used to name a variable in the outer block of the method cannot be used to name any other variable in an inner block of the method

• For example, in the method definition on the next slide, the second declaration of the variable x is illegal

public static void illegalIdentifierDeclaration(){ int x; //block { double x; //illegal declaration, //x is already declared ... }}

Scope Rules

• Scope rules of an identifier declared within a class and accessed within a method (block) of the class

• An identifier, say x, declared within a method (block) is accessible:– Only within the block from the point at which it is

declared until the end of the block– By those blocks that are nested within that block

Scope Rules (continued)

• Suppose x is an identifier declared within a class and outside of every method’s definition (block) – If x is declared without the reserved word static (such

as a named constant or a method name), then it cannot be accessed in a static method

– If x is declared with the reserved word static (such as a named constant or a method name), then it can be accessed within a method (block), provided the method (block) does not have any other identifier named x

Example 7-11public class ScopeRules{ static final double rate = 10.50; static int z; static double t; public static void main(String[] args) { int num; double x, z; char ch; //... } public static void one(int x, char y) { //... }

public static int w; public static void two(int one, int z) { char ch; int a; //block three { int x = 12; //... } //end block three //... }}

Scope Rules: Demonstrated

Scope Rules: Demonstrated (continued)

Method Overloading: An Introduction

• Method overloading: more than one method can have the same name

• Two methods are said to have different formal parameter lists if both methods have:– A different number of formal parameters, or– If the number of formal parameters is the same,

then the data type of the formal parameters, in the order you list, must differ in at least one position

Method Overloading

public void methodOne(int x)

public void methodTwo(int x, double y)

public void methodThree(double y, int x)

public int methodFour(char ch, int x,

double y)

public int methodFive(char ch, int x,

String name)

• These methods all have different formal parameter lists

Method Overloading (continued)

public void methodSix(int x, double y,

char ch)

public void methodSeven(int one, double u,

char firstCh)

• The methods methodSix and methodSeven both have three formal parameters, and the data type of the corresponding parameters is the same

• These methods all have the same formal parameter lists

• Method overloading: creating several methods, within a class, with the same name

• The signature of a method consists of the method name and its formal parameter list

• Two methods have different signatures if they have either different names or different formal parameter lists– Note that the signature of a method does not include

the return type of the method

• The following method headings correctly overload the method methodXYZ:

public void methodXYZ()

public void methodXYZ(int x, double y)

public void methodXYZ(double one, int y)

public void methodXYZ(int x, double y,

char ch)

public void methodABC(int x, double y)

public int methodABC(int x, double y)

• Both these method headings have the same name and same formal parameter list

• These method headings to overload the method methodABC are incorrect

• In this case, the compiler will generate a syntax error– Notice that the return types of these method headings are different

Programming Example: Data Comparison

• Input: data from two different files• Data format: course number followed by scores• Output: course number, group number, course

average• Solution

– Read from more than one file, write output to file– Generate bar graphs– User-defined methods and re-use (calculateAverage and printResult)

– Parameter passing

Sample Output

Course No Group No Course Average CSC 1 83.71 2 80.82

ENG 1 82.00 2 78.20

HIS 1 77.69 2 84.15

MTH 1 83.57 2 84.29

PHY 1 83.22 2 82.60

Avg for group 1: 82.04Avg for group 2: 82.01

Programming Example: Data Comparison (continued)

• A program may contain a number of methods. In a complex program, usually, when a method is written, it is tested and debugged alone.

• You can write a separate program to test the method. The program that tests a method is called a driver program.

• Before writing the complete program, you could write separate driver programs to make sure that each method is working properly.

• Sometimes the results calculated by one method are needed in another method.

• In that case, the method that depends on another method cannot be tested alone.

• A method stub is a method that is not fully coded. • For a void method, a method stub might consist of only a

method header and a set of empty braces, {}. • For a value-returning method it might contain only a return

statement with a plausible return value.

• If the problem is large and complex, it must be broken into subproblems, and if a subproblem is still complex, it must further be divided into subproblems.

• The subdivision of a problem should continue to the point where the solution is clear and obvious.

• Once a subproblem is solved, we can continue with the solution of another subproblem and if all the subproblems of a problem are solved, we can continue with the next level.

• Eventually, the overall solution of the problem must be assembled and tested to ensure that the programming code accomplishes the required task.

• A Java program is a collection of classes, and a class is a collection of data members and methods.

• Each class and each method must work properly. • To accomplish this, as explained in the previous section, once a

method is written, it can be tested using stubs and drivers. • Since a method can be tested in isolation, it is not necessary to

code all the methods in order. • Once all the methods are written, the overall program must be

tested.

• The technique to solve a problem by subdividing into smaller problems is known as divide and conquer and top-down design approach.

• These techniques are suitable and work for many kinds of problems, including most of the problems given in this book and the problems you will encounter as a beginning programmer.

• To simplify the overall solution of a problem that consists of many subproblems, we write and test the code one piece at a time.

• Typically, once a subproblem is solved and the code is tested, it is saved as the first version or a version of the program.

• We continue to add and save the program one piece at a time. Keep in mind that a working program with fewer features is better than a nonworking one with many features.

Chapter Summary

• Predefined methods

• User-defined methods– Value-returning methods– Void methods– Formal parameters– Actual parameters

• Flow of execution

• Primitive data type variables as parameters– One-way link between actual parameters and

formal parameters (limitations caused)

• Reference variables as parameters – Can pass one or more variables from a method– Can change value of actual parameter

• Scope of an identifier within a class• Method overloading

• Debugging: using drivers and stubs

• Avoiding bugs: one-piece-at-a-time coding

Java Introduction

Chapter 8User-Defined Classes and ADTs

Chapter Objectives

• Learn about classes

• Learn about private, protected, public, and static members of a class

• Explore how classes are implemented

• Learn about the various operations on classes

• Examine constructors and finalizers

• Examine the method toString• Learn about the abstract data type (ADT)

Classesfinal class String { //variables to store a string ... public int compareTo(String anotherString) { //code to compare two strings } public String concat(String str) { //code to join two strings } public String toLowerCase() { //code to convert all the characters of a //string to lowercase } ...}

Classes (continued)

• class: reserved word; collection of a fixed number of components

• Components: members of a class• Members accessed by name• Class categories/modifiers

– private– protected– public

Classes (continued)

• private: members of class are not accessible outside class

• public: members of class are accessible outside class

• Class members: can be methods or variables

• Variable members declared like any other variables

Syntax

The general syntax for defining a class is:

Syntax (continued)

• If a member of a class is a named constant, you declare it just like any other named constant

• If a member of a class is a variable, you declare it just like any other variable

• If a member of a class is a method, you define it just like any other method

Syntax (continued)

• If a member of a class is a method, it can (directly) access any member of the class—data members and methods

- Therefore, when you write the definition of a method (of the class), you can directly access any data member of the class (without passing it as a parameter)

Data Members (Instance Variables)•private int hr; //store hours•private int min; //store minutes•private int sec; //store seconds

class Clock

class Clock (continued)

Methods • public void setTime(int hours, int minutes, int seconds)• public int getHours()• public int getMinutes()• public int getSeconds()• public void printTime() • public void incrementSeconds()• public void incrementMinutes()• public void incrementHours()• public boolean equals(Clock otherClock)• public void makeCopy(Clock otherClock)• public Clock getCopy()

• Two types of constructors- With parameters- Without parameters (default constructor)

Constructors

Constructors (continued)• Constructors have the following properties:

- The name of a constructor is the same as the name of the class- A constructor, even though it is a method, has no type- A class can have more than one constructor; all constructors

of a class have the same name- If a class has more than one constructor, any two constructors

must have different signatures- Constructors are automatically executed when a class object is

instantiated- If there are multiple constructors, which constructor executes

depends on the type of values passed to the class object when the class object is instantiated

• Default constructor is:- public Clock()

• Constructor with parameters is:- public Clock(int hours, int minutes, int seconds)

class Clock: Constructors

Unified Modeling Language Class Diagrams

Variable Declaration and Object Instantiation

• The general syntax for using the operator new is:

Clock myClock; Clock yourClock;

myClock = new Clock(); yourClock = new Clock(9, 35, 15);

Variable Declaration and Object Instantiation (continued)

Accessing Class Members• The syntax to access a data member of a class

object or method is:

• Example 8-1

myClock.setTime(5, 2, 30);myClock.printTime();yourClock.setTime(x, y, z);

if (myClock.equals(yourClock))...

Assignment Operator: A Precaution

myClock = yourClock;

• Copies the value of the reference variable yourClock into the reference variable myClock

- After this statement executes, both yourClock and myClock refer to the same object

• Shallow copying: two or more reference variables of the same type point to the same object

• Deep copying: each reference variable refers to its own object

Assignment Operator: A Precaution (continued)

Definitions of the Constructors and Methods of the class Clock

Definitions of the Constructors and Methods of the class Clock (continued)

Default Constructor

Constructor with Parameters

• public value-returning method• Takes no parameters• Returns address of a String object• Output using print, println, printf

methods• Default definition creates String with

name of object’s class name followed by hash code of object

The Method toString

Method toString: class Clock

The Copy Constructor

• Executes when an object is instantiated• Initialized using an existing object • Syntax

The Copy Constructor (continued)

The Modifier static• In the method heading, it specifies that the

method can be invoked by using the name of the class

• If used to declare data member, data member invoked by using the class name

• Static data members of class exist even when no object of class type is instantiated

• Static variables are initialized to their default values

• Example 8-5public class Illustrate{ private int x; private static int y; public static int count;

public Illustrate() { x = 0; }

public Illustrate(int a) { x = a; }

Static Members of a Class

void setX(int a) {

x = a; }

public String toString() {

return("x = " + x + ", y = " + y + ", count = " + count); }

public static void incrementY() {

y++; }}

Illustrate illusObject = new Illustrate();Illustrate.incrementY();Illustrate.count++;

Static Members of a Class (continued)

Illustrate illusObject1 = new Illustrate(3); Illustrate illusObject2 = new Illustrate(5);

Illustrate.incrementY();Illustrate.count++;

Finalizers

• Automatically execute when class object goes out of scope

• Have no parameters

• Only one finalizer per class

• Name of finalizer: finalize

Accessor and Mutator Methods

• Accessor Method: a method of a class that only accesses (that is, does not modify) the value(s) of the data member(s)

• Mutator Method: a method of a class that modifies the value of one or more data member(s)

• Before moving to the design phase, a problem must be thoroughly understood so that the focus is on solving the problem.

• Once a class is designed, it must be properly documented. • In order to design the class Clock, first we identified the operations

and determined that each operation must be implemented using a method.

• We then identified the data members and their types. • We also identified which member should be public and which

should be private. • An algorithm must be designed and documented to implement a

method. • Describing the algorithm is not as important as the clarity of the

algorithm.

• You can write the Java code of the class Clock using this specification.

• You can also specify the design of a class as it is shown in the programming example, Candy Machine, of this chapter.

• To become an effective and a good programmer, you must avoid the temptation to skip the design phase.

• It is possible that the first few programs that you write can be coded directly.

• In general, this approach works only for very small programs. • You will spend less time in implementing, debugging, and

maintaining a code that is properly designed and documented.

The Reference this

• Refers to instance variables and methods of a class

• Used to implement cascaded method calls

Inner Classes

• Defined within other classes

• Can be either a complete class definition or anonymous inner class definition

• Used to handle events

Abstract Data Types

• Definition- A data type that specifies the logical properties without the implementation details

Programming Example: Candy Machine (Problem Statement)

• A new candy machine is bought for the gym, but it is not working properly

-The machine sells candies, chips, gum, and cookies • Write a two-part program to create a Java application program for this candy machine so that it can be put into operation

- In the first part, design a non-GUI application program- In the second part, design an application program that will create a GUI as described in the second part

Programming Example: Candy Machine (Problem Statement)

(continued)• The non-GUI application program should

do the following:1. Show the customer the different products sold by

the candy machine2. Let the customer make the selection3. Show the customer the cost of the item selected4. Accept money from the customer5. Release the item

Programming Example: Candy Machine (Input and Output)

• Input: the item selection and the cost of the item

• Output: the selected item

Programming Example: Candy Machine

• Components– Cash register– Dispenser– Machine

Programming Example: Candy Machine (continued)

Chapter Summary

• Creating classes• Members of a class

– private– protected– public– static

• Implementing classes• Various operations on classes

• Constructors

• Finalizers

• Method toString• Abstract data types

java introduction chapter 1 overview 1. 2 chapter objectives examine how a java program is processed...

Documents

java: chapter 3 methods

installing devpartner java edition - micro focus€¦ ·...

1 microbiology of thermally processed foods chapter 2

java 2 chapter 10 - basic oop in java

java chapter 15

introduction & the java virtual machine small java chapter 1

chapter 6. java threads

chapter 2 first java programs fundamentals of java

java chapter 1 review

chapter 7: starting java

chapter 7_inheritance in java

chapter 2 introduction to java applications · chapter 2...

java 2d: graphics in chapter java 2

chapter 01 - java programming

java: chapter 1 introduction

the java programming language - uniwersytet...

java chapter 16

introduction to java chapter 8 - introduction to java...

java chapter 1 - psis

java, java, java object oriented problem solving chapter 13:...