chapter 3 data types, arithmetic and arrays

Chapter 3 Data Types, Arithmetic and

Arrays

Foundational Java Key Elements and Practical Programming

1 Foundational Java by David Parsons © 2012

Data Types

• Java has two groups of data types:

– Primitive

• integer, floating point, character, boolean

– Reference

• array, class, interface


Primitive Types

• All primitive type names are lower case

• Integers (all signed) – byte (8-bit) short (16-bit)

– int (32-bit) long (64-bit)

• Real Numbers (signed) – float (32 bit) double (64 bit)

• Other – boolean true & false only

– char 16-bit Unicode


Literals

• Literals

– ‘Immutable’ values

– Fixed when the program starts running

4

10 // an int

45.5 // a double

true // a boolean

'a' // a char

"string" // a String (not a primitive type)

Foundational Java by David Parsons © 2012

Variables

• Variables

– We give variables names to create and use them

– Have a type

– Have storage allocated to at runtime

– Can contain changing values


Naming and Declaration

• Naming Conventions

– Variables use Camel (caMel) case

– start with a lower case letter, embedded words begin with upper case, no under_scores

• Variable declaration and assignment

– Local variables must be given an initial value when they are declared

6

int intValue = 3; // declare and assign intValue

intValue = 5; // reassign intValue

int anotherIntValue = intValue; // assign one variable to the value of another


Literal Number Types • A literal whole number is assumed by the compiler to

be an int

• This literal is too large to fit into an ‘int’ variable:

• Change the type of the variable from ‘int’ to ‘long’ • Add an ‘L’ to the end of the literal so the compiler will

treat it as a long data type rather than an int

• A similar situation occurs with floating point numbers – use a letter suffix to change the type of the literal

7

double d = 3.5; // double is default floating point

float f = 4.56F; // will compile - F or f = float

int myNumber = 9; // int is default integral

int myBigNumber = 2147483648; // won’t compile

long myBigNumber = 2147483648L; // will compile


Boolean Variables

• boolean variables are very simple

• They can only have the values ‘true’ or ‘false’ (must be in lower case)

• These values can be assigned as literals

• They can also be assigned the result of an expression that returns a boolean value

8

// assigning booleans

boolean isFull = true;

isFull = false;


Unicode Characters

• A char variable can hold a single 16 bit Unicode character

• Can be assigned to a literal in single quotes

• Can alternatively be assigned the Unicode value of the character (up to 65535)

9

// assign the literal character ‘c' to a char variable

char myChar = ‘c';

// assign the Unicode value of ‘c’ (99)

char myOtherChar = 99;


Escape Sequences • Represent special, often non-printable

characters

• May appear in any character or String literal

10

// assign the tab escape sequence character

char tab = '\t‘;

// embed quotes in a String literal

String quotation = "Java is C++ \"without the guns, clubs and knives\"";

Backspace \b horizontal tab \t

single quote \' double quote \"

new line \n carriage return \r

form feed \f backslash \\

octal Unicode

character value

\xxx hexadecimal Unicode

character value

\uxxxx


Scope • The scope of a variable is its code block, defined

within braces {…}

• Variables can’t be used in code until after declaration

• Declare as close to point of first use as possible

11

{

int myVariable = 3; // can use ‘myVariable’ now

} // ‘myVariable’ is now out of scope and can’t be used

int myVariable = 0;

{

myVariable = 3; // can use ‘myVariable’ now

} // ‘myVariable’ is still in scope and can be used


Exercise 3.1 • Use the example class provided in the exercise files • It contains a number of deliberate errors relating to

literals and scope • Fix these errors by applying your knowledge of the

various concepts that have been introduced so far in this chapter

• The method contains some braces that serve no useful function, they are simply there to enable you to demonstrate your understanding of scope

• In making your changes do not change any of the data types, change only the values or the way they are expressed

Foundational Java by David Parsons © 2012 12

Arithmetic Operators • add + subtract - • multiply * divide / • remainder % • Variable on the left of an assignment (=) operator

equals the result of an arithmetic expression on the right:

• Expression is a combination of operators and operands (variables or literals)

13

variable = expression;

double netPay = grossPay – deductions;

double distanceInKm = distanceInMiles * 1.6093;

int perimeter= height * 2 + width * 2;

int numberoOfGroupsofFour = classSize / 4;

int studentsNotInGroupOfFour = classSize % 4; Foundational Java by David Parsons © 2012

Order of Precedence

• Multiply, divide and modulus have precedence over addition and subtraction

• Use parentheses to change precedence

• operators of the same are evaluated from left to right

14

int result = (4 + 2) * 3; // result is 18

int result = 10 * 3 / 2; // result is 15

int result = 4 + 2 * 3; // result is 10


Remainder Operator

• The remainder operator returns the remainder from a division

• If the value if ‘classSize’ was 22, the result of the division would be 4, but the result for the remainder would be 2

• An integer remainder is usually known as a ‘modulus’, but since we can also use this operator with floating-point data types it is not strictly speaking a modulus operator

15

int numberOfGroupsofFour = classSize / 4;

int studentsNotInGroupOfFour = classSize % 4;


Increment and Decrement Operators

• Add 1 to, or take 1 away from, the value of the variable

• This is simply a shorthand for

• Similarly…

• Is a shorthand version of

16

counter = counter + 1;

counter = counter + 1;

counter++ // increments ‘counter’ by 1

counter-- // decrements ‘counter’ by 1


Prefix and Postfix Operators

• Postfix notation: counter++ or counter--

• Prefix notation: ++counter or --counter • Prefix and postfix notations have a different

order of precedence in expressions – Prefix

– Postfix

• Safer not to embed them in larger expressions

17

int counter = 1;

int currentCount = counter++; // currentCount = 1

int counter = 1;

int currentCount = ++counter; // currentCount = 2;


Shorthand Assignment Operators

• We also have shorthand for assignment operators with arithmetic

• In this syntax outline, ‘?’ means any one of the five arithmetic operators: – In general terms: var = var ? n

– can be replaced with: var ?= n

• For example…

18

myVariable = myVariable + 2; is equivalent to myVariable += 2;

myVariable = myVariable - 2; is equivalent to myVariable -= 2;

myVariable = myVariable * 2; is equivalent to myVariable *= 2;

myVariable = myVariable / 2; is equivalent to myVariable /= 2;

myVariable = myVariable % 2; is equivalent to myVariable %= 2;


Promotion

• Mixed Type Calculations (promotion)

• The narrower type operand is converted to the broader type automatically

int * long int becomes long

float * double float becomes double

int * double int becomes double

• Useful to know about, even though it is automatic


Type Casting

• Explicit Conversion (casting)

• Where conversion is otherwise not allowed or not automatic

• e.g. a double value that we want to convert to a float

• Useful technique for objects as well as primitives

20

float floatValue = (float)doubleValue;

(type we want) value we’ve got


String Concatenation

• Strings can be concatenated with values of other types using the ‘+’ operator

– Primitives or objects

– Primitives are automatically converted to Strings

• You can also use the ‘+=’ operator

21

int myVariable = 99;

System.out.println("The value of myVariable is " + myVariable);

// prints "The value of myVariable is 99”

String greeting = ″Hello ″

String message = greeting += ″Mr. President″;

System.out.println(greeting);


Concatenation v. Addition

• String concatenation uses the ‘+’ operator in a different way to how it is used in arithmetic

• It only concatenates when at least one String is in an expression.

• e.g. ‘+’ operator with char data types:

• Contrast with first character as a String (double quotes)

22

System.out.println(″a″ + ′b′ + ′c′); // prints abc

System.out.println(′a′ + ′b′ + ′c′); // prints 294 (97 + 98 + 99)


Exercise 3.2

• Create a class with a main method

• In the main method, calculate the fuel consumption of a car that just cost §72 to fill up at §1.80 a litre after going 390 km since it was last filled with fuel

• Display the number of kilometres travelled per litre


Arrays

• An array is a indexed collection

– It can contain primitive types or objects

