# CONTENTS: Array Usage Multi-Dimensional Arrays Reference Types. COMP-202 Unit 6: Arrays

Size: px
Start display at page:

Download "CONTENTS: Array Usage Multi-Dimensional Arrays Reference Types. COMP-202 Unit 6: Arrays"

Transcription

1 CONTENTS: Array Usage Multi-Dimensional Arrays Reference Types COMP-202 Unit 6: Arrays

2 Introduction (1) Suppose you want to write a program that asks the user to enter the numeric final grades of 350 COMP-202 students, and calculates various statistics, such as the mean grade and the median grade To calculate some of these statistics (such as the median), we may need to store all the grades in memory simultaneously In other words, we cannot calculate these statistics by simply reading the value from the keyboard, processing it, and discarding it How can we keep track of large amounts of information in memory while the program is running? 2

3 Introduction (2) One potential solution would be to declare one variable for each grade we want to process, like this: double grade1, grade2, grade3, grade4, /* 345 more... */ grade350; However, this solution has many serious disadvantages Declaring such a large number of variables is tedious and error-prone Such a solution does not allow us to use loops to process the values, which leads to repeated statements and ugly, unmaintainable code The program works only for a specific number of grades, and needs to be modified if we want to process a different number of grades 3

4 Arrays An array is a fixed-size, ordered collection of elements of the same type Each of the individual elements in the array is basically a separate variable The entire array is declared as one variable and has a single name Each of the variables in the array can be referred to using the array's name in combination with a numeric index For example, we can refer to the variable at position i in an array, where i is called an index into the array This makes handling large amounts of data much easier 4

5 Part 1: Array Basics

6 Array Declarations (1) Before we can use an array, we have to declare it just like other variables An array declaration has the following syntax: type [] The type of the values that will be stored in the array variablename; Indicates that the variable is an array, not a single regular variable The single name used to refer to the entire array 6

7 Array Declarations (2) In an array declaration: type[] variablename; The type of each element in the array is type type can be any type (primitive or reference) On the other hand, the type of variablename is not type; it is type[], read as "array of type" Note that declaring an array variable does not specify what the size of the array will be This will be specified in a separate step 7

8 Array Declaration Examples double[] prices; Declares an array called prices Each element in this array is a double; variable prices is of type double[] char[] code; Declares an array called code Each element of this array is a char; variable code is of type char[] String[] names; Declares an array called names Each element of this array is a String; variable names is of type String[] 8

9 Array Declarations Variations (1) We can also declare arrays by placing the square brackets ([]) after the variable name instead of after the type, using the following syntax: type variablename[]; However, the preferred array declaration style is the one we saw earlier: type[] variablename; When the array declaration specifies only one variable name, both of the above styles are equivalent However, these two styles are not equivalent when the array declarations specify more than one variable name 9

10 Array Declaration Variations (2) int[] first, second; Declares two variables of type int[]; one is called first and the other is called second int first[], second; Declares a variable of type int[] called first, along with a single variable of type int called second 10

11 Arrays and Reference Types (1) All array types are reference types, regardless of whether the type of element the array contains is a primitive or reference type Primitive types and reference types are not stored in memory in the same manner When declaring a variable, memory cells are allocated regardless of whether the type of the variable is a primitive type or a reference type What differs is the nature of what will be stored in those cells The declaration int number; creates a variable that will hold a value of type int 11

12 Arrays and Reference Types (2) The int value is stored directly in the memory cells that are allocated when the variable number is declared On the other hand, the declaration int[] numberarray; creates a reference variable, which holds a reference to an int[] No array is created When the array is created, it will not be stored in the memory cells that are allocated when the variable numberarray is declared Instead, what will be stored in those cells is a reference to the array; the location, or address, in memory where the array is stored once it is created 12

13 Allocating Arrays (1) Declaring an array variable is a separate operation from actually creating the array whose address in memory will be stored in that array variable We use the new operator to create an array: variablename = new type [ size ]; The variable in which the location in memory of the newly created array will be stored new is a reserved word in Java An expression which specifies the number of elements in the array The type of the elements to be stored in the array 13

14 Allocating Arrays (2) The statement variablename = new type[size]; does two things: It creates an array of elements; the type of the elements stored in this array is specified by type, and the number of elements the array contains is specified by size It assigns the location in memory where the newly-created array is stored to the variable specified by variablename In general, variable variablename MUST be of type type[] The size of the array can be specified by any expression which evaluates to a value of type int; such an expression can be An int literal (for example, 5) 14

15 Allocating Arrays (3) A variable of type int A call to a method which returns an int value; the method call will be executed in its entirety before the array is created An expression with operators involving multiple int literals, int variables, and calls to methods which return an int value Once an array has been created, its size cannot be changed But we can allocate a new array of a different size and store its address in the variable which contained the address of the old array, thus overwriting this address As with regular variables, the array declaration and the array allocation operation can be combined: type[] variablename = new type[size]; 15

16 Array Allocation (1) final int SIZE = 5; int[] numbers; numbers = new int[2 * SIZE]; numbers - SIZE 5 16

17 Array Allocation (2) final int SIZE = 5; int[] numbers; numbers = new int[2 * SIZE]; numbers SIZE

18 Default Values When an array is allocated with the new operator, default values are assigned to each element in the array The default value depends on the type of the values the array contains byte, short, and int: 0 long: 0L char: The character whose code is 0 float: 0.0f double: 0.0 boolean: false Reference types: null We will see what null is later 18

19 Accessing Array Elements (1) Each element in an array can be thought of as a single, separate variable To access one of the elements of an array, we use the following syntax: variablename [ index ] variablename is the name of the array variable which contains the address in memory of the array containing the element being accessed index specifies the position within the array of the element which is being accessed 19

20 Accessing Array Elements (2) The index of the element to be accessed can be specified by any expression which evaluates to a value of type int Any of the kinds of expressions that can be used to specify the size of an array (an int literal, an int variable, a call to a method that returns an int value, or a combination using operators) can be used to specify an index in the array The array element being accessed can be used in all the ways that a regular variable of the same type can be used We can assign a value to it We can assign the value it contains to another variable We can use the element as an operand in an expression We can pass the element to a method as an actual parameter 20

21 Array Indexing If the number of elements in an array is n, all integers from 0 to n-1 can be used to access elements in the array Each integer in this range is used as an index to access a different element In other words: The first element has index 0 The second element has index 1... The last element in an array of n elements has index n-1 For example, in an array of size 10, all the numbers between 0 and 9 (inclusive) can be used to access the array elements 21

22 Array Access Example numbers[0] = 1; numbers[1] = numbers[0]; numbers[2 * SIZE 1] = 2 * numbers[0] + 1; numbers SIZE

23 Bounds Checking (1) An expression used to specify an array index MUST evaluate to an int whose value is between 0 (inclusive) and the size of the array (exclusive) That is, if an array has size n, then n is NOT a valid index value for this array The validity of an array index cannot be enforced by the Java compiler However, the Java Virtual Machine performs automatic bounds checking; it verifies that all indices used to access array values are valid for the array containing the element being accessed That is, every time the program tries to access an element in an array, the JVM first verifies that the index refers to a valid element in this array 23

