Transcript PowerPoint Sunusu

Advanced Java Programming
Java SE 8 for Programmers, Third Edition
Contents I
Multidimensional Arrays
Introduction to Collections and Class ArrayList
Object-Oriented Programming(cont’d)
Interfaces
final Methods and Classes
Creating and Using Interfaces
Interface Enhancements
Exception Handling
Contents II
Swing GUI Components
Simple GUI-Based Input/Output with JOptionPane
Overview of Swing Components
Displaying Text and Images in a Window
Text Fields and an Introduction to Event Handling
with Nested Classes
Buttons That Maintain State
JComboBox; Using an Anonymous Inner Class for
Event Handling
Mouse Event Handling
Adapter Classes
JPanel Subclass for Drawing with the Mouse
Introduction to Layout Managers
Contents III
Graphics and Java 2D
Strings, Characters and Regular Expressions
Class String
Files, Streams and Object Serialization
Two-Dimensional Arrays with Rows of
Different Lengths
Arrays of One-Dimensional Arrays
int[][] b = {{1, 2}, {3, 4}}
 Multidimensional arrays are maintained as arrays of one-dimensional
arrays.
 The initial values are grouped by row in braces.
 1 and 2 initialize b[0][0] and b[0][1],
 3 and 4 initialize b[1][0] and b[1][1],
 The compiler counts the number of nested array initializers to
determine the number of rows in array b.
 The compiler counts the initializer values in the nested array initializer
for a row to determine the number of columns in that row.
 array b is actually composed of two separate one-dimensional arrays
 one containing the value first nested initializer list {1, 2}
 one containing the values in the second nested initializer list {3, 4}.
 array b itself is anof two elements, each a one-dimensional array of
int values.
Two-Dimensional Arrays with Rows of
Different Lengths
int[][] b = {{1, 2}, {3, 4, 5}};
creates integer array b with two elements
Representing the rows of the two-dimensional array.
Each element of b is a reference to a onedimensional array of int variables.
The int array for row 0 is a one-dimensional
array with two elements (1 and 2),
the int array for row 1 is a one-dimensional
array with three elements (3, 4 and 5).
Creating Two-Dimensional Arrays with
Array-Creation Expressions
int[][] b = new int[3][4];
we use the values 3 and 4 to specify the
number of rows and number of columns,
but this is not required.
Programs can use variables to specify array
dimensions
new creates arrays at execution time—not at
compile time.
The elements of a multidimensional array are
initialized when the array object is created.
Creating Two-Dimensional Arrays with
Array-Creation Expressions
A multidimensional array in which each row has a
different number of columns can be created
int[][] b = new int[2][]; // create 2 rows
b[0] = new int[5]; // create 5 columns for row 0
b[1] = new int[3]; // create 3 columns for row 1
This statements create a two-dimensional array
with two rows.
Row 0 has five columns
Row 1 has three columns
Two-Dimensional Array Example:
Displaying
Element
Values
public class InitArray
{
// create and output 2D arrays
public static void main(String[] args)
{
int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
int[][] array2 = {{1, 2}, {3}, {4, 5, 6}};
System.out.println
("Values in array1 by row are");
outputArray(array1);
// displays array1 by row
System.out.printf
("%nValues in array2 by row are%n");
outputArray(array2);
// displays array2 by row
}
// output rows and columns of a 2D array
public static void outputArray(int[][] array)
{ // loop through array's rows
for (int row = 0; row < array.length; row++)
{ // loop through columns of current row
for (int column = 0;
column < array[row].length; column++)
System.out.printf("%d ",
array[row][column]);
System.out.println();
}
}
} // end class InitArray
Values in array1 by row are
1 2 3
4 5 6
Values in array2 by row are
1 2
3
4 5 6
Common Multidimensional-Array Manipulations
Performed with for Statements
 Many common array manipulations use for statements.
 The following for statement sets all the elements in row 2 of array a to
