chapter 3 syntax, errors, and debugging - parkway … 3 syntax, errors, and debugging ... –...

Chapter 3Syntax, Errors, and Debugging

Fundamentals of Java

Fundamentals of Java 2

Objectives

Construct and use numeric and string literals.

Name and use variables and constants.

Create arithmetic expressions.

Understand the precedence of different

arithmetic operators.

Concatenate two strings or a number and a

string.


Objectives (cont.)

Know how and when to use comments in a

program.

Tell the difference between syntax errors,

run-time errors, and logic errors.

Insert output statements to debug a program.


Objectives (cont.)

Understand the difference between

Cartesian coordinates and screen

coordinates.

Work with color and text properties.


Vocabulary

Arithmetic expression

Comments

Coordinate system

Exception

Graphics context

Literal


Vocabulary (cont.)

Logic error

Origin

Package

Pseudocode

Reserved words

Run-time error


Vocabulary (cont.)

Screen coordinate system

Semantics

Syntax

Virus


Language Elements

Every language, including Java has:

– Vocabulary: Set of all of the words and

symbols in the language

– Syntax: Rules for combining words into

sentences (statements)

– Semantics: Rules for interpreting the meaning

of statements


Language Elements (cont.)

Table 3-1: Some Java vocabulary


Language Elements (cont.)

Programming vs. natural languages

– Programming languages have small

vocabularies and simple syntax and semantics.

– Programming language syntax must be

absolutely correct.

– Programming language statements are

interpreted literally.

Every detail must be present.


Basic Java Syntax and Semantics

Two categories of data types:

– 1. Primitive data types: Numbers, characters,

and Booleans

– 2. Objects – ex; Strings

Syntax for manipulating primitive data types

differs than for objects

– Primitive data types are combined in expressions

with operators.

– Objects are sent messages.

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/datatypes.html

12

Basic Java Syntax and Semantics (cont.)

Objects must be instantiated before use.

– Unlike primitives

– String objects are a little different; are objects & are sent messages, but don’t need to be instantiated before use.

Six numeric data types– int and double are most commonly used

Also short, long, byte, and float

– Each uses a different number of bytes for storage.

Each represents a different range of values.

Learn more later.

http://www.particle.kth.se/~lindsey/JavaCourse/Book/Part1/Java/Chapter03/instance.html

http://www.particle.kth.se/~lindsey/JavaCourse/Book/Part1/Java/Chapter03/instance.html




Table 3-2: Some Java numeric data types



Literals: Items whose values do not change.

– Examples the number 5.0 or the string “Java”

– Restricted to primitive data & strings.

Variable is a named location in memory.

– Changing a variable’s value is equivalent to

replacing the value at the memory location.

– A variable’s data type cannot change.


http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html



Figure 3-1: Changing the value of a variable



Variable declaration statement: Declares

the identifier and data type for a variable

– int age; (declares one int variable)

– int a, b, c; (declares three int variables)

– double d = 2.45; (declares and initializes

a variable)

– You can declare several variables in a single

declaration & simultaneously assign them initial

values

int x, y, z = 7;

double p, q = 1.41, pi = 3.14, t;

String name = “Bill Jones”;

Scanner reader = new Scanner(System.in);

Declares the object variable reader, instantiates or

creates a Scanner object that is attached to the

keyboard input stream, System.in, and finally assigns

the object to the object variable, reader.

http://www.boloji.com/java/j007.htm


Constants are variables whose value cannot

change.

– final double PI = 3.14;

– Customary to write the names of

constants in uppercase.


http://www.ryerson.ca/~dgrimsha/courses/cps840/variablesConstants.html



Assignment statements:

– <variable> = <expression>;

– Value of expression assigned to variable

Arithmetic expressions:

– Multiplication and division have higher

precedence than addition and subtraction.

– Operators of same precedence evaluated from

left to right.

– Parentheses are used to change evaluation order.

EXAMPLE:

double celsius, fahrenheit;

String name;

Scanner reader;

fahrenheit = reader.nextDouble();

celsius = (fahrenheit – 32.0) * 5.0/9.0;

name = “Bill Smith”;

reader = new Scanner(System.in);

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/expressions.html



Table 3-5: Common operators and their precedence



The semantics of division (/) differ for

integers and floating-point operators.

– int / int yields an int.

– double / double yields a double.

The modulus operator (%) yields a remainder.

– 11 % 3 yields 2.

EXAMPLES:

Division:

5.0/2.0 yields 2.5

5/2 yields 2

Modulus:

9 % 5 yields 4

9.3 % 5.1 yields 4.2



Table 3-6: Examples of expressions and their values



Arithmetic overflow: Assigning a value to a

variable that is outside of the ranges of

values that the data type can represent

Mixed-mode arithmetic: Expressions

involving integer and floating-point values

– Lower-precision data types (int) temporarily

converted to high-precision data types (double)



Type casting: Temporarily converting one

data type to another

– Can type cast a single variable or an entire

expression

– Place the desired data type within parentheses

before the variable or expression that will be

cast to another data type.

int x = (int)(d + 1.6);

int i;

double d;