24 Bounds Checking (2) If you attempt to access the element in an array located at an invalid index (either negative, or greater than or equal to the length of the array), your program will crash: int[] myarray = new int[5]; myarray[5] = 42; // Array myarray contains 5 elements, so // the valid indices for myarray are 0-4 // inclusive // Therefore, the program crashes When this occurs, the error message will mention that the program threw an ArrayIndexOutOfBoundsException The error message should also mention which line in your program caused the latter to crash 24

25 IndexOutOfBoundsDemo.java public class IndexOutOfBoundsDemo { public static void main(string[] args) { final int SIZE = 5; int[] myarray; } } myarray = new int[size]; System.out.println("Attempting to retrieve the " + "element at position " + SIZE + " of an array of " + "size " + SIZE); myarray[size] = 42; System.out.println("The element at position " + SIZE + " of this array is " + myarray[size]); 25

26 Reading Exception Output (1) The program's output: Attempting to retrieve the element at position 5 of an array of size 5 Exception in thread "main" java.lang. ArrayIndexOutOfBoundsException: 5 ` at IndexOutOfBoundsDemo.main(IndexOutOfBoundsDemo.java:11) Method where the problem occurred File where the problem occurred Line number where the problem occurred Nature of the problem and additional information Index we tried to access and caused the crash 26

27 Off-By-One Errors Revisited Off-by-one errors are common when using arrays: int[] array = new int[100]; int i; i = 0; while (i <= 100) { array[i] = 2 * i; i = i + 1; } Problem: the loop body will be executed when the value of i is 100 This will cause the program to attempt to store a value in position 100 of an array of 100 elements However, position 100 does not exist in an array of 100 elements 27

28 Array Length (1) We can retrieve the length of an array by accessing the length field of the array We can access the length field of an array using the following syntax variablename.length An array variable For example, if we wanted to retrieve the length of an array called myarray, we would write: myarray.length 28

29 Array Length (2) The length field of an array is a value of type int This value is assigned automatically when the array is allocated with the new operator However, its value is constant and cannot be changed Therefore, the length field of an array can be used like any other final variable of type int: We can assign it to a variable We can use it in an expression We can pass it to a method as an actual parameter However, we cannot assign a value to it; that is, the following line will cause the compiler to report an error: myarray.length = 4; 29

30 Array Length (3) Note that the length field of an array holds the length of the array, not the index of the last element in the array However, the index of the last element in an array can be retrieved by accessing the length field and subtracting 1 from its value: myarray[myarray.length 1] = 42; // Stores value 42 in the last position // of array myarray 30

31 Initializer Lists (1) We can declare an array, allocate it, and initialize all of its elements in one statement This statement involves initializer lists, and has the following syntax: type[] variablename = {value1, value2, /* More values */ valuen}; The list of values is surrounded by braces ({}) Values are separated by commas 31

32 Initializer Lists (2) For example, consider this use of the initializer list: int[] numbers = {2, 3, 5}; The above statement does all the following in one step: It declares a variable of type int[] called numbers It creates an array which contains 3 elements It stores the address in memory of the new array in variable numbers It sets the value of first element of the array to 2, the value of the second element of the array to 3, and the value of the last element of the array to be 5 32

33 Initializer Lists (3) Therefore, the statement int[] numbers = {2, 3, 5}; is equivalent to the following code fragment: int[] numbers = new int[3]; numbers[0] = 2; numbers[1] = 3; numbers[2] = 5; Other examples of initializer lists: char[] lettergrades = {'A', 'B', 'C', 'D', 'F'}; String[] operatingsystems = {"Windows", "Mac OS X", "GNU/Linux"}; 33

34 Details of Initializer Lists (1) Note that when an initializer list is used The new operator is not used No size value is specified explicitly Instead, the length of the array is determined by the number of values in the initializer list For example, if there are 10 items in the initializer list, the array is of size 10 The values in the array created using an initializer lists can be used and modified just like the values stored in a regular array Likewise, an array variable initialized using an initializer list can be used and modified just like a regular array variable 34

35 Details of Initializer Lists (2) An initializer list can only be used to initialize the array upon declaration Therefore, when using an initializer list, splitting the array declaration step from the initialization step will cause the compiler to report an error: int[] numbers; numbers = {2, 3, 5}; // Error: initializer lists can // only be used when declaring // the array 35

36 Part 2: Multidimensional Arrays

37 Two-Dimensional Arrays (1) So far, the elements of all the arrays we have seen have been simple values: primitive types or Strings Such arrays are one-dimensional However, we can create arrays whose elements are themselves one-dimensional arrays Such an array is really an array of arrays These arrays are two-dimensional arrays (or 2D arrays) Elements in a two dimensional array are accessed using two indices The first index specifies the one-dimensional array containing the element we want to access 37

38 Two-Dimensional Arrays (2) The second index specifies the element we want to access within the one-dimensional array specified by the first index It may be useful to think of two-dimensional arrays as tables of values with rows and columns The first index specifies a row or column The second index specifies an element within a row or column 38

39 2D Array Declarations (1) The declaration for a two-dimensional array has the same basic syntax and semantics as the declaration of a onedimensional array The only difference is that there are two pairs of square brackets ([]) instead of just one Examples: double[][] matrix; char[][] mysteryword; We can also declare two-dimensional arrays by placing the square brackets after the variable name instead of after the type double table[][]; 39

40 2D Array Declarations (2) Again, placing the brackets before the type is the preferred declaration style More array declaration examples: double[][] distances, prices; Declares two variables of type double[][]; one is called distances and the other is called prices double distances[][], totalprice; Declares a variable of type double[][] called distances, along with a single variable of type double called totalprice double[] distances[], averages; Declares a variable of type double[][] called distances, along with a variable of type double[] called averages 40

41 2D Array Allocations (1) We can allocate a two-dimensional array using the same basic syntax as when we allocate a one-dimensional array The only difference is that we can specify two sizes The first size specifies the number of one-dimensional arrays that the array of arrays will contain The second size component specifies the number of elements in each one-dimensional array For example, if a variable of type int[][] called numbers has already been declared, we can allocate a two-dimensional array of int and store its address in variable numbers like this: matrix = new int[3][5]; 41

42 2D Array Allocations (2) This allocates an array that can store 3 elements, each of which is the address of an array of ints Each of these 3 arrays of ints can store 5 elements, each of which is of type int numbers

43 Accessing 2D Array Elements We can access the individual elements of a two-dimensional array by using two indices, between two sets of square brackets The first index specifies the one-dimensional array which contains the element we want to access The second index specifies the element we want to access within the one-dimensional array specified by the first index The individual elements of a two-dimensional array can be used in the same manner as regular variables of the same type We can also access an entire one-dimensional array by specifying only one index between a pair of square brackets When we do this, the one-dimensional array can be used in the same manner as a regular one-dimensional array 43

