AP Computer Science - Data Types & Variables

Learning Objectives:

Identify the most appropriate data type category for a particular specification.
Declare variables of the correct types to represent primitive data.
Evaluate arithmetic expressions in a program code.
Evaluate what is stored in a variable as a result of an expression with an assignment statement.
Evaluate arithmetic expressions that use casting.

Essential Knowledge:

System.out.println
displays information on the computer monitor.
A
(data)
type is a set of values
(a domain)
and a set of operations on them.
Data types can be categorized as primitive.
The primitive data types used in this course define the set of operations for numbers and
boolean
values.
The three primitive data types used in this course are
int
,
double
, and
boolean
.
Each variable has associated memory that is used to hold its value.
The memory associated with a variable of a primitive type holds an actual primitive value.
When a variable is declared
final
, its value cannot be changed once it is initialized.
A literal is the source code representation of a fixed value.
Arithmetic expressions include expressions of type
int
and
double
.
The arithmetic operators consist of
+
,
-
,
*
,
/
, and
%
.
An arithmetic operation that uses two
int
values will evaluate to an
int
value.
An arithmetic operation that uses two
double
values will evaluate to an
double
value.
Operators can be used to construct compound expressions.
During evaluation, operands are associated with operators according to operator precedence to determine how they are grouped.
An attempt to divide an integer by zero will result in an
ArithmeticException
to occur.
The assignment operator (
=
) allows a program to initialize or change the value stored in a variable. The value of the expression on the right is stored in the variable on the left.
During execution, expressions are evaluated to produce a single value.
The value of an expression has a type based on the evaluation of the expression.
Compound assignment operators (
+=
,
-=
,
*=
,
/=
,
%=
) can be used in place of the assignment operator.
The casting operators (
int
) and (
double
) can be used to create a temporary value converted to a different data type.
Casting a
double
value to an
int
causes the digits to the right of the decimal point to be truncated.
Some programming code causes
int
values to be automatically cast (widened) to
double
values.
Values of type
double
can be rounded to the nearest integer by
(int)(x + 0.5)
or
(int)(x - 0.5)
for negative numbers.

Identifier/Variables

A name made up by the programmer to identify and reserve the address in memory where a particular piece of data is stored.
- Basically like how we use algebra in maths
  (letters that represent values in equations)
  .
  - But we can also use words
    (as well as letters)
    in programs and we can have "text" or other values
    (as well as numerical values)
    .
- When a program runs, any data that it uses is stored in RAM.
  - If a variable name is not used, then the location is not reserved, so data can be overwritten at any time and lost.
    - Similar to reserving a table at a restaurant.
An identifier/variable is a name made up by the programmer to identify the address in RAM where a particular piece of data is stored.

Data Type

Defines the values that a variable can take.
- Data consists of bit (1 or 0) patterns.
- The data type tells the program and in turn, the computer, the "meaning" of the data, so it knows how to process the data.
- The computer needs to be told how to process each bit pattern
  (what it "means")
  .
- Different kinds of values require different amounts of memory and are stored in different ways.
Based on the data type of a variable, the operating system (OS) allocates memory and decides what can be stored in the reserved memory.

Data Type Sizes

When humans write a number we think of the space that a small number takes up as being less than a large one.

e.g. 1 is shorter and takes up less space than 100,000.

When we want to write a large number we make sure there is more "space" available than for a small number.

We have problems when we want to change a small number to a large one and there is not enough "space" to write it.

Computers can't do this and reserve a certain amount of "space" for every number of a certain data type so small and large numbers all take up the same amount of space.

Leading 0's are added to the left, e.g. 00000001 = 1.

Larger ranges or more decimal points need more bits so more space.

Data Types in Java

2 categories of data type in Java:

Primitive data types:

We will look at these data types here.

Non-primitive data types:

Arrays and Strings are non-primitive data types, we will discuss them in much later topics
(from 7. Strings onwards

.

int

short for integer, which are all positive and negative numbers, including zero.
4 bytes
The int data type only allows values between -2,147,483,648 and 2,147,483,647
(approx. +2 billion to -2 billion)
.

double

Sufficient for holding 15 decimal digits.
8 bytes

Range: -1.7E308 to 1.7E308

E = "ten to the power of"

When writing numbers as double it is suggested that, even for whole numbers, you always use a decimal point or write
D
on the end.

e.g.
12.0
or
12D

If you only write 12 then Javac will convert from
int
to
double
for you
(i.e. from 12 -> 12.0)
as this is a safe conversion.

boolean

Can only be either true or false.
1 byte

Other primitive data types not on your syllabus:

char

Short for character and is used to represent a single character
(includes all symbols on a keyboard)
.
2 bytes in Java
(to enable Unicode representation - see the Conversion topic)
.
All char values must be enclosed in single quotes, e.g. 'G'.

byte

Can hold whole number between -128 and 127
(2 bytes)
.
Mostly used to save memory and when you are certain that the numbers would be in the limit specified by the byte data type.

short

Greater than byte in terms of size and less than
int

(2 bytes)
.
Its range is -32,768 to 32767.

long

Used when int is not large enough to hold the value, it has wider range than
int
data type, ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
(8 bytes)
.
Always suffix float values with the "
L
" otherwise Javac will consider it as an
int
.

e.g.
928389283L
.

float

Sufficient for holding 6 to 7 decimal digits
(range: +3.4E38 to -3.4E38, 4 bytes = less range and accuracy than
double
but consequently uses less storage space)
.
Always suffix float values with the "
F
" otherwise Javac will consider it as a
double
.

e.g.
22.4F
.

Variable naming convention in Java

Should begin with a lower case letter and for multiple words use a capital from the 2nd word to begin each word
(as no spaces are allowed, this helps make the name more readable)
:

e.g.
number
,
smallNumber
,
bigNumber

Note that variable names are case sensitive.

So
smallNumber
and
smallnumber
will be considered as different variables in Java.

How to declare a variable in Java

Java is a statically typed language
(unlike Python for example)
.

Means that the data type of a variable must be declared
(made known)
at compile time.

To declare a variable follow this syntax:
data_type variableName
;

e.g.
int num;

Types of Operator in Java

Basic Arithmetic Operators
Assignment Operators
Unary +, -
Relational
(comparison)
operators
Logical Operators
(including Unary !)
Unary Auto-increment & Auto-decrement Operators
Concatenation
Bitwise Operators
Ternary Operator

We will cover types 1 - 3 here.

1. Basic Arithmetic Operators

+
,
-
,
*
,
/
,
%

+
is for addition.
-
is for subtraction.
*
is for multiplication.
/
is for division.
%
is for modulo.

Note: Modulo operator returns remainder.

e.g.

10 % 5
=
0
15 % 6
=
3

Arithmetic Operator Precedence Rules

Start with anything inside brackets, going from left to right.
Do anything involving a power or a square root next
(these are also known as orders)
, again working from left to right if there is more than one.
Multiplication and division rank equally, so you go from left to right in the sum, doing each operation in the order in which it appears.
Again, subtraction and addition rank equally, and you simply move from left to right.

2. Assignment Operators

=
,
+=
,
-=
,
*=
,
/=
,
%=
num2 = num1

Assigns the value of variable num1 to the variable num2.
In programming "
=
" means "assign".

It does not mean "it is equal" it means "make it equal".

Left Side -> Right Side

(make it equal to)

num2 += num1
equivalent to
num2 = num2 + num1
num2 -= num1
equivalent to
num2 = num2 - num1
num2 *= num1
equivalent to
num2 = num2 * num1
num2 /= num1
equivalent to
num2 = num2 / num1
num2 %= num1
equivalent to
num2 = num2 % num1

Operand

An item of data being operated on.

e.g. in the following expression:
6 + 7
, the operands are
6
&
7
.

3. Unary Operators

Operators which only work on one operand
(a single input)
.

int a = 5; // a is 5
int b = -a; // b is -5
int c = -b; // c is +5

- doesn't necessarily make an operand have a negative value. Instead, it changes whatever sign the operand has to start with
(e.g. --a = +a)
.

int a = -5; // a is -5
int b = +a; // b is -5

+
doesn't actually do anything.

If a starts out positive, +a is also positive but if a starts out negative, +a is still negative.
Java only provides the + operator out of a need for balance only, but it isn't actually useful.

Literals

Fixed values.

e.g.
10
,
"ABC"

Assign a value to a variable

In other words "tell the computer what to remember".
You assign a value to a variable either:

On a new line after the declaration:

variable_name
=
literal value
;

e.g.
num = 10;

Or at the end of the declaration line:

data_type variable_name
=
literal value
;

e.g.
int num = 10; // This is actually the safest way - see "Local Variables" later for details.

When a variable is assigned a value for the 1st time, the variable is said to be initialised.

Variable Declaration Variations

datatype variableName;

Declares a variable & data type, and reserves memory for it.

It says nothing about what value is put in memory.

datatype variableName = initialValue;

Declares a variable & data type, reserves memory for it, and puts an initial value into that memory.

datatype variableNameOne, variableNameTwo, ... ;

Declares multiple variables, all of the same data type, reserves memory for each, but puts nothing in any variable.

datatype variableNameOne = initialValueOne, variableNameTwo = initialValueTwo, ... ;

Declares multiple variables, all of the same data type, reserves memory for each, and puts an initial value in each variable.

Variable naming "rules" in Java

Try discovering these rules for yourself by making up and trying some variable names.

e.g.
int
... (varName)

Then try to compile or execute.
If there are errors then the variable name is invalid, if not then the variable name is obviously valid.

Primitive data types in Java

The most basic data types available within the Java language.

Primitive = "a fundamental component that is used to create other, larger parts."

Can only store 1 basic value of a specific kind.
Cannot be broken down into simpler data types.
Fixed memory sizes.
Use little memory & fast to process.
Directly contains the value of its type.

If you visit its memory location you will find the value of the variable.

This may not be particularly surprising at the moment but it becomes important after you cover topic 10.

int

Division

Integer division occurs if there is an integer on both sides of
/
.

The result of integer division is an integer.

Integer division determines how many times one integer goes into another.
The remainder after integer division is simply dropped/the decimal part is truncated
(cut off)
.

7/4
=
1
12/5
=
2
1/2 + 1/2
=
0
-3/4
=
0

Integer arithmetic can be used in some parts of an expression and not in others, even though the final value of the expression is double.

1.5 + 7/2
=
1.5 + 3 = 4.5

double

division

Double division occurs if there is an double number on at least 1 side of /

You can do this to "force" "correct" division.

11.0/5
=
2.2
1.0/2.0
=
0.5
12/5.0
=
2.4
int x = 11, y = 5;
x/y
=
2

However, if we have variables instead of literals
(fixed values)
, how can we "force" "correct" double division then?

Answer: See below.

Conversion between primitive data types

There are two ways in which values of 1 data type can be converted into another data type:

Implicitly - possible for automatic "safe" conversions.
Explicitly - the programmer asks for values to be converted with a type cast
(necessary for non-automatic "unsafe" conversions but also useful for "safe" conversions - see later)

.

Safe / Automatic / Widening Conversions

If the data types are compatible and JAVAC can make the conversion without loss of information, it will automatically do so.

e.g.
int
->
double

int a = 123456789;

double x = a; // Is allowed. ✔

Unsafe / Non-automatic / Narrowing Conversions

If the data types are compatible and JAVAC cannot make the conversion without a loss of information then a type cast has to be made
(basically meaning the programmer must specifically ask for the conversion)
.

e.g.
double
->
int

double x = 11.0;

int a = x; // Is NOT allowed! ❌

/*

A type cast looks like this:

(requiredType) variable

Basically TypeCasting means:

"treat this variable as a (... data type) even

if it was declared as some other data type".

*/

int a = (int)x; // Is allowed. ✔

x = (double)a;

/* Type-casting is recommended even

for safe conversions, as it makes

it clear what is happening. */

 boolean 

Is incompatible for converting into any other primitive data type.

That is, a boolean value cannot be converted into any other data type like
int
,
double
, etc....

double

division with variables

So to return to our earlier question:

int x = 11, y = 5;
x/y
=
2

How can we "force" double
("correct")
division with two integer variables?
(double) x/y = 2.2;
Will these ways also work? Why?

(double)(x / y)

No, as integer division has already occurred before the type cast is performed (you would get 2.0 instead of 2 though, but this is still not double division).

x / (double)y

Yes, this works as even though
x
has not been type casted into a
double
,
y
has.

(double)x / (double)y

Yes, as both sides of the division have been type casted into
double
s, however, type casting of both sides is not necessary and is arguably "overkill".

Can we "force" double ("correct") division using safe conversions instead of type casting?

More Practice:

13/5
=
2

How can we force double division above?

13.0/5
= 2.6
or
13/5.0
= 2.6
or

int x = 13, y = 5;
x/y
=
2

How can we force double division above?

(double) x/y
= 2.6
or
x/(double) y
= 2.6
or

Will these compile? If so, what will happen?

int x = 6, int y = 5;

double z = x/y;
// Will compile ✔ but z =
1.0

double z = (double)x/y;
// Will compile ✔ and z =
1.2

// Assume any one the declarations of z above.

y = z;
// Will NOT compile because double -> int is “unsafe”! ❌

y = (int)z;
// Will compile ✔ but y =
1 (no matter which one of the z declarations above are used).

Type Casting Effects

Please note that type casting a variable does not actually change the value stored in the variable, it only changes the way the value is handled by Javac.

int x = 6, int y = 5;

double z = (double)x/y;

What are the values in z, x & y?

How to round

(without the round() function which is not on your syllabus!)

Using "truncation towards 0" behaviour positive floating-point numbers
(e.g.
double x
)
can be rounded to the nearest integer as
(int)(x + 0.5)
, negative numbers as
(int)(x - 0.5)
.

e.g.

double x = 2.2;

int xRounded = (int)(x + 0.5);

System.out.println(xRounded);

// 2.2 + 0.5 = 2.7 truncates to 2

double x = 2.6;

int xRounded = (int)(x + 0.5);

System.out.println(xRounded);

// 2.6 + 0.5 = 3.1 truncates to 3

Operator Precedence / Ranking

Local Variables

All variables declared inside methods of a class.

At the moment we have only looked at the
main()
method and we will continue to do so for a while, so this will probably not mean much to you at the moment.

Therefore, all the variables you will declare up until we start looking at true OOP concepts, will be local ones.

/*

All local variables must be given a value at some point during a program

otherwise you will receive a "variable might not have been initialized"

error if and when you try to access it

- this is the most important point at this stage.

Will the following code sections compile?

*/

int x;

.....

System.out.println(x);

int x;

.....

x = 0;

int x = 0;

.....

Exception

An unwanted event that interrupts the normal flow of the program.

System generated error message.
Terminates program execution.

Arithmetic exception

Java.lang.ArithmeticException

A built-in-class present in the java.lang package.

This point may not make much sense to you at the moment though.

This exception occurs when a program attempts:

To divide by zero or square root a negative number.

The message will look like this:

Exception in thread "main" java.lang.ArithmeticException: / by zero at
ClassName.methodName ... at line ...

Compile Time Vs Run Time Errors

Debugging

The process of determining and fixing bugs or errors present in your code.

Manually Tracing / White Box Testing

Fill in a table with variable values as you manually read each code line.

Column headings are the program's variable names.
Also the 1st a column can be for line numbers and last column for output.

This is strongly encouraged as it is only the possible way in exams.

A quick way to get a table is to use a spreadsheet e.g. Excel.

Line	FirstNumber	SecondNumber	Total
05	10
06		12
07			22
09			22
...	...	...	...
...	...	...	...

Black Box Testing

Use of different input values to determine whether the program gives you expected results
(compare actual results with expected ones)
and can cope with them without crashing.

Tracing / White Box Testing Example

A program is written to output the value of the following expression:

area /(spaceWidth * spaceLength - emptySpaces)

int area = 0, spaceWidth, spaceLength, emptySpaces; // line 03

System.out.println(area /(spaceWidth * spaceLength - emptySpaces));

However, when the following values are used the code above produces an Arithmetic exception so lets try a white box test.

spaceWidth <-- 7
spaceLength <-- 4
emptySpaces <-- 28

Line	area	spaceWidth	spaceLength	emptySpaces	spaceWidth * spaceLength - emptySpaces
03	10	7	4	28
04					0

The value 0 tells us what?

Other Possible Tracing / White Box Testing Methods

Add
System.out.println(var);
lines in multiple key locations places
(of your choice)
to print out variable values.

e.g. If you want to trace a variable named x add:

System.out.println(x);
// Add this line multiple times at key locations to see the value of x on these lines.

int area = 0, spaceWidth, spaceLength, emptySpaces; // line 03

System.out.println(area);

System.out.println(spaceWidth);

System.out.println(spaceLength);

System.out.println(emptySpaces);

System.out.println(spaceWidth * spaceLength - emptySpaces);

System.out.println(area /(spaceWidth * spaceLength - emptySpaces));

Use animated or other compilers that have variable tracing features.

e.g. Jeliot or Eclipse

Cannot be done in exams as you will handwrite code.

User Input

User input is not included in the AP Java subset.

There are many possible ways for supplying user input: e.g., by reading from a Scanner, reading from a stream
(such as a file or a URL)
, or from a dialog box.

The exam does not prescribe any one approach.
Instead, if reading input is necessary, it will be indicated in a way similar to the following:

double x = /* call to a method that reads a floating point number */;
Or:
double x = ...; // read user input

/*

I will be using the latter 2nd way for basically the whole course

i.e. declare a variable as if the program is going to ask for user input

BUT instead, the 'input value' will be set directly and "hard-wired" into the code.

/*

// e.g.

int numInput1 = 6;

/* Simulates a program asking the user to enter a number, they

entering 6 and the program storing it in a variable 'numInput'. */

Writing your own programs:

Of course you should use previous programs for reference, but write your code from "scratch"
(do not copy and paste)
.
All your programs MUST have meaningful variable names not x, y, etc...

You may complain that I occasionally use these kinds of names but whenever I have, there was no context, they were just random lines of code used for concept demonstration.

If there is context within a purposeful program I also should use meaningful variable names.
As an additional point to prove the need for meaningful variable names exams love to use non-meaningful variable names just to make things complicated.
Although you may complain that writing meaningful variable names "wastes" time, you will save time in the long run as debugging time will be reduced, if not eliminated.

Please NEVER use concepts or functions that are not on your syllabus.

If I haven't shown you something then this almost always means it is not on your syllabus so you should not use it.

However, for various reasons, there will be a few occasions where I will not introduce certain concepts or functions that may be useful until later on the course. In these circumstances I will accept if you use them earlier than I introduce them but only if they are actually on your syllabus.

In a real exam you are allowed to use things that are not on your syllabus, as long as they work, however, this is not recommended as mark schemes and readers may not recognise code that is not on your syllabus and as far as this course is concerned I personally will not accept concepts or functions that are not on your syllabus.

I also believe that not using advanced functions is more "pure" programming and gives you a clearer overall understanding of programming, particularly at this early stage.

Finally look out for any requirements to write comments, if you don't write any comments when requested, you will lose marks. You have been warned!

1. Average

Write a program to calculate the average of a set of integer numbers.

Make sure it gives the "correct"
double
average.

Calculate the average in 2 ways:

With literals only without type casting and state "literals without type casting" in a comment for this line.
With only variables
(no int or double literals)
with type casting and state "only variables with type casting" in a comment for this line.

2. Mini-Calculator

Add, subtract, multiply, divide and modulo any two integer variables.

Show:

int
division with only variables.
double
division with only variables and type casting.

Try dividing by zero and find out what happens.

Write the following as comments:

Name the 2 categories of errors and describe them.
Name the errors that could occur in this program and give sample code for each.
Name the exception that is possible here and what causes it.

3. Melon Packing Plant

Raul writes software for a melon packing plant.
Raul has Y melons which are to be packed into boxes.
Each box contains X melons.

Write a program to accept:

How many melons are to be packed.
How many melons each box contains.

And then calculates:

The number of boxes as a decimal.
The number of full boxes.
The number of melons not in a full box.

In a comment for this line state the name of the operator used to calculate this and explain what it does.

The number of boxes needed rounded up to the next integer
(note please do not use a round function or any
if
statements)
.

4. Round

Round a double variable to the nearest integer.

For hints on how to do this see "How to round".

In a comment for this line explain how computers round both positive and negative numbers.
Please do not use a round function or any
if
statements.

5. ASCII

Find the ASCII code of a character.

asciitable.com

Use both of the following methods:

By assigning a character to an int variable.
By type casting character value as (
int

).

AP Computer Science A

- Data Types & Variables

System.out.println

boolean

int

double

boolean

final

int

double

+

-

*

/

%

int

int

double

double

ArithmeticException

=

+=

-=

*=

/=

%=

int

double

double

int

int

double

double

(int)(x + 0.5)

(int)(x - 0.5)

D

12.0

12D

int

double

char

byte

short

int

long

int

L

int

928389283L

float

double

F

double

22.4F

number

smallNumber

bigNumber

smallNumber

smallnumber

;

int num;

+

-

*

/

%

+

-

*

/

%

10 % 5

0

15 % 6

3

=

+=

-=

*=

/=