zero:
for (int column = 0; column <a[2].length; column++)
a[2][column] = 0;
We specified row 2
we know that the first index is always 2 (0 is the first row, and 1 is the second
row).
This for loop varies only the second index (i.e., the column index).
If row 2 of array a contains four elements, then the preceding for statement is
equivalent to the assignment statements
a[2][0] = 0;
a[2][1] = 0;
a[2][2] = 0;
a[2][3] = 0;
Common Multidimensional-Array Manipulations
Performed with for Statements
The nested for statement totals the values of all the elements in array a:
int total = 0;
for (int row = 0; row < a.length; row++)
{
for (int column = 0; column < a[row].length; column++)
total += a[row][column];
}
 These nested for statements total the array elements one row at a time.
 The outer for statement begins by setting the row index to 0 so that the
first row’s elements can be totaled by the inner for statement.
 The outer for increments row to 1 so that the second row can be totaled.
 The outer for increments row to 2 so that the third row can be totaled.
 The variable total can be displayed when the outer for statement
terminates.
// an example of two-dimensional array
int[][] grades = {{87, 96, 70}, {68, 87, 90},
{94, 100, 90}, {100, 81, 82},
{83, 65, 85}, {78, 87, 65},
{85, 75, 83}, {91, 94, 100},
{76, 72, 84}, {87, 93, 73}};
Introduction to Collections and Class
ArrayList
The Java API provides several predefined data
structures, called collections, used to store
groups of related objects in memory.
 These classes provide efficient methods that
organize, store and retrieve your data without
requiring knowledge of how the data is being
stored.
This can reduce application-development time
and help you produce higher-quality, betterperforming software.
Introduction to Collections and Class
ArrayList
Arrays are used to store sequences of objects.
Arrays do not automatically change their size at
execution time to add additional elements.
The collection class ArrayList<T> (package java.util)
provides a convenient solution to this problem
it can dynamically change its size to accommodate more
elements.
The T (by convention) is a placeholder
when declaring a new ArrayList, replace it with the type
of elements that you want the ArrayList to hold.
Class ArrayList<T>
java.lang.Object
java.util.AbstractCollection<T>
java.util.AbstractList<T>
java.util.ArrayList<T>
Introduction to Collections and Class
ArrayList
ArrayList<String> list;
declares list as an ArrayList collection that can store
only Strings.
Classes with this kind of placeholder that can be
used with any type are called generic classes.
Only nonprimitive types can be used to declare
variables and create objects of generic classes.
Boxing mechanism allows primitive values to be
wrapped as objects for use with generic classes.
Boxing Mechanism
ArrayList<Integer> integers;
declares integers as an ArrayList that can store only
Integers.
When you place an int value into an
ArrayList<Integer>, the int value is boxed
(wrapped) as an Integer object,
 When you get an Integer object from an
ArrayList<Integer>, then assign the object to an
int variable, the int value inside the object is
unboxed (unwrapped).
Some methods and properties of class
ArrayList<T>.
an ArrayList<String> Example
import java.util.ArrayList;
public class ArrayListCollection
{
public static void main(String[] args)
{
// create a new ArrayList of Strings with an initial capacity of 10
ArrayList<String> items = new ArrayList<String> ();
items.add("red"); // append an item to the list
items.add(0, "yellow"); // insert "yellow" at index 0
//header
System.out.print( "Display list contents with countercontrolled loop:");
for (int i = 0; i < items.size(); i++)
System.out.printf(" %s", items.get(i));
an ArrayList<String> Example
// display colors using enhanced for in the display method
display(items, "%nDisplay list contents with enhanced for statement:");
items.add("green"); // add "green" to the end of the list
items.add("yellow"); // add "yellow" to the end of the list
display(items, "List with two new elements:");
items.remove("yellow"); // remove the first "yellow"
display(items, "Remove first instance of yellow:");
items.remove(1); // remove item at index 1
display(items, "Remove second list element (green):");
// check if a value is in the List
System.out.printf("\red \" is %s in the list%n",
items.contains("red") ? "": "not ");
// display number of elements in the List
System.out.printf("Size: %s%n", items.size());
}
an ArrayList<String> Example
// display the ArrayList's elements on the console
public static void display(ArrayList<String> items, String header)
{
System.out.printf(header); // display header
// display each element in items
for (String item : items)
System.out.printf(" %s", item);
System.out.println();
}
} // end class ArrayListCollection
Output
Display list contents with counter-controlled loop: yellow red
Display list contents with enhanced for statement: yellow red
List with two new elements: yellow red green yellow
Remove first instance of yellow: red green yellow
Remove second list element (green): red yellow
"red" is in the list
Size: 2