Session 3 Lecture Notes for First Course in Java
course homepage      course calendar

Data types

A data type is the characteristic of a variable that determines what kind of data it can hold. Java is a strongly typed language because it requires that every variable and expression have a type. The Java compiler checks for type compatibility among the variables to which you assign values. The Java compiler alerts you of any type mismatch, and you have to fix it before your program will compile.

The output is:

The largest byte value is 127
The largest short value is 32767
The largest integer value is 2147483647
The largest long value is 9223372036854775807
The largest float value is 3.4028235E38
The largest double value is 1.7976931348623157E308
The character S is upper case.
The value of aBoolean is true

Variable Types - Primitives

A given variable is either a primitive (basic type) or an object. 
Each primitive data type has a range of values, which determines its size in memory

Sun's Java Tutorial contains a program that outputs the largest value of the primitive types.
http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

Integers

Whole numbers without decimals (no floating point).

Floating-point

Can be float or double.

Characters

Booleans

Copy by value versus copy by reference

Java stores each primitive type in a fixed amount of memory and Java directly manipulates the values for primitives. 
However, objects and arrays do not have a standard size, and they can become quite large. Therefore, Java manipulates these reference types by reference.

Although the reference types do not have a standard size, the references to reference types do have a standard size.

Reference types differ from primitives in the way values are copied and compared.

• When you work with a primitive data type, such as an integer, you are working directly with values and no Java object is involved. So the statement x = y actually copies the value of y into x. 
• When you work with reference types (objects), the variable does not contain the object.
  The variable is a reference to that object in memory. 
  So the statement x = y does not copy the object, but only copies the reference. 
  There is still only one object, but it now has two references. 

Variables, Constants, and Data Types

A variable is a name for a piece of memory that stores a value. Each variable must have a name. 

Unlike JavaScript and Visual Basic, Java is a strongly typed programming language.

Number are represented in memory using bits. A bit is the smallest unit that a computer can work with. A bit has two possible values, 0 or 1.
Everything in a computer is represented by bits.
A number is represented by a series of bits which represent different powers of 2.

An 8 bits number (byte):

• every variable must have a type
  • each type has a pre-defined range of values
  • each type has a pre-defined size in memory

Note: Java does not have explicit pointers. Instead, a variable references an object. When you make a change, you change the original object. However, when you work with a primitive data type, such as an integer, you are working directly with values.

Constant

A constant variable is a variable which is assigned a value once and cannot be changed afterward (during execution of the program). The compiler optimizes a constant for memory storage and performance.

Examples of constants

• the number pi (3.1415927...)
• the number of French francs in a Euro
• boiling point as 100 degree centigrade
• freezing point as 0 centigrade
• the value of the speed of light

Literals

A literal is different from a variable.
Whereas a variable is name (or reference) for a storage area for a value that can change, a literal is the direct representation of a value.

double sum = 382.36;
String firstName = "Luke"; // string literal inside quotation marks
boolean isExpensive = false;

Here are character literals you might use:

// character literal inside single quote marks
'\n'     new line
'\t'    tab

Variables

We have already seen Declarations and assignments.

Declaring a variable

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

Initializing a variable

The expression that initializes a variable (that assigns it a value for initial use) can be an expression with:

• a literal
• a reference to another variable
• a call to a method, in which case the return value determines the initialization

Scope of a variable

We say, "seeing is believing". Java can only compute with variables that it can see. 
Scope is the block of code in which a variable exists and is available for use.
The scope (or visibility) of a variable depends upon WHERE you declare it. 
You might declare a variable within a block of code that is a:

• class (static variable)
• instance
• local logic and looping structures

local variable

A data item known within a block, but inaccessible to code outside the block. For example, any variable defined within a method is a local variable and can't be used outside the method.

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

Sun's tutorial exposes a common error involving the concept of scope:

if (...) {
    int myInteger = 17;
    ...
}
System.out.println("The value of myInteger  = " + myInteger);    // error

The final line won't compile because the local variable i is out of scope. The scope of i is the block of code between the { and }.

The myInteger variable does not exist after the closing curly brace (}) ends that block of code.

QUESTION: Can you use have an instance variable with exactly the same name as a local variable?

QUESTION: Which line numbers define the scope of x? of y?

Scope in a for loop example

Let's discuss this example:

and its output:

Value of myInteger is: 1
Value of myInteger is: 2
3 is a multiple of 3
Value of myInteger is: 3
Value of myInteger is: 4
Value of myInteger is: 5
6 is a multiple of 3
Value of myInteger is: 6
Value of myInteger is: 7
Value of myInteger is: 8
9 is a multiple of 3
Value of myInteger is: 9

Let discuss this example with break:

and its output:

counting.. 1 2 3 4 5

Let's look ahead at break in more detail (in a switch statement) and then come back.

Type Conversion

Automatic conversion occurs when your expression involves two data types that are compatible with each other, and the conversion is widening, that is, the destination type accommodates larger values the the source type.

For example,

double myInteger = 1;
double myFloat = 1.0;

I do not need to use all the memory it takes to store a double (64 bits) if my value is just an integer (32 bits), but Java allows me to make an assignment that involves this explicit conversion.

Type Casting

Casting

Casting is the explicit translation of:

• a primitive type into another primitive type
• an object into another object.

In a cast, the Java runtime knows enough about the types and how they are related to do this conversion.

Casting primitives

Explicit cast to smaller type - the syntax is (typename)value

Line 9 casts the product of two doubles as an integer.