44 2D Array Access Example (1) For example, suppose we have the following array declaration / allocation statement: int[][] numbers = new int[3][5]; Consider the expression numbers[1][3] The above expression refers to the element at position 3 of a onedimensional array of ints This one dimensional array of ints is stored in position 1 of a twodimensional array of ints The address of this two-dimensional array of ints is stored in variable matrix 44

45 2D Array Access Example (2) Consider the expression numbers[1] This expression refers to the element at position 1 of a twodimensional array of ints This element is an entire one-dimensional array of ints Its type is int[], and therefore can be used in the same manner as a regular variable of type int[] 45

46 2D Array Access Example (3) numbers[1][3] = 7; numbers[2][4] = numbers[1][3] - 2; numbers

47 2D Arrays and length Fields (1) Because a two-dimensional array is an array of arrays, the actual value of the length field depends on the array whose length is being accessed The expression variablename.length specifies the number of onedimensional arrays in the two-dimensional array whose address is stored in variable variablename The expression variablename[index].length refers to the maximum number of individual elements in the one-dimensional array whose address is stored at position index of the two-dimensional array whose address is stored in variablename 47

48 2D Array and length Fields (2) int size = numbers.length; int rowsize = numbers[0].length; numbers size rowsize

49 2D Arrays and Initializer Lists (1) Initializer lists can be used to initialize two-dimensional arrays upon declaration The basic syntax, semantics, and restrictions are the same as when an initializer list is used to initialize a one-dimensional array The only difference is that each element in the initializer list for a two-dimensional array is itself the initializer list for a one dimensional array The following statement declares an allocates a twodimensional array of int called grid: int[][] grid = { {1, 2, 3}, {2, 4, 6} } 49

50 2D Array and Initializer Lists (2) grid contains 2 one-dimensional arrays as elements Each of these one-dimensional arrays contains 3 values of type int grid

51 Variation: Jagged Arrays (1) In a two-dimensional array, each one-dimensional array can have a different length Such arrays are called jagged arrays, or ragged arrays We can accomplish this by not assigning a length to the onedimensional arrays when we create the two-dimensional array, like this: variablename = new type[size][]; No size information 51

52 Variation: Jagged Arrays (2) The previous statement allocates an array which can hold the addresses of size one-dimensional arrays, and stores its address in variablename, of type type[][] However, none the one-dimensional arrays themselves are allocated by the above statement, and their size is unknown The one-dimensional arrays are allocated one-by-one normally in separate steps Their sizes do not have to be equal, and are totally arbitrary Actual use of jagged arrays is uncommon 52

53 Jagged Array Example (1) numbers = new int[3][]; numbers

54 Jagged Array Example (2) for(int i = 0; i < numbers.length; i++) numbers[i] = new int[i+1]; numbers i

55 Multidimensional Arrays (1) Multidimensional arrays are a more general case of twodimensional arrays Syntactically, multidimensional arrays work just like twodimensional arrays, except for the fact that they have more dimensions All syntactic rules for one-dimensional arrays and two-dimensional arrays generalize to handle more dimensions These generalizations are based on the idea that the number of square bracket pairs specifies the number of dimensions For example, when accessing an element in a multidimensional array, we must specify as many indices between square bracket pairs as the array has dimensions 55

56 Multidimensional Arrays (2) If the multidimensional array has n dimensions, then specifying m dimensions will refer to an (n-m)-dimensional array Multidimensional arrays can be perfectly rectangular, or they can be jagged Actual use of "pure" arrays with more than 2 dimensions is rare 56

57 Part 3: Reference Types

58 Reference Types We know that there are two broad kinds of types in Java: primitive types and reference types We have already covered primitive types Although array types are reference types, they are not the only kind of reference type We will see the other reference types later However, the concepts explained in the following slides apply to all reference types 58

59 Reference Variables We can declare variables whose types are reference types, just like we can declare variables whose types are primitive types The syntax for declaring variables whose types are reference types is the same as the syntax for declaring variables whose types are primitive types The following statement is a variable declaration: int[] numbers; The name of the variable is numbers The type of the variable is int[] int[], being an array type, is a reference type A variable whose type is a reference type is called a reference variable 59

60 Primitive vs. Reference Types (1) When declaring a variable, memory cells are allocated and associated with that variable, regardless of whether the type of the variable is a primitive type or a reference type What differs is the nature of what will be stored in those cells The declaration int number; creates a variable that holds a value of type int The purpose of a variable whose type is a primitive type is to store values The int value is stored directly in the memory cells that are allocated when the variable number is declared 60

61 Primitive vs. Reference Types (2) On the other hand, the declaration int[] numbers; creates a reference variable A reference variable is used to keep track of an object Declaring a reference variable does not create any objects, it merely creates a variable which can keep track of an object in memory The object must be created in a separate step When it is created, the object will not be stored in the memory cells that are allocated when the variable numbers is declared Instead, what will be stored in those cells is the reference to the object; the location, or address, in memory where the object is stored once it is created The object itself will be stored somewhere else in memory 61

62 Aside: Objects In object-oriented programming languages like Java, objects represent individual and identifiable items or entities In Java, all arrays are objects However, there are objects in Java that are not arrays We will cover objects in detail later in the course For now, we will use the term object to refer to any individual item stored in memory, and which can be accessed and modified using a reference variable Primitive values are therefore not objects 62

63 Creating Objects (1) Declaring a reference variable is a separate operation from creating an object whose address in memory will be stored in that reference variable In general, we use the new operator to create an object: numbers = new int[10]; There are two situations where we create objects without using the new operator: When we use array initializer lists The first time we use a String literal, a String object representing this literal is automatically created 63

64 Creating Objects (2) When we create an object using the new operator, additional memory cells are allocated The object is stored in these additional memory cells These memory cells are not the same as the memory cells allocated when reference variables are declared The address of the memory cells in which the object is stored will be stored in a reference variable 64

65 Reference Types: Initialization The assignment number = 42; writes the value 42 into the memory cells allocated to variable number On the other hand, when the assignment numbers = new int[10]; is executed, the following happens: A new array of int is created; it uses some memory cells The variable numbers gets assigned the address of the memory cells that contain the array of int object We say that the contents of the reference variable is a reference or a pointer to the real object 65

66 Primitive Types: Assignment Consider the following code fragment: int i1, i2 = 8; i1 = 6; i2 = i1; When the last line of the above fragment is executed, the contents of variable i1 is copied into i2 Because the type of these variables is a primitive type, the respective contents of these variables are their actual values Thus, the value of i1 is copied into i2 If the value of i2 is modified afterwards, the value of i1 stays the same 66

67 Primitive Types In Memory int i1, i2 = 8; // Line 1 i1 = 6; // Line 2 i2 = i1; // Line 3 Line 1: i1 i2 8 Line 2: i1 6 i2 8 Line 3: i1 6 i2 6 67

68 Reference Types: Assignment Now, consider the following code fragment: int[] a1, a2 = {2, 3, 5}; a1 = new int[3]; a1 = a2; When the last line of the above fragment is executed, the contents of variable a2 is copied into variable a1 However, because the type of these variables is a reference type, the respective contents of these variables are the addresses of objects in memory, not the objects themselves Thus, the address stored in a2 is copied into a1 There is still only one object involved here, but its address in memory is stored in two different variables 68