• Type and size is specified when the array is declared

• Bounds-checked

– An exception occurs at runtime if index is invalid

• Efficient storage but cannot be dynamically resized


Declaring Arrays • An array reference is declared by putting empty square

brackets after the name of the data type • e.g. declare a reference to an array to store values of

type int • Arrays are reference types not primitives • Declaring the reference does not create the array • Arrays are created by using the keyword ‘new’,

followed by the data type and size of the array in square brackets

• e.g. create an array that can hold three int values:

25

;

int[] myArray;

myArray = new int[3];


Declaring an Array • Can declare the reference and create the array together

• Array indexes start at zero • This array has three elements:

– myArray[0] – myArray[1] – myArray[2]

• no myArray[3]!

• Values in an array will have a default value – Each int value in ‘myArray’ will be initialised to zero

26

int[] myArray = new int[3];

0 1 2 3

int[]myArray = new int[3];

// creates an array of type int with 3elements

// array contains {0,0,0} Foundational Java by David Parsons © 2012

Assigning Values

• We can assign values to the array elements using index numbers in brackets

• For example this array will contain integer values representing the average monthly rainfall in millimetres in Auckland, New Zealand from January to December:

27

int[] monthlyRainfall = new int[12];

monthlyRainfall[0] = 74;



//etc…


Initializer Blocks • Assigning values individually can be tedious • Alternative is to use an initializer block

– Assign a new array reference to a number of comma-separated values surrounded by braces

• e.g. example this array is initialized with twelve integer values representing the average monthly rainfall in millimetres in Auckland, new Zealand from January to December:

• Array size based on number of values provided – 12 in this example

• An initializer can only be used with a newly declared array reference

28

int[] monthlyRainfall = {74,81,86,93,100,116,126,111,93,80,84,91};


Accessing Array Data

• The data in an array element can be updated or retrieved using the index number – Update the last element of the rainfall array

– retrieve a value from an element

– include an element in output

• • Using an index number which is out of range will

lead to a run time exception

29


int augustRainfall = monthlylRainfall[7];

System.out.println(″March rainfall was ″ + monthlyRainfall[2]);

monthlyRainfall[12] = 92; // exception at run time


Arrays are Typed • Arrays can only store values of the type specified by

the reference

• Types are checked at compile time

• e.g. cannot assign a double to an element of int array

30

monthlyRainfall[0] = 74.3; // compiler error!

can’t assign a double to an int


The length Field • Arrays have a public length field

• Useful to know to help avoid going beyond the bounds of the array

• Can be used to control a loop

31

System.out.println(monthlyRainfall.length); // '12' printed in console


Multidimensional Arrays • Java also supports multidimensional arrays,

declared using multiple pairs of brackets

• This code relates to a two dimensional array that contains two names for each month in the year (short and long versions)

32

String[][] monthNames = new String[12][2];

monthNames[0][0] = "Jan";

monthNames[0][1] = "January";

monthNames[1][0] = "Feb";

…

monthNames[11][1] = "December";


Exercise 3.3 • This exercise converts distances expressed in Kilometers to

their equivalents in miles and nautical miles – One kilometer equals .62 miles and .54 nautical miles.

• Create a new class with a ‘main’ method • In ‘main’ create and initialize an array of type ‘double’

containing the values .62 and .54 (representing the conversion multipliers.)

• Create and initialize an array of type ‘int’ containing the values 2, 5 and 10 (representing distances in kilometers)

• For each element in the integer array, calculate and display the equivalent distances in miles and nautical miles – Use String concatenation to add text labels to make the output

understandable


Exercise • Create a new class with a ‘main’ method • Create and initialise an array of type ‘double’

containing the values .62 and .54 (representing the conversion multipliers from Kms to miles and nautical miles)

• Create and initialise an array of type ‘int’ containing the values 2, 5 and 10 (representing distances in kilometers)

• For each element in the integer array, calculate and display the equivalent distances in miles and nautical miles. Use String concatenation to add text labels to make the output understandable.


chapter 3 data types, arithmetic and arrays

Documents