i = (int)3.14; i equals 3, truncation toward 0

d = (double)5/4; d equals 1.25

http://www.javabeginner.com/java-object-type-casting.htm



String concatenation: Append a String or value to another String

– Use the + operator

– String s = “string1” + “string2”;

– String s2 = “String1” + intVariable1;

Escape character (\): Used in codes to

represent characters that cannot be directly typed into a program– “\t” is a tab character

http://www.java-samples.com/showtutorial.php?tutorialid=217

http://72.14.205.104/search?q=cache:Ykip6fziifsJ:www.ics.uci.edu/~stasio/winter06/Lectures/Dis2.ppt+Escape+character+and+java&hl=en&ct=clnk&cd=10&gl=us



The String class’s length method gives

the number of characters in a String.

Classes implement methods, and objects are

instances of classes.

– Objects can respond to a message only if their

class implements the method.

Must implement a method with a matching

signature

http://java.sun.com/mailers/techtips/corejava/2006/tt0822.html

http://java.sun.com/mailers/techtips/corejava/2006/tt0822.html



Method signature:

– Method name

– Number and data types of method parameters

Method and variable names are user

defined symbols.

– Cannot use Java keywords (reserved words)

Packages: Used to organize related classes

into a single unit for distribution



Table 3-7: Java’s reserved words


Terminal I/O for Different Data Types

Table 3-8: Methods in class Scanner


Terminal I/O for Different Data Types (cont.)

Example 3-1: Tests three types of input data


Comments

Explanatory sentences inserted in a program

Compiler ignores them

Purpose is to make program more readable

Two varieties:

– End of line comments: All text following a double slash (//) on a single line

– Multiline comments: All text occurring between a /* and a */


Comments (cont.)

Typical uses of comments:

– Begin a program with a statement of its purpose

– Explain the purpose of a variable declaration

– Explain the purpose of a major segment of code

– Explain the workings of complex or tricky

sections of code


Programming Errors

Three types of programming errors:

– Syntax errors: When a syntax rule is violated

Detected during compilation

Compiler helps identify error

– Run-time errors: Occurs during execution

Dividing by 0

Detected when program runs

JVM indicates type of error and location


Programming Errors (cont.)

Three types of programming errors (cont.):

– Logic errors (design errors or bugs):

Incorrect logic implemented in the program

Code may be correct in every other way, but

does not do what it is supposed to do.

Must thoroughly test and debug the program

when an error is found.

– Desk checking: Examine code immediately after

it is written


Debugging

One debugging method is to add extra lines

of code to print values of selected variables

at strategic points in the program.


Graphics and GUIs: Drawing Shapes and Text

Defining a specialized graphics panel: Define a new class that extends the JPanel class

– Inherits all of the properties and methods of a

JPanel, but can add additional instance

variables and methods


Graphics and GUIs: Drawing Shapes and Text (cont.)

Example 3.5: Empty color panel



Every graphics application uses a

coordinate system.

– Positions of items on a window specified in

terms of two-dimensional points

– Java uses the screen coordinate system:

The origin (point with coordinates (0,0)) located

at upper-left corner of a panel or frame

Every window, frame, or other type of window

has own coordinate system



Figure 3-7: Orientation of Java’s coordinate system



Graphics class: Used to draw on a panel

– Every panel maintains an instance of this class.

The graphics context

– Shapes drawn on a panel by the Graphics

class have a foreground color.

Change color via the setColor() method.



Table 3-9: Common method in the Graphics class



Table 3-9: Common method in the Graphics class (cont.)



Every panel instance has a paintComponent() method

– Called by the JVM when the panel needs to be

drawn on the screen

– Contains instructions for how to draw the panel

– For custom panels, can write own paintComponent() method, but must also

call the superclass’s paintComponent()

method



Example 3.6: Colored panel containing a red text message in a blue rectangle



Figure 3-8: Displaying a shape and text in a panel



The width and height of a panel can be found using the getWidth() and getHeight()

methods, respectively.

Font class: Information about a specific font

– Font name, size, and style

– Font font = new Font(“Arial”,

Font.BOLD, 10);


Summary

Use the int data type for whole numbers

and double for floating-point numbers.

Variable and method names consist of a

letter followed by additional letters or digits.

Keywords cannot be used as names.

Final variables behave as constants; their

values cannot change after they are

declared.


Summary (cont.)

Arithmetic expressions are evaluated

according to precedence.

Some expressions yield different results for

integer and floating-point operands.

Strings may be concatenated.

The compiler catches syntax errors.

The JVM catches run-time errors.


Summary (cont.)

Logic errors, if caught, are detected by the

programmer or user at run-time.

Can find and remove logic errors by inserting

debugging output statements to view the

values of variables.

The programmer can modify the color with

which images are drawn and the properties

of text fonts for a given graphics object.


Summary (cont.)

Java uses a screen coordinate system to

locate the positions of pixels in a window or

panel.

– Origin is the upper-left corner of the drawing

area.

– x and y axes increase to the right and

downward.

chapter 3 syntax, errors, and debugging - parkway … 3 syntax, errors, and debugging ... –...

Documents