69 Reference Types in Memory int[] a1, a2 = {2, 3, 5}; // Line 1 a1 = new int[3]; // Line 2 a2 = a1; // Line 3 a a2 Line 1: a a2 Line 2: a a2 Line 3:

70 Aliases (1) When the address in memory of one object is stored in two or more different variables, we say that the variables are aliases We need to be careful when working with aliases Aliasing has side-effects that we need to be aware of Because the variables contain the address in memory of the same object, the result of changing the object using one of its aliases will be reflected through the other aliases Recall that the object is not stored in the reference variables; instead, the reference variables specify where to find the object in memory Thus, changing the object is not the same as changing the contents of the reference variable which contain the address of this object 70

71 Aliases (2) To "de-alias" the variables, we simply need to store the address of a different object in one of them by using an assignment statement Note that aliasing is only a property of reference types; it is not a property of primitive types 71

72 Alias Example Consider the following code fragment: int[] a1 = {2, 3, 5}; int[] a2 = a1; a1[0] = 7; int v = a2[0]; What will be the value of variable v after the last line in the above fragment is executed? The answer is: 7 (?!?) Because a1 and a2 are aliases for the same object, any change to the object via one of its aliases will be reflected through the other alias 72

73 Aliases in Memory (1) int[] a1 = {2, 3, 5}; // Line 1 int[] a2 = a1; // Line 2 a1[0] = 7; // Line 3 int v = a2[0]; // Line 4 a Line 1: a a2 Line 2:

74 Aliases in Memory (2) int[] a1 = {2, 3, 5}; // Line 1 int[] a2 = a1; // Line 2 a1[0] = 7; // Line 3 int v = a2[0]; // Line 4 a a2 Line 3: a a2 v 7 Line 4:

75 Comparing Objects (1) Among the comparison operators, only == and!= are defined for reference types If you try to compare two reference variables using <, <=, >, or >=, the compiler will report an error Moreover, when used to compare reference variables, the == and!= operators check whether the two reference variables refer to the same object in memory In other words, for reference variables, the == and!= operators check whether the addresses stored in them are the same In yet other words, the == and!= operators check whether two reference variables are aliases for the same object But two different objects, stored at different addresses, can have the same contents 75

76 Comparing Objects Using == (1) int[] a1 = {2, 3, 5}; // Line 1 int[] a2 = a1; // Line 2 boolean b = (a1 == a2); // Line 3 a Line 1: a a2 Line 2: a a2 b true Line 3:

77 Comparing Objects Using == (2) int[] a1 = {2, 3, 5}; // Line 1 int[] a2 = {2, 3, 5}; // Line 2 boolean b = (a1 == a2); // Line 3 a Line 1: a a2 Line 2: a a2 b false Line 3:

78 More on Comparing Objects To see check whether two objects have the same contents, we need to compare their contents manually For arrays, this can be done using a loop to verify whether all elements are the same For other kinds of objects (like Strings), we can use the equals() method In fact, the reason Strings cannot be compared using the == and!= operator is because String is a reference type Therefore, when applied to String variables, the == and!= operators check whether the variables contain the address in memory of the same String object But two String variables could contain the addresses of two different String objects which consist of the same characters in the same order 78

79 More on Comparing Objects (2) In such a case, the expression involving the == operator would evaluate to false, even though the Strings really are equal Again, never use the == and!= operators to compare Strings for equality (or inequality) unless you are really sure of what you are doing; always use the equals() method to compare Strings 79

80 The null Literal Value Sometimes, we want a reference variable to contain a special value to indicate that the variable intentionally does not contain the address in memory of a valid object The literal value null can be used for this purpose Like the boolean literals true and false, null is not technically a reserved word, but you cannot use it for any purpose other than as a literal value for reference variables null can be assigned to reference variables of any type A reference variable containing the value null is sometimes said to "point nowhere" In memory diagrams, null is often represented with a ground symbol 80

