int [][] A; // A is a two-dimensional array A = new int[5][]; // A now has 5 rows, but no columns yet A[0] = new int [1]; // A's first row has 1 column A[1] = new int [2]; // A's second row has 2 columns A[2] = new int [3]; // A's third row has 3 columns A[3] = new int [5]; // A's fourth row has 5 columns A[4] = new int [5]; // A's fifth row also has 5 columns
For each of the following code fragments, fill in the number of the picture that best illustrates the value of A after the code executes, or fill in "error" to indicate that executing the code causes a runtime error. (In the pictures, a diagonal line indicates a null pointer.)
| Code | Corresponding Picture or Error |
| int [] A; | |
| int [] A = new int [4]; | |
| int [][] A = new int[4][3]; | |
| int [][] A = new int[4][];
A[1] = new int[4]; A[3] = new int[2]; | |
| int [] A = new int[4];
int [] B = {0,1,2,3,4,5,6,7,8,9}; System.arraycopy(B,2,A,0,4); | |
| int [] A = new int[4];
int [] B = {2,3,4}; System.arraycopy(B,0,A,0,4); | |
| int [] A = new int[4];
int [] B = {0,1,2,3,4,5,6,7,8,9}; System.arraycopy(B,8,A,0,4); | |
| int [] A = {1,1,1,1};
int [] B = {2,2,2}; System.arraycopy(A,0,B,1,2); System.arraycopy(B,0,A,0,3); | |
| int [] A = new int[4];
int [] B = {0,1,2,3,4,5,6,7,8,9}; System.arraycopy(B,0,A,0,10); | |
| int [][] A = new int[4][3];
int [] B = {1,2,3,4,5,6,7,8,9,10}; System.arraycopy(B,0,A[0],0,3); System.arraycopy(B,1,A[1],0,3); System.arraycopy(B,2,A[2],0,3); System.arraycopy(B,3,A[3],0,3); |
| (1) | (2) | (3) |
| 
| 
|
| (4) | (5) | (6) |
| 
| 
|
| (7) | (8) | (9) |
| 
| 
|
| (10) | (11) | (12) |
| 
| 
|
| (13) | (14) | (15) |
| 
| 
|
- In C++, when you declare a variable whose type is a class,
storage is allocated for an object of that class, and the
class's constructor function is called to initialize that
instance of the class. In Java, you are really declaring
a pointer to a class object; no storage is allocated for
the class object, and no constructor function is called
until you use "new". Assume that you have defined a List
class as follows:
class List { public void AddToEnd(...) { ...} ... }
C++
List L; // L is a List; the List constructor function is called to
// initialize L.
List *p; // p is a pointer to a List;
// no list object exists yet, no constructor function has
// been called
p = new List; // now storage for a List has been allocated
// and the constructor function has been called
L.AddToEnd(...) // call L's AddToEnd function
p->AddToEnd(...) // call the AddToEnd function of the List pointed to by p
JAVA
List L; // L is a pointer to a List; no List object exists yet
L = new List(); // now storage for a List has been allocated
// and the constructor function has been called;
// note that you must use parentheses even when you are not
// passing any arguments to the constructor function
L.AddToEnd(...) // no -> operator in Java -- just use .
Aliasing Problems in Java
The fact that arrays and classes are really pointers in Java can lead to some problems:
Problem 1: Simple assignment causes aliasing:
Java code conceptual picture
(all empty boxes contain zeros)
+--+ +---+---+---+
int [] A = new int[3], A: | -|-----> | | | |
+--+ +---+---+---+
B = new int[2]; +--+ +---+---+
B: | -|-----> | | |
+--+ +---+---+
+--+ +---+---+---+
A[0] = 5; A: | -|-----> | 5 | | |
+--+ +---+---+---+
+--+ +---+---+---+
B = A; A: | -|-----> | 5 | | |
+--+ +---+---+---+
^
+--+ |
B: | -|-------+
+--+
+--+ +---+---+---+ *** NOTE **
B[0] = 2; A: | -|-----> | 2 | | | the value of A[0]
+--+ +---+---+---+ changed, too!
^
+--+ |
B: | -|-------+
+--+
Problem 2: In Java, all parameters are passed by value, but for arrays and classes the actual parameter is really a pointer, so changing
- an array element, or
- a class field
void f( int [] A )
{
A[0] = 10; // change an element of parameter A
A = null; // change A itself
}
void g()
{
int [] B = new int [3];
B[0] = 5;
f(B);
*** B is not null here, because B itself was passed by value
*** however, B[0] is now 10, because function f changed the first element
*** of the array
}
In C++, similar problems can arise when a class that has pointer data
members is passed by value. This problem is addressed by the use of
For each of the following Java code fragments, say whether it causes a compile-time error, a run-time error, or no error. If there is an error, explain why.
1. int A[5];
2. int [] A, B;
B = 0;
3. int [] A = {1,2,3};
int [] B;
B = A;
4. int [] A;
A[0] = 0;
5. int [] A = new int[20];
int [] B = new int[10];
A = B;
A[15] = 0;
Type Conversion
Java is much more limited than C++ in the type conversions that are allowed. Here we discuss conversions among primitive types. Conversions among class objects will be discussed later.
Booleans cannot be converted to other types. For the other primitive types (char, byte, short, int, long, float, and double), there are two kinds of conversion: implicit and explicit.
Implicit conversions: An implicit conversion means that a value of one type is changed to a value of another type without any special directive from the programmer. A char can be implicitly converted to an int, a long, a float, or a double. For example, the following will compile without error:
char c = 'a'; int k = c; long x = c; float y = c; double d = c;For the other (numeric) primitive types, the basic rule is that implicit conversions can be done from one type to another if the range of values of the first type is a subset of the range of values of the second type. For example, a byte can be converted to a short, int, long or float; a short can be converted to an int, long, float, or double, etc.
Explicit conversions: Explicit conversions are done via casting: the name of the type to which you want a value converted is given, in parentheses, in front of the value. For example, the following code uses casts to convert a value of type double to a value of type int, and to convert a value of type double to a value of type short:
double d = 5.6; int k = (int)d; short s = (short)(d * 2.0);Casting can be used to convert among any of the primitive types except boolean. Note, however, that casting can lose information; for example, floating-point values are truncated when they are cast to integers (e.g., the value of k in the code fragment given above is 5), and casting among integer types can produce wildly different values (because upper bits, possibly including the sign bit, are lost). So use explicit casting carefully!
Fill in the table below as follows:
- If the declaration will compile as is, put a check in the second column, and write the value of the declared variable in the last column.
- If the declaration will not compile as is, but can be made to compile by adding an explicit cast, rewrite the declaration with the correct explicit cast in the third column, and write the value of the declared variable in the last column.
- If the declaration will not compile, and cannot be fixed by adding an explicit cast, put a check in the fourth column.
Declaration | Correct | Rewrite with cast | Never correct | Variable's value
| double d = 5; | X | | | 5.0
| int k = 5.6;
| long x = 5.4;
| short n = 99999;
| int b = true;
| char c = 97;
| short s = -10.0;
| |
Solutions to Self-Study Questions
Test Yourself #1
System.out.println(x + y); ==> 30
System.out.println(x + y+ "!"); ==> 30!
System.out.println("printing: " + x + y); ==> printing: 2010
System.out.println("printing: " + x * y); ==> printing: 200
Test Yourself #2
class Test {
public static void main( String[] args ) {
int sum = 0;
for (int k=1; k<=10; k++) sum += k;
System.out.println("The sum is: " + sum);
}
}
Test Yourself #3
class Test {
public static int[] NonZeros( int[] A ) {
// count # nonzero values
int nonz = 0;
for (int k=0; k<A.length; k++) if (A[k] != 0) nonz++;
// allocate and fill new array
int[] result = new int[nonz];
int j = 0; // index of next element of new array to fill in
for (int k=0; k<A.length; k++) {
if (A[k] != 0) {
result[j] = A[k];
j++;
}
}
return result;
}
public static void PrintArray( int[] A ) {
System.out.print("[");
for (int k=0; k<A.length; k++) {
System.out.print(A[k]);
if (k < (A.length - 1)) System.out.print(" ");
}
System.out.print("]");
}
public static void main(String[] args) {
int[] A = {0,1,2,3,2};
System.out.print("passing ");
PrintArray(A);
A = NonZeros(A);
System.out.print(" got back ");
PrintArray(A);
System.out.println();
int[] B = {0,0};
System.out.print("passing ");
PrintArray(B);
A = NonZeros(B);
System.out.print(" got back ");
PrintArray(A);
System.out.println();
int[] C = {1,0};
System.out.print("passing ");
PrintArray(C);
A = NonZeros(C);
System.out.print(" got back ");
PrintArray(A);
System.out.println();
}
}
Test Yourself #4
CODE CORRESPONDING PICTURE
---- ---------------------
int [] A; 9
int [] A = new int[4]; 6
int [][] A = new int[4][3]; 3
int [][] A = new int[4][];
A[1] = new int[4];
A[3] = new int[2]; 1
int [] A = new int[4];
int [] B = {0,1,2,3,4,5,6,7,8,9};
System.arraycopy(B,2,A,0,4); 14
int [] A = new int[4];
int [] B = {2,3,4};
System.arraycopy(B,0,A,0,4); error
int [] A = new int[4];
int [] B = {0,1,2,3,4,5,6,7,8,9};
System.arraycopy(B,8,A,0,4); error
int [] A = {1,1,1,1};
int [] B = {2,2,2};
System.arraycopy(A,0,B,1,2);
System.arraycopy(B,0,A,0,3); 12
int [] A = new int[4];
int [] B = {0,1,2,3,4,5,6,7,8,9};
System.arraycopy(B,0,A,0,10); error
int [][] A = new int[4][3];
int [] B = {1,2,3,4,5,6,7,8,9,10};
System.arraycopy(B,0,A[0],0,3);
System.arraycopy(B,1,A[1],0,3);
System.arraycopy(B,2,A[2],0,3);
System.arraycopy(B,3,A[3],0,3); 10