The output is:

The product as double is 3.75
The product as integer is = 3

Another explicit cast is of integer into byte:

b = (byte) (50 * 2);

Booleans cannot be cast.

When you cast a floating point type to an integer type, or a double to a float, there may be loss of precision.
For example, (int)3.2 truncates the .2 and returns 3.
 
Also, when you cast from a larger integer type to a smaller one, if the number is very large, it might be truncated and return a smaller number.

The output is:

Conversion of int to byte.
When int i = 257 is cast as a byte, the byte value is: 1

Conversion of double to int.
Truncation when double 323.142 is cast as int 323

Conversion of double to byte.
Casting double d 323.142 into byte causes wraparound after 255 67

Casting objects

You can cast an object to another class if the two classes are related by inheritance.

For example, all objects inherit from the superclass Object.
http://java.sun.com/j2se/1.4.1/docs/api/java/lang/Object.html

Therefore, all objects have a GetClass() method.
http://java.sun.com/j2se/1.4.1/docs/api/java/lang/Object.html#getClass()

I do not need to make an explicit cast for my string object to use this method.

The output is:

The class of myClass@111f71 is myClass
The class of [Ljava.lang.String;@273d3c is [Ljava.lang.String;

You do not need an explicit cast when upcasting, but you do need an explicit cast when downcasting.
For example, this example casts an object as a string.
Object is higher in the class hierarchy than String, so casting an object as a string is downcasting.

String s = "Heeeeeeeeere's Johnny";
Object o = s; // implicit upcast, no casting syntax needed because all strings inherit from the Object superclass
String sz = (String)o; // explicit downcast, need casting syntax because String is a subclass of Object

The instanceof operator

You can use the instanceof  operator to test an object's class before doing a downcast:

String s = "Heeeeeeeeere's Johnny";
Object o = s;
String sz;
if (o instanceof String) {
   sz = (String)o;
}

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/other.html
Here, the instanceof operator determines whether its first operand is an instance of its second operand.

Converting objects

Converting is the translation of one type into another, when you cannot do a simple cast. 
Unlike a cast, the runtime does not know enough about the types to do this automatically. 
Some code must be written to handle the conversion

Suppose that you have been storing zip codes as strings, but now you need to treat those zip codes as integers.
You can use an method of the Integer class to pass in a string argument and get integer output.
In effect, the following example converts a string object into a integer primitive.

String myZipCode = "94568"; // myZipCode is a String object
int myZip = Integer.parseInt(myZipCode); // myZip is a primitive

http://java.sun.com/j2se/1.4.1/docs/api/java/lang/Integer.html

To convert an integer primitive into an object of its corresponding Integer class:

The output is:

The class to which 94568 is an instance is java.lang.Integer

http://java.sun.com/j2se/1.4.1/docs/api/java/lang/Integer.html#Integer(int)

The most common type of conversion is to and from a String. 
The java.lang.Object package defines the toString() method with a simple default implementation. 
Many classes override this implementation to provide a translation that preserves the object's content.
For example, an XML document might use the toString() method.

Comparing Objects

java.lang.Object defines an equals() method, but the default implementation is simply a = = test. 
Some objects override this (which is polymorphism applied to inheritence).

When you compare Strings, the = = operator tests for identical objects.
More likely, you want to test for identical values being stored in the String variables.
Every String object has an equals() method for this test of equivalent values being stored in two string variables.

Whereas line 5 creates a second reference (or variable) to the original object, line 11 reassigns that variable to a new and different object.

The output is:

Contents of first string: some text.
Contents of second string: some text.
Two variables REFER to same object? Use = = and result is true
s2 now refers to a new and different object
even if it contains the same value as s1.
Contents of first string: some text.
Contents of second string: some text.
Same object? Use = = and result is false
Same value? Use equals and result is true

Type Promotion

Java can promote data types when it evaluates an expression.

As the comments state, a byte can be promoted to a float, a char to an integer, a short to a double, an int to a float, and a float to a double.

Arrays

An array stores multiple variables of 

• the same type
• a specific number of indices ("slots")
• you access an element by using its index

Examples of arrays

• days of week
• zipcode
• table of sines and cosines in trigonometry

one-dimensional

Line 4 declares the array named month_days to store a set of values of type int.
Line 5 creates the array with 12 elements.
Lines 6 through 17 populate the array with integer values.

To get the number of elements in an array, use the length() method of the array object;

multidimensional

The output is:

Strings

Internally, a String is an array of characters, an array of char. The Java API, however, considers a String to be an object. Therefore, you benefit from built-in methods and property to help you handle strings.

Quiz

1. Put in order, from smallest to larger number of possible values:

• float
• integer
• boolean
• short
• double
• long

2. We have seen a loop with a "break" statement. What does the "break" statement do?
3. We also looked ahead at a switch statement. What is a switch statement about? What is it an alternative for?
4. How many different kinds of objects can an array with ten elements hold?
5. What determines the scope of a variable?
6. Which lines define the scope of the variable if the variable is a counter in a for loop?
7. If you say "x = 2;" and "y = x;" then say "x = 3'", what will the value of y then be?
8. Write a string variable named curDay, and assign it the literal value of the current day of the week.
9. What is casting?
10. What similarity do you find between a table and a two-dimensional array?

Homework Assignment

Write a program that does one or both of the following:

• convert values from the metric system

• convert values to the metric system

Here is some starter code for taking command-line input:

______________
course homepage      course calendar