81 Using null One can assign null to a reference variable like one assigns an int literal like 42 to a variable of type int int[] a; a1 = null; One can check whether or not a reference variable contains the value null like one checks whether or not a variable of type int contains any value represented by an int literal like 42 if (a == null) { // do something } else { // do something else } 81

82 null-related Caveats The address stored in a reference variable is always either the address in memory of a valid object of that variable's type, or null In Java, you cannot store an arbitrary memory address in a reference variable, nor manipulate memory addresses directly If you attempt to use access an object using a reference variable which contains null, your program will crash: int[] a = null; a[0] = 1; // a1 contains null: crash! When this occurs, the error message will mention that the program threw a NullPointerException The error message should also mention which line in your program caused the latter to crash 82

83 NullPointerDemo.java public class NullPointerDemo { public static void main(string[] args) { int[] a = null; } } System.out.println("Attempting to retrieve the " + "element stored at index 0 of an array through a " + "null reference variable..."); System.out.println("The value stored at index 0 of " + "this array is: " + a[0]); What will happen if we run this program? 83

84 Reading Exception Output (2) The program's output: Attempting to retrieve the element stored at index 0 of an array through a null reference variable... Exception in thread "main" java.lang.nullpointerexception ` at NullPointerDemo.main(NullPointerDemo.java:8) Nature of the problem 84

85 Garbage Collection (1) When there are no more reference variables containing the address of an object, the object can no longer be accessed by the program It is useless, and therefore called garbage Java performs automatic garbage collection periodically When garbage collection occurs, all the memory allocated to store garbage objects is made available so it be allocated to store new objects In other languages, the programmer has the responsibility for performing garbage collection Always ensure you do not lose the last reference to an object you still need 85

86 Garbage Collection (2) On the other hand, if you no longer need an object, you should make sure that none of your reference variables contain its address in memory You can do this by assigning null to the reference variables which contain the address of this object This is so that the memory it occupies can be reclaimed by the garbage collector and reused to store new objects 86

87 Garbage Collection in Memory (1) int[] a1 = {2, 3, 5}; // Line 1 int[] a2 = {4, 6, 7}; // Line 2 a2 = a1; // Line 3 a Line 1: a a2 Line 2:

88 Garbage Collection in Memory (2) int[] a1 = {2, 3, 5}; // Line 1 int[] a2 = {4, 6, 7}; // Line 2 a2 = a1; // Line 3 Garbage a a Line 1: a a After Garbage Collection: 88

89 Passing Reference Types (1) Recall: Parameter passing works just like an assignment statement The value of the actual parameter is copied into the method's formal parameter When passing reference types, the value of the actual parameter also is copied into the formal parameter just like in an assignment statement However, recall that the value stored in a reference variable is the address in memory where an object is located, not the object itself 89

90 Passing Reference Types (2) Therefore, for parameters whose types are reference types, the value copied in the formal parameter is the address where an object is stored in memory This implies that: When passing reference types, the formal parameter and the actual parameter become aliases If a method changes the contents of an object whose address is stored in a formal parameter, the change will also be reflected by the actual parameter However, if you change the address stored in the formal parameter, the address stored in the actual parameter will not change 90

91 ReferenceAssignDemo.java (1 / 2) public class ReferenceAssignDemo { public static void main(string[] args) { int[] a1 = {1, 2, 3}; int[] a2 = {4, 5, 6}; int[] ac1, ac2; // *** Line 1 System.out.println("Value of a1[0]: " + a1[0]); System.out.println("Value of a2[0]: " + a2[0]); ac1 = a1; ac2 = a2; // *** Line 2 System.out.println("Value of ac1[0]: " + ac1[0]); System.out.println("Value of ac2[0]: " + ac2[0]); // Continued on next slide 91

92 ReferenceAssignDemo.java (2 / 2) } } // Continued from previous slide ac1[0] = 7; ac2 = new int[3]; ac2[0] = 8; ac2[1] = 9; ac2[2] = 10; // *** Line 3 System.out.println("New value of ac1[0]: " + ac1[0]); System.out.println("Value of new ac2[0]: " + ac2[0]); System.out.println("Value of a1[0] after assignment: " + a1[0]); System.out.println("Value of a2[0] after assignment: " + a2[0]); What does this display? What does it look like in memory while it is running? 92

93 More Aliases in Memory (1) Memory contents after execution of line 1: a ac1 - - a2 ac2 93

94 More Aliases in Memory (2) Memory contents after execution of line 2: a ac1 a2 ac2 94

95 More Aliases in Memory (3) Memory contents after execution of line 3: a ac a2 ac2 95

96 ReferencePassingDemo.java (1 / 2) public class ReferencePassingDemo { public static void main(string[] args) { int[] a1 = {1, 2, 3}; int[] a2 = {4, 5, 6}; } System.out.println("Value of a1[0] before calling m(): " + a1[0]); System.out.println("Value of a2[0] before calling m(): " + a2[0]); System.out.println("--"); m(a1, a2); System.out.println("--"); System.out.println("Value of a1[0] after calling m(): " + a1[0]); System.out.println("Value of a2[0] after calling m(): " + a2[0]); // Continued on next slide 96

97 ReferencePassingDemo.java (2 / 2) } // Continued from previous slide public static void m(int[] ac1, int[] ac2) { System.out.println("Value of received ac1[0]: " + ac1[0]); System.out.println("Value of received ac2[0]: " + ac2[0]); // *** Line 2 ac1[0] = 7; ac2 = new int[3]; // *** Line 3 ac2[0] = 8; ac1[1] = 9; ac2[2] = 0; System.out.println("New value of ac1[0]: " + ac1[0]); System.out.println("Value of new ac2[0]: " + ac2[0]); } What does this display? What does it look like in memory while it is running? 97

98 Reference Passing in Memory (1) Memory contents after execution of line 1: a main() a2 98

99 Reference Passing in Memory (2) Memory contents after execution of line 2: a main() m() a2 ac1 ac2 99

100 Reference Passing in Memory (3) Memory contents after execution of line 3: a m() a2 ac1 ac2 100

### Last Class. Introduction to arrays Array indices Initializer lists Making an array when you don't know how many values are in it

Last Class Introduction to arrays Array indices Initializer lists Making an array when you don't know how many values are in it public class February4{ public static void main(string[] args) { String[]

### Example: Computing prime numbers

Example: Computing prime numbers -Write a program that lists all of the prime numbers from 1 to 10,000. Remember a prime number is a # that is divisible only by 1 and itself Suggestion: It probably will

### Last Class. More on loops break continue A bit on arrays

Last Class More on loops break continue A bit on arrays public class February2{ public static void main(string[] args) { String[] allsubjects = { ReviewArray, Example + arrays, obo errors, 2darrays };

### Computer Science is...

Computer Science is... Machine Learning Machine learning is the study of computer algorithms that improve automatically through experience. Example: develop adaptive strategies for the control of epileptic

### Last Class. While loops Infinite loops Loop counters Iterations

Last Class While loops Infinite loops Loop counters Iterations public class January31{ public static void main(string[] args) { while (true) { forloops(); if (checkclassunderstands() ) { break; } teacharrays();

### COMP 250: Java Programming I. Carlos G. Oliver, Jérôme Waldispühl January 17-18, 2018 Slides adapted from M. Blanchette

COMP 250: Java Programming I Carlos G. Oliver, Jérôme Waldispühl January 17-18, 2018 Slides adapted from M. Blanchette Variables and types [Downey Ch 2] Variable: temporary storage location in memory.

### Chapter 6 SINGLE-DIMENSIONAL ARRAYS

Chapter 6 SINGLE-DIMENSIONAL ARRAYS Lecture notes for computer programming 1 Faculty of Engineering and Information Technology Prepared by: Iyad Albayouk What is an Array? A single array variable can reference

### CONTENTS: Arrays Strings. COMP-202 Unit 5: Loops in Practice

CONTENTS: Arrays Strings COMP-202 Unit 5: Loops in Practice Computing the mean of several numbers Suppose we want to write a program which asks the user to enter several numbers and then computes the average

### COMP-202 Unit 5: Basics of Using Objects

COMP-202 Unit 5: Basics of Using Objects CONTENTS: Concepts: Classes, Objects, and Methods Creating and Using Objects Introduction to Basic Java Classes (String, Random, Scanner, Math...) Introduction

### Primitive vs Reference

Primitive vs Reference Primitive types store values Reference types store addresses This is the fundamental difference between the 2 Why is that important? Because a reference type stores an address, you

### Arrays. Outline 1/7/2011. Arrays. Arrays are objects that help us organize large amounts of information. Chapter 7 focuses on:

Arrays Arrays Arrays are objects that help us organize large amounts of information Chapter 7 focuses on: array declaration and use bounds checking and capacity arrays that store object references variable

### Motivation was to facilitate development of systems software, especially OS development.

A History Lesson C Basics 1 Development of language by Dennis Ritchie at Bell Labs culminated in the C language in 1972. Motivation was to facilitate development of systems software, especially OS development.

### Arrays: Higher Dimensional Arrays. CS0007: Introduction to Computer Programming

Arrays: Higher Dimensional Arrays CS0007: Introduction to Computer Programming Review If the == operator has two array variable operands, what is being compared? The reference variables held in the variables.

### Lesson 06 Arrays. MIT 11053, Fundamentals of Programming By: S. Sabraz Nawaz Senior Lecturer in MIT Department of MIT FMC, SEUSL

Lesson 06 Arrays MIT 11053, Fundamentals of Programming By: S. Sabraz Nawaz Senior Lecturer in MIT Department of MIT FMC, SEUSL Array An array is a group of variables (called elements or components) containing

### Array. Prepared By - Rifat Shahriyar

Java More Details Array 2 Arrays A group of variables containing values that all have the same type Arrays are fixed length entities In Java, arrays are objects, so they are considered reference types

### COMP-202 Unit 8: Defining Your Own Classes. CONTENTS: Class Definitions Attributes Methods and Constructors Access Modifiers and Encapsulation

COMP-202 Unit 8: Defining Your Own Classes CONTENTS: Class Definitions Attributes Methods and Constructors Access Modifiers and Encapsulation Defining Our Own Classes (1) So far, we have been creating

### array Indexed same type

ARRAYS Spring 2019 ARRAY BASICS An array is an indexed collection of data elements of the same type Indexed means that the elements are numbered (starting at 0) The restriction of the same type is important,

### Chapter 9 Introduction to Arrays. Fundamentals of Java

Chapter 9 Introduction to Arrays Objectives Write programs that handle collections of similar items. Declare array variables and instantiate array objects. Manipulate arrays with loops, including the enhanced

### Arrays and Lists CSC 121 Fall 2016 Howard Rosenthal

Arrays and Lists CSC 121 Fall 2016 Howard Rosenthal Lesson Goals Understand what an array is Understand how to declare arrays Understand what reference variables are Understand how to pass arrays to methods

### Object Oriented Programming. Java-Lecture 6 - Arrays

Object Oriented Programming Java-Lecture 6 - Arrays Arrays Arrays are data structures consisting of related data items of the same type In Java arrays are objects -> they are considered reference types

### TOPICS TO COVER:-- Array declaration and use.

ARRAYS in JAVA TOPICS TO COVER:-- Array declaration and use. One-Dimensional Arrays. Passing arrays and array elements as parameters Arrays of objects Searching an array Sorting elements in an array ARRAYS

### Review Chapters 1 to 4. Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013

Review Chapters 1 to 4 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013 Introduction to Java Chapters 1 and 2 The Java Language Section 1.1 Data & Expressions Sections 2.1 2.5 Instructor:

### School of Computer Science CPS109 Course Notes 5 Alexander Ferworn Updated Fall 15

Table of Contents 1 INTRODUCTION... 1 2 IF... 1 2.1 BOOLEAN EXPRESSIONS... 3 2.2 BLOCKS... 3 2.3 IF-ELSE... 4 2.4 NESTING... 5 3 SWITCH (SOMETIMES KNOWN AS CASE )... 6 3.1 A BIT ABOUT BREAK... 7 4 CONDITIONAL

### Arrays and Lists Review CSC 123 Fall 2018 Howard Rosenthal

Arrays and Lists Review CSC 123 Fall 2018 Howard Rosenthal Lesson Goals Review what an array is Review how to declare arrays Review what reference variables are Review how to pass arrays to methods Review

### Method OverLoading printf method Arrays Declaring and Using Arrays Arrays of Objects Array as Parameters

Outline Method OverLoading printf method Arrays Declaring and Using Arrays Arrays of Objects Array as Parameters Variable Length Parameter Lists split() Method from String Class Integer & Double Wrapper

### TOPIC 2 INTRODUCTION TO JAVA AND DR JAVA

1 TOPIC 2 INTRODUCTION TO JAVA AND DR JAVA Notes adapted from Introduction to Computing and Programming with Java: A Multimedia Approach by M. Guzdial and B. Ericson, and instructor materials prepared

### CS5000: Foundations of Programming. Mingon Kang, PhD Computer Science, Kennesaw State University

CS5000: Foundations of Programming Mingon Kang, PhD Computer Science, Kennesaw State University Arrays A data structure for a collection of data that is all of the same data type. The data type can be

### Lecture Notes on Memory Layout

Lecture Notes on Memory Layout 15-122: Principles of Imperative Computation Frank Pfenning André Platzer Lecture 11 1 Introduction In order to understand how programs work, we can consider the functions,

### More non-primitive types Lesson 06

CSC110 2.0 Object Oriented Programming Ms. Gnanakanthi Makalanda Dept. of Computer Science University of Sri Jayewardenepura More non-primitive types Lesson 06 1 2 Outline 1. Two-dimensional arrays 2.

### Data Types, Variables and Arrays. OOC 4 th Sem, B Div Prof. Mouna M. Naravani

Data Types, Variables and Arrays OOC 4 th Sem, B Div 2016-17 Prof. Mouna M. Naravani Identifiers in Java Identifiers are the names of variables, methods, classes, packages and interfaces. Identifiers must

### COMP-202 Unit 2: Java Basics. CONTENTS: Using Expressions and Variables Types Strings Methods

COMP-202 Unit 2: Java Basics CONTENTS: Using Expressions and Variables Types Strings Methods Assignment 1 Assignment 1 posted on WebCt and course website. It is due May 18th st at 23:30 Worth 6% Part programming,

### PROGRAMMING FUNDAMENTALS

PROGRAMMING FUNDAMENTALS Q1. Name any two Object Oriented Programming languages? Q2. Why is java called a platform independent language? Q3. Elaborate the java Compilation process. Q4. Why do we write

### Motivation was to facilitate development of systems software, especially OS development.

A History Lesson C Basics 1 Development of language by Dennis Ritchie at Bell Labs culminated in the C language in 1972. Motivation was to facilitate development of systems software, especially OS development.

### Introduction to Object-Oriented Programming

Introduction to Object-Oriented Programming Arrays, Part 2 of 2 Christopher Simpkins chris.simpkins@gatech.edu Chris Simpkins (Georgia Tech) CS 1331 Arrays, Part 2 of 2 1 / 16 A few more array topics Variable

### Lecture 17. For Array Class Shenanigans

Lecture 17 For Array Class Shenanigans For or While? class WhileDemo { public static void main(string[] args){ int count = 1; while (count < 11) { System.out.println("Count is: " + count); count++; Note:

### G Programming Languages - Fall 2012

G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter

### Chapter 6 Introduction to Defining Classes

Introduction to Defining Classes Fundamentals of Java: AP Computer Science Essentials, 4th Edition 1 Objectives Design and implement a simple class from user requirements. Organize a program in terms of

### Lesson 9: Introduction To Arrays (Updated for Java 1.5 Modifications by Mr. Dave Clausen)

Lesson 9: Introduction To Arrays (Updated for Java 1.5 Modifications by Mr. Dave Clausen) 1 Lesson 9: Introduction Objectives: To Arrays Write programs that handle collections of similar items. Declare

### For example, let s say we define an array of char of size six:

Arrays in C++ An array is a consecutive group of memory locations that all have the same name and the same type. To refer to a particular location, we specify the name and then the positive index into

### CONTENTS: Compilation Data and Expressions COMP 202. More on Chapter 2

CONTENTS: Compilation Data and Expressions COMP 202 More on Chapter 2 Programming Language Levels There are many programming language levels: machine language assembly language high-level language Java,

### Data dependent execution order data dependent control flow

Chapter 5 Data dependent execution order data dependent control flow The method of an object processes data using statements, e.g., for assignment of values to variables and for in- and output. The execution

### Full file at

Java Programming: From Problem Analysis to Program Design, 3 rd Edition 2-1 Chapter 2 Basic Elements of Java At a Glance Instructor s Manual Table of Contents Overview Objectives s Quick Quizzes Class

### Arrays. Lecture 9 COP 3014 Fall October 16, 2017

Arrays Lecture 9 COP 3014 Fall 2017 October 16, 2017 Array Definition An array is an indexed collection of data elements of the same type. Indexed means that the array elements are numbered (starting at

### EXERCISES SOFTWARE DEVELOPMENT I. 04 Arrays & Methods 2018W

EXERCISES SOFTWARE DEVELOPMENT I 04 Arrays & Methods 2018W Solution First Test DATA TYPES, BRANCHING AND LOOPS Complete the following program, which calculates the price for a car rental. First, the program

### Array Basics: Outline. Creating and Accessing Arrays. Creating and Accessing Arrays. Arrays (Savitch, Chapter 7)

Array Basics: Outline Arrays (Savitch, Chapter 7) TOPICS Array Basics Arrays in Classes and Methods Programming with Arrays Searching and Sorting Arrays Multi-Dimensional Arrays Static Variables and Constants

### COMP-202: Foundations of Programming. Lecture 5: Arrays, Reference Type, and Methods Sandeep Manjanna, Summer 2015

COMP-202: Foundations of Programming Lecture 5: Arrays, Reference Type, and Methods Sandeep Manjanna, Summer 2015 Announcements Assignment 2 posted and due on 30 th of May (23:30). Extra class tomorrow

### Arrays and Lists CSC 121 Fall 2015 Howard Rosenthal

Arrays and Lists CSC 121 Fall 2015 Howard Rosenthal Lesson Goals Understand what an array is Understand how to declare arrays Understand what reference variables are Understand how to pass arrays to methods

### COMP-202: Foundations of Programming. Lecture 4: Flow Control Loops Sandeep Manjanna, Summer 2015

COMP-202: Foundations of Programming Lecture 4: Flow Control Loops Sandeep Manjanna, Summer 2015 Announcements Check the calendar on the course webpage regularly for updates on tutorials and office hours.

### C++ Arrays and Vectors

C++ Arrays and Vectors Contents 1 Overview of Arrays and Vectors 2 2 Arrays 3 2.1 Declaring Arrays................................................. 3 2.2 Initializing Arrays................................................

### CMSC131. Introduction to your Introduction to Java. Why Java?

CMSC131 Introduction to your Introduction to Java Why Java? It s a popular language in both industry and introductory programming courses. It makes use of programming structures and techniques that can

### General Syntax. Operators. Variables. Arithmetic. Comparison. Assignment. Boolean. Types. Syntax int i; float j = 1.35; int k = (int) j;

General Syntax Statements are the basic building block of any C program. They can assign a value to a variable, or make a comparison, or make a function call. They must be terminated by a semicolon. Every

### CPSC 3740 Programming Languages University of Lethbridge. Data Types

Data Types A data type defines a collection of data values and a set of predefined operations on those values Some languages allow user to define additional types Useful for error detection through type

### Arrays. Defining arrays, declaration and initialization of arrays. Designed by Parul Khurana, LIECA.

Arrays Defining arrays, declaration and initialization of arrays Introduction Many applications require the processing of multiple data items that have common characteristics (e.g., a set of numerical

### Fall 2017 CISC124 9/16/2017

CISC124 Labs start this week in JEFF 155: Meet your TA. Check out the course web site, if you have not already done so. Watch lecture videos if you need to review anything we have already done. Problems

### Creating and Using Objects

Creating and Using Objects 1 Fill in the blanks Object behaviour is described by, and object state is described by. Fill in the blanks Object behaviour is described by methods, and object state is described

### Pointer Basics. Lecture 13 COP 3014 Spring March 28, 2018

Pointer Basics Lecture 13 COP 3014 Spring 2018 March 28, 2018 What is a Pointer? A pointer is a variable that stores a memory address. Pointers are used to store the addresses of other variables or memory

### Crash Course in Java. Why Java? Java notes for C++ programmers. Network Programming in Java is very different than in C/C++

Crash Course in Java Netprog: Java Intro 1 Why Java? Network Programming in Java is very different than in C/C++ much more language support error handling no pointers! (garbage collection) Threads are

### Chapter 3: Arrays and More C Functionality

Chapter 3: Arrays and More C Functionality Objectives: (a) Describe how an array is stored in memory. (b) Define a string, and describe how strings are stored. (c) Describe the implications of reading

### CS 231 Data Structures and Algorithms, Fall 2016

CS 231 Data Structures and Algorithms, Fall 2016 Dr. Bruce A. Maxwell Department of Computer Science Colby College Course Description Focuses on the common structures used to store data and the standard

### CPS122 Lecture: From Python to Java last revised January 4, Objectives:

Objectives: CPS122 Lecture: From Python to Java last revised January 4, 2017 1. To introduce the notion of a compiled language 2. To introduce the notions of data type and a statically typed language 3.

### 12. Pointers Address-of operator (&)

12. Pointers In earlier chapters, variables have been explained as locations in the computer's memory which can be accessed by their identifer (their name). This way, the program does not need to care

### News and information! Review: Java Programs! Feedback after Lecture 2! Dead-lines for the first two lab assignment have been posted.!

True object-oriented programming: Dynamic Objects Reference Variables D0010E Object-Oriented Programming and Design Lecture 3 Static Object-Oriented Programming UML" knows-about Eckel: 30-31, 41-46, 107-111,

### Agenda CS121/IS223. Reminder. Object Declaration, Creation, Assignment. What is Going On? Variables in Java

CS121/IS223 Object Reference Variables Dr Olly Gotel ogotel@pace.edu http://csis.pace.edu/~ogotel Having problems? -- Come see me or call me in my office hours -- Use the CSIS programming tutors Agenda

### [0569] p 0318 garbage

A Pointer is a variable which contains the address of another variable. Declaration syntax: Pointer_type *pointer_name; This declaration will create a pointer of the pointer_name which will point to the

### Introduction to Programming in C Department of Computer Science and Engineering. Lecture No. #43. Multidimensional Arrays

Introduction to Programming in C Department of Computer Science and Engineering Lecture No. #43 Multidimensional Arrays In this video will look at multi-dimensional arrays. (Refer Slide Time: 00:03) In

### Arrays. Lecture 11 CGS 3416 Spring March 6, Lecture 11CGS 3416 Spring 2017 Arrays March 6, / 19

Arrays Lecture 11 CGS 3416 Spring 2017 March 6, 2017 Lecture 11CGS 3416 Spring 2017 Arrays March 6, 2017 1 / 19 Arrays Definition: An array is an indexed collection of data elements of the same type. Indexed

### CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages Variables and Constants R. Sekar 1 / 22 Topics 2 / 22 Variables and Constants Variables are stored in memory, whereas constants need not be. Value of variables

Java How to Program, 10/e Copyright 1992-2015 by Pearson Education, Inc. All Rights Reserved. Data structures Collections of related data items. Discussed in depth in Chapters 16 21. Array objects Data

### BM214E Object Oriented Programming Lecture 4

BM214E Object Oriented Programming Lecture 4 Computer Numbers Integers (byte, short, int, long) whole numbers exact relatively limited in magnitude (~10 19 ) Floating Point (float, double) fractional often

### Java Language Basics: Introduction To Java, Basic Features, Java Virtual Machine Concepts, Primitive Data Type And Variables, Java Operators,

Java Language Basics: Introduction To Java, Basic Features, Java Virtual Machine Concepts, Primitive Data Type And Variables, Java Operators, Expressions, Statements and Arrays. Java technology is: A programming

### Learning Objectives. Introduction to Arrays. Arrays in Functions. Programming with Arrays. Multidimensional Arrays

Chapter 5 Arrays Learning Objectives Introduction to Arrays Declaring and referencing arrays For-loops and arrays Arrays in memory Arrays in Functions Arrays as function arguments, return values Programming

### Pointers. Reference operator (&) ted = &andy;

Pointers We have already seen how variables are seen as memory cells that can be accessed using their identifiers. This way we did not have to care about the physical location of our data within memory,

### Chapter 1 GETTING STARTED. SYS-ED/ Computer Education Techniques, Inc.

Chapter 1 GETTING STARTED SYS-ED/ Computer Education Techniques, Inc. Objectives You will learn: Java platform. Applets and applications. Java programming language: facilities and foundation. Memory management

### Primitive Data, Variables, and Expressions; Simple Conditional Execution

Unit 2, Part 1 Primitive Data, Variables, and Expressions; Simple Conditional Execution Computer Science S-111 Harvard University David G. Sullivan, Ph.D. Overview of the Programming Process Analysis/Specification

### H212 Introduction to Software Systems Honors

Introduction to Software Systems Honors Lecture #07: September 21, 2015 1/30 We explained last time that an array is an ordered list of values. Each value is stored at a specific, numbered position in

### CS 251 Intermediate Programming Java Basics

CS 251 Intermediate Programming Java Basics Brooke Chenoweth University of New Mexico Spring 2018 Prerequisites These are the topics that I assume that you have already seen: Variables Boolean expressions

### CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University

CS 112 Introduction to Computing II Wayne Snyder Department Boston University Today: Java basics: Compilation vs Interpretation Program structure Statements Values Variables Types Operators and Expressions

### C# and Java. C# and Java are both modern object-oriented languages

C# and Java C# and Java are both modern object-oriented languages C# came after Java and so it is more advanced in some ways C# has more functional characteristics (e.g., anonymous functions, closure,

### Introduction to Computer Science Unit 2. Notes

Introduction to Computer Science Unit 2. Notes Name: Objectives: By the completion of this packet, students should be able to describe the difference between.java and.class files and the JVM. create and

### CPS122 Lecture: From Python to Java

Objectives: CPS122 Lecture: From Python to Java last revised January 7, 2013 1. To introduce the notion of a compiled language 2. To introduce the notions of data type and a statically typed language 3.

### STUDENT LESSON A12 Iterations

STUDENT LESSON A12 Iterations Java Curriculum for AP Computer Science, Student Lesson A12 1 STUDENT LESSON A12 Iterations INTRODUCTION: Solving problems on a computer very often requires a repetition of

### CS121/IS223. Object Reference Variables. Dr Olly Gotel

CS121/IS223 Object Reference Variables Dr Olly Gotel ogotel@pace.edu http://csis.pace.edu/~ogotel Having problems? -- Come see me or call me in my office hours -- Use the CSIS programming tutors CS121/IS223

### A brief introduction to C programming for Java programmers

A brief introduction to C programming for Java programmers Sven Gestegård Robertz September 2017 There are many similarities between Java and C. The syntax in Java is basically

### Arrays and ArrayLists. David Greenstein Monta Vista High School

Arrays and ArrayLists David Greenstein Monta Vista High School Array An array is a block of consecutive memory locations that hold values of the same data type. Individual locations are called array s

### Decisions in Java IF Statements

Boolean Values & Variables In order to make decisions, Java uses the concept of true and false, which are boolean values. Just as is the case with other primitive data types, we can create boolean variables

### Arrays. Lecture 11 CGS 3416 Fall October 26, 2015

Arrays Lecture 11 CGS 3416 Fall 2015 October 26, 2015 Arrays Definition: An array is an indexed collection of data elements of the same type. Indexed means that the array elements are numbered (starting

### COMP 202. Programming With Arrays

COMP 202 Programming With Arrays CONTENTS: Arrays, 2D Arrays, Multidimensional Arrays The Array List Variable Length parameter lists The Foreach Statement Thinking Like A Programmer: Designing for arrays

### Zheng-Liang Lu Java Programming 45 / 79

1 class Lecture2 { 2 3 "Elementray Programming" 4 5 } 6 7 / References 8 [1] Ch. 2 in YDL 9 [2] Ch. 2 and 3 in Sharan 10 [3] Ch. 2 in HS 11 / Zheng-Liang Lu Java Programming 45 / 79 Example Given a radius

### Arrays. Weather Problem Array Declaration Accessing Elements Arrays and for Loops Array length field Quick Array Initialization Array Traversals

Arrays Weather Problem Array Declaration Accessing Elements Arrays and for Loops Array length field Quick Array Initialization Array Traversals Can we solve this problem? Consider the following program

### Modern Programming Languages. Lecture Java Programming Language. An Introduction

Modern Programming Languages Lecture 27-30 Java Programming Language An Introduction 107 Java was developed at Sun in the early 1990s and is based on C++. It looks very similar to C++ but it is significantly

### Java+- Language Reference Manual

Fall 2016 COMS4115 Programming Languages & Translators Java+- Language Reference Manual Authors Ashley Daguanno (ad3079) - Manager Anna Wen (aw2802) - Tester Tin Nilar Hlaing (th2520) - Systems Architect

### Getting started with Java

Getting started with Java by Vlad Costel Ungureanu for Learn Stuff Programming Languages A programming language is a formal constructed language designed to communicate instructions to a machine, particularly

### CE221 Programming in C++ Part 2 References and Pointers, Arrays and Strings

CE221 Programming in C++ Part 2 References and Pointers, Arrays and Strings 19/10/2017 CE221 Part 2 1 Variables and References 1 In Java a variable of primitive type is associated with a memory location

### VARIABLES AND TYPES CITS1001

VARIABLES AND TYPES CITS1001 Scope of this lecture Types in Java the eight primitive types the unlimited number of object types Values and References The Golden Rule Primitive types Every piece of data

### Introduction to Visual Basic and Visual C++ Introduction to Java. JDK Editions. Overview. Lesson 13. Overview

Introduction to Visual Basic and Visual C++ Introduction to Java Lesson 13 Overview I154-1-A A @ Peter Lo 2010 1 I154-1-A A @ Peter Lo 2010 2 Overview JDK Editions Before you can write and run the simple

### Chapter 2: Using Data

Chapter 2: Using Data TRUE/FALSE 1. A variable can hold more than one value at a time. F PTS: 1 REF: 52 2. The legal integer values are -2 31 through 2 31-1. These are the highest and lowest values that

### Operational Semantics of Cool

Operational Semantics of Cool Key Concepts semantics: the meaning of a program, what does program do? how the code is executed? operational semantics: high level code generation steps of calculating values