![Language Basics - Variables
• The Java programming language defines the following kinds of variables:
• Instance Variables (Non-Static Fields) Technically speaking, objects store
their individual states in "non-static fields", that is, fields declared without the static
keyword. Non-static fields are also known as instance variables because their values
are unique to each instance of a class (to each object, in other words); the
currentSpeed of one bicycle is independent from the currentSpeed of another.
• Class Variables (Static Fields) A class variable is any field declared with
the static modifier; this tells the compiler that there is exactly one copy of this
variable in existence, regardless of how many times the class has been instantiated.
A field defining the number of gears for a particular kind of bicycle could be marked
as static since conceptually the same number of gears will apply to all instances.
The code static int numGears=6; would create such a static field. Additionally, the
keyword final could be added to indicate that the number of gears will never
change.
• Local Variables Similar to how an object stores its state in fields, a method will
often store its temporary state in local variables. The syntax for declaring a local
variable is similar to declaring a field (for example, int count = 0;). There is no
special keyword designating a variable as local; that determination comes entirely
from the location in which the variable is declared — which is between the opening
and closing braces of a method. As such, local variables are only visible to the
methods in which they are declared; they are not accessible from the rest of the
class.
• Parameters Recall that the signature for the main method is public static
void main(String[] args). Here, the args variable is the parameter to this
method. The important thing to remember is that parameters are always classified as
"variables" not "fields". This applies to other parameter-accepting constructs as well
(such as constructors and exception handlers) that you'll learn about later in the
7](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-7-320.jpg)
![Language Basics
• Expressions - An expression is a construct made up of variables, operators, and
method invocations, which are constructed according to the syntax of the language,
that evaluates to a single value. You've already seen examples of expressions,
illustrated in bold below:
int cadence = 0;
anArray[0] = 100;
int result = 1 + 2; // result is now 3
if(value1 == value2)
System.out.println("value1 == value2");
• Statements - Statements are roughly equivalent to sentences in natural languages.
A statement forms a complete unit of execution.
• Blocks - A block is a group of zero or more statements between balanced braces
and can be used anywhere a single statement is allowed. The following
example, BlockDemo, illustrates the use of blocks:
class BlockDemo {
public static void main(String[] args) {
boolean condition = true;
if (condition) { // begin block 1
System.out.println("Condition is true.");
} // end block one
else { // begin block 2
System.out.println("Condition is false.");
} // end block 2
}
}
11](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-11-320.jpg)
![Control Flow Statements - Switch
• The switch Statement - Unlike if-then and if-then-else, the switch statement
allows for any number of possible execution paths. A switch works with
the byte, short, char, and int primitive data types. It also works
with enumerated types (discussed in Classes and Inheritance) and a few
special classes that "wrap" certain primitive types: Character, Byte, Short,
and Integer (discussed in Simple Data Objects ).
13
class SwitchDemo {
public static void main(String[] args) {
int month = 8;
switch (month) {
case 1: System.out.println("January"); break;
case 2: System.out.println("February"); break;
case 3: System.out.println("March"); break;
case 4: System.out.println("April"); break;
case 5: System.out.println("May"); break;
case 6: System.out.println("June"); break;
case 7: System.out.println("July"); break;
case 8: System.out.println("August"); break;
case 9: System.out.println("September"); break;
case 10: System.out.println("October"); break;
case 11: System.out.println("November"); break;
case 12: System.out.println("December"); break;
default: System.out.println("Invalid month.");break;
}
}
}
Another point of interest is the break statement
after each case. Each break statement
terminates the enclosing switch statement.
class SwitchDemo2 {
public static void main(String[] args) {
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDays = 30;
break;
case 2:
if ( ((year % 4 == 0) && !(year % 100 == 0))|| (year % 400 == 0) )
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = " + numDays);
}
}](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-13-320.jpg)
![Control Flow Statements - While
• The while statement continually executes a block of
statements while a particular condition is true. Its syntax
can be expressed as:
while (expression) {
statement(s)
}
• Using the while statement to print the values from 1
through 10 can be accomplished as in the following
WhileDemo program:
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
14](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-14-320.jpg)
![Control Flow Statements – Do While
• The Java programming language also provides a do-
while statement, which can be expressed as follows:
do {
statement(s)
} while (expression);
• The difference between do-while and while is that do-while
evaluates its expression at the bottom of the loop instead of the
top. Therefore, the statements within the do block are always
executed at least once, as shown in the following DoWhileDemo
program:
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: " +
count);
count++;
} while (count <= 11);
}
}
15](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-15-320.jpg)
![Control Flow Statements – For
• The for statement provides a compact way to iterate over a range of
values. Programmers often refer to it as the "for loop" because of the way
in which it repeatedly loops until a particular condition is satisfied. The
general form of the for statement can be expressed as follows:
for (initialization; termination; increment) {
statement(s)
}
• When using this version of the for statement, keep in mind that:
• The initialization expression initializes the loop; it's executed once, as the
loop begins.
• When the termination expression evaluates to false, the loop terminates.
• The increment expression is invoked after each iteration through the loop;
it is perfectly acceptable for this expression to increment or decrement a
value.
• The following program, ForDemo, uses the general form of the for
statement to print the numbers 1 through 10 to standard output:
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
} 16](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-16-320.jpg)
![Control Flow Statements – For
• The three expressions of the for loop are optional; an infinite loop can be
created as follows:
for ( ; ; ) { // infinite loop
// your code goes here
}
• The for statement also has another form designed for iteration through
Collections and arrays This form is sometimes referred to as the enhanced
for statement, and can be used to make your loops more compact and
easy to read. To demonstrate, consider the following array, which holds the
numbers 1 through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
• The following program, EnhancedForDemo, uses the enhanced for to loop
through the array:
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
17](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-17-320.jpg)
![Control Flow Statements – For-Break
• Branching Statements - Break
• The break statement has two forms: labeled and unlabeled.
• An unlabeled break statement terminates the
innermost switch, for, while, or do-while statement, but a
labeled break terminates an outer statement.
18
class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076,
2000, 8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;
}
}
if (foundIt) {
System.out.println("Found " + searchfor
+ " at index " + i);
} else {
System.out.println(searchfor
+ " not in the array");
}
}
}
class BreakWithLabelDemo {
public static void main(String[] args) {
int[][] arrayOfInts = { { 32, 87, 3, 589 }, { 12, 1076, 2000, 8 }, { 622, 127, 77, 955 } };
int searchfor = 12;
int i;
int j = 0;
boolean foundIt = false;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length; j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor +
" at " + i + ", " + j);
} else {
System.out.println(searchfor
+ " not in the array");
}
}
}](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-18-320.jpg)
![Object-Oriented Programming
Concepts Class
• Class - is a blueprint or prototype from which
objects are created.
• In object-oriented terms, we say that your bicycle is
an instance of the class of objects known as
bicycles. A class is the blueprint from which
individual objects are created.
20
class Bicycle {
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue){
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+“
speed:"+speed+" gear:"+gear);
}
}
class BicycleDemo {
public static void main(String[] args) {
// Create two different Bicycle objects
Bicycle bike1 = new Bicycle();
Bicycle bike2 = new Bicycle();
// Invoke methods on those objects
bike1.changeCadence(50);
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();
bike2.speedUp(10);
bike2.changeGear(2);
bike2.changeCadence(40);
bike2.speedUp(10);
bike2.changeGear(3);
bike2.printStates();
}
}](https://image.slidesharecdn.com/javaplatform-170728094734/85/Java-platform-20-320.jpg)
![Language Basics - Variables
• The Java programming language defines the following kinds of variables:
• Instance Variables (Non-Static Fields) Technically speaking, objects store
their individual states in "non-static fields", that is, fields declared without the static
keyword. Non-static fields are also known as instance variables because their values
are unique to each instance of a class (to each object, in other words); the
currentSpeed of one bicycle is independent from the currentSpeed of another.
• Class Variables (Static Fields) A class variable is any field declared with
the static modifier; this tells the compiler that there is exactly one copy of this
variable in existence, regardless of how many times the class has been instantiated.
A field defining the number of gears for a particular kind of bicycle could be marked
as static since conceptually the same number of gears will apply to all instances.
The code static int numGears=6; would create such a static field. Additionally, the
keyword final could be added to indicate that the number of gears will never
change.
• Local Variables Similar to how an object stores its state in fields, a method will
often store its temporary state in local variables. The syntax for declaring a local
variable is similar to declaring a field (for example, int count = 0;). There is no
special keyword designating a variable as local; that determination comes entirely
from the location in which the variable is declared — which is between the opening
and closing braces of a method. As such, local variables are only visible to the
methods in which they are declared; they are not accessible from the rest of the
class.
• Parameters Recall that the signature for the main method is public static
void main(String[] args). Here, the args variable is the parameter to this
method. The important thing to remember is that parameters are always classified as
"variables" not "fields". This applies to other parameter-accepting constructs as well
(such as constructors and exception handlers) that you'll learn about later in the
7](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-7-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Language Basics
• Expressions - An expression is a construct made up of variables, operators, and
method invocations, which are constructed according to the syntax of the language,
that evaluates to a single value. You've already seen examples of expressions,
illustrated in bold below:
int cadence = 0;
anArray[0] = 100;
int result = 1 + 2; // result is now 3
if(value1 == value2)
System.out.println("value1 == value2");
• Statements - Statements are roughly equivalent to sentences in natural languages.
A statement forms a complete unit of execution.
• Blocks - A block is a group of zero or more statements between balanced braces
and can be used anywhere a single statement is allowed. The following
example, BlockDemo, illustrates the use of blocks:
class BlockDemo {
public static void main(String[] args) {
boolean condition = true;
if (condition) { // begin block 1
System.out.println("Condition is true.");
} // end block one
else { // begin block 2
System.out.println("Condition is false.");
} // end block 2
}
}
11](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-11-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Control Flow Statements - Switch
• The switch Statement - Unlike if-then and if-then-else, the switch statement
allows for any number of possible execution paths. A switch works with
the byte, short, char, and int primitive data types. It also works
with enumerated types (discussed in Classes and Inheritance) and a few
special classes that "wrap" certain primitive types: Character, Byte, Short,
and Integer (discussed in Simple Data Objects ).
13
class SwitchDemo {
public static void main(String[] args) {
int month = 8;
switch (month) {
case 1: System.out.println("January"); break;
case 2: System.out.println("February"); break;
case 3: System.out.println("March"); break;
case 4: System.out.println("April"); break;
case 5: System.out.println("May"); break;
case 6: System.out.println("June"); break;
case 7: System.out.println("July"); break;
case 8: System.out.println("August"); break;
case 9: System.out.println("September"); break;
case 10: System.out.println("October"); break;
case 11: System.out.println("November"); break;
case 12: System.out.println("December"); break;
default: System.out.println("Invalid month.");break;
}
}
}
Another point of interest is the break statement
after each case. Each break statement
terminates the enclosing switch statement.
class SwitchDemo2 {
public static void main(String[] args) {
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDays = 30;
break;
case 2:
if ( ((year % 4 == 0) && !(year % 100 == 0))|| (year % 400 == 0) )
numDays = 29;
else
numDays = 28;
break;
default:
System.out.println("Invalid month.");
break;
}
System.out.println("Number of Days = " + numDays);
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-13-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Control Flow Statements - While
• The while statement continually executes a block of
statements while a particular condition is true. Its syntax
can be expressed as:
while (expression) {
statement(s)
}
• Using the while statement to print the values from 1
through 10 can be accomplished as in the following
WhileDemo program:
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Count is: " + count);
count++;
}
14](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-14-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Control Flow Statements – Do While
• The Java programming language also provides a do-
while statement, which can be expressed as follows:
do {
statement(s)
} while (expression);
• The difference between do-while and while is that do-while
evaluates its expression at the bottom of the loop instead of the
top. Therefore, the statements within the do block are always
executed at least once, as shown in the following DoWhileDemo
program:
class DoWhileDemo {
public static void main(String[] args){
int count = 1;
do {
System.out.println("Count is: " +
count);
count++;
} while (count <= 11);
}
}
15](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-15-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Control Flow Statements – For
• The for statement provides a compact way to iterate over a range of
values. Programmers often refer to it as the "for loop" because of the way
in which it repeatedly loops until a particular condition is satisfied. The
general form of the for statement can be expressed as follows:
for (initialization; termination; increment) {
statement(s)
}
• When using this version of the for statement, keep in mind that:
• The initialization expression initializes the loop; it's executed once, as the
loop begins.
• When the termination expression evaluates to false, the loop terminates.
• The increment expression is invoked after each iteration through the loop;
it is perfectly acceptable for this expression to increment or decrement a
value.
• The following program, ForDemo, uses the general form of the for
statement to print the numbers 1 through 10 to standard output:
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
} 16](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-16-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Control Flow Statements – For
• The three expressions of the for loop are optional; an infinite loop can be
created as follows:
for ( ; ; ) { // infinite loop
// your code goes here
}
• The for statement also has another form designed for iteration through
Collections and arrays This form is sometimes referred to as the enhanced
for statement, and can be used to make your loops more compact and
easy to read. To demonstrate, consider the following array, which holds the
numbers 1 through 10:
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
• The following program, EnhancedForDemo, uses the enhanced for to loop
through the array:
class EnhancedForDemo {
public static void main(String[] args){
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
17](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-17-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Control Flow Statements – For-Break
• Branching Statements - Break
• The break statement has two forms: labeled and unlabeled.
• An unlabeled break statement terminates the
innermost switch, for, while, or do-while statement, but a
labeled break terminates an outer statement.
18
class BreakDemo {
public static void main(String[] args) {
int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076,
2000, 8, 622, 127 };
int searchfor = 12;
int i;
boolean foundIt = false;
for (i = 0; i < arrayOfInts.length; i++) {
if (arrayOfInts[i] == searchfor) {
foundIt = true;
break;
}
}
if (foundIt) {
System.out.println("Found " + searchfor
+ " at index " + i);
} else {
System.out.println(searchfor
+ " not in the array");
}
}
}
class BreakWithLabelDemo {
public static void main(String[] args) {
int[][] arrayOfInts = { { 32, 87, 3, 589 }, { 12, 1076, 2000, 8 }, { 622, 127, 77, 955 } };
int searchfor = 12;
int i;
int j = 0;
boolean foundIt = false;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length; j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor +
" at " + i + ", " + j);
} else {
System.out.println(searchfor
+ " not in the array");
}
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-18-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Object-Oriented Programming
Concepts Class
• Class - is a blueprint or prototype from which
objects are created.
• In object-oriented terms, we say that your bicycle is
an instance of the class of objects known as
bicycles. A class is the blueprint from which
individual objects are created.
20
class Bicycle {
int cadence = 0;
int speed = 0;
int gear = 1;
void changeCadence(int newValue){
cadence = newValue;
}
void changeGear(int newValue) {
gear = newValue;
}
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:"+cadence+“
speed:"+speed+" gear:"+gear);
}
}
class BicycleDemo {
public static void main(String[] args) {
// Create two different Bicycle objects
Bicycle bike1 = new Bicycle();
Bicycle bike2 = new Bicycle();
// Invoke methods on those objects
bike1.changeCadence(50);
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();
bike2.speedUp(10);
bike2.changeGear(2);
bike2.changeCadence(40);
bike2.speedUp(10);
bike2.changeGear(3);
bike2.printStates();
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-20-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Objects
• A typical Java program creates many objects, which as you know,
interact by invoking methods. Through these object interactions, a
program can carry out various tasks, such as implementing a GUI,
running an animation, or sending and receiving information over a
network. Here's a small program, called CreateObjectDemo, that
creates three objects: one Point object and two Rectangle objects.
25
public class CreateObjectDemo {
public static void main(String[] args) {
//Declare and create a point object
//and two rectangle objects.
Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle();
Rectangle rectTwo = new Rectangle(originOne);
//display rectOne's width, height, and area
System.out.println("Width of rectOne: " + rectOne.width);
System.out.println("Height of rectOne: " + rectOne.height);
System.out.println("Area of rectOne: " + rectOne.getArea());
//set rectTwo's position
rectTwo.origin = originOne;
//display rectTwo's position
System.out.println("X Position of rectTwo: “ + rectTwo.origin.x);
System.out.println("Y Position of rectTwo: “+ rectTwo.origin.y);
//move rectTwo and display its new position
rectTwo.move(40, 72);
System.out.println("X Position of rectTwo: “ + rectTwo.origin.x);
System.out.println("Y Position of rectTwo: “ + rectTwo.origin.y);
}
public class Point {
public int x = 0;
public int y = 0;
//constructor
public Point(int a, int b) {
x = a;
y = b;
}
}
public class Rectangle {
public int width = 0;
public int height = 0;
public Point origin;
// two constructors
public Rectangle() {
origin = new Point(0, 0);
}
public Rectangle(Point p) {
origin = p;
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-25-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Nested Classes – Inner class example
31
public class DataStructure {
//create an array
private final static int SIZE = 15;
private int[] arrayOfInts = new int[SIZE];
public DataStructure() {
//fill the array with ascending integer values
for (int i = 0; i < SIZE; i++) {
arrayOfInts[i] = i;
}
}
public void printEven() {
//print out values of even indices of the array
InnerEvenIterator iterator = this.new InnerEvenIterator();
while (iterator.hasNext()) {
System.out.println(iterator.getNext() + " ");
}
}
//inner class implements the Iterator pattern
private class InnerEvenIterator {
//start stepping through the array from the beginning
private int next = 0;
public boolean hasNext() {
//check if a current element is the last in the array
return (next <= SIZE - 1);
}
public int getNext() {
//record a value of an even index of the array
int retValue = arrayOfInts[next];
//get the next even element
next += 2;
return retValue;
}
}
public static void main(String s[]) {
//fill the array with integer values and print out only values of even
indices
DataStructure ds = new DataStructure();
ds.printEven();
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-31-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![The Set Interface
• A Collection represents a group of objects known as its elements. The Collection interface
is used to pass around collections of objects where maximum generality is desired.
• The Java platform contains three general-purpose Set implementations: HashSet, TreeSet,
and LinkedHashSet. HashSet, which stores its elements in a hash table, is the best-
performing implementation; however it makes no guarantees concerning the order of
iteration. TreeSet, which stores its elements in a red-black tree, orders its elements based
on their values; it is substantially slower than HashSet. LinkedHashSet, which is
implemented as a hash table with a linked list running through it, orders its elements
based on the order in which they were inserted into the set (insertion-
order). LinkedHashSet spares its clients from the unspecified, generally chaotic ordering
provided by HashSet at a cost that is only slightly higher.
• Example
36
import java.util.*;
public class FindDups {
public static void main(String[] args) {
Set<String> s = new HashSet<String>();
for (String a : args)
if (!s.add(a))
System.out.println("Duplicate detected: " + a);
System.out.println(s.size() + " distinct words: " + s);
}
}
• Bulk Operations
s1.containsAll(s2)- returns true if s2 is a subset of s1. (s2 is a subset of s1 if
set s1 contains all of the elements in s2.)
s1.addAll(s2) - transforms s1 into the union of s1 and s2. (The union of two sets is the set
containing all of the elements contained in either set.)
s1.retainAll(s2) - transforms s1 into the intersection of s1 and s2. (The intersection of two
sets is the set containing only the elements common to both sets.)
s1.removeAll(s2) - transforms s1 into the (asymmetric) set difference of s1 and s2. (For
example, the set difference of s1 minus s2 is the set containing all of the elements found](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-36-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![The List Interface
38
import java.util.*;
public class Deal {
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("Usage: Deal hands cards");
return;
}
int numHands = Integer.parseInt(args[0]);
int cardsPerHand = Integer.parseInt(args[1]);
// Make a normal 52-card deck.
String[] suit = new String[] { "spades", "hearts", "diamonds", "clubs" };
String[] rank = new String[] { "ace","2","3","4","5","6","7","8", "9","10","jack","queen","king" };
List<String> deck = new ArrayList<String>();
for (int i = 0; i < suit.length; i++)
for (int j = 0; j < rank.length; j++)
deck.add(rank[j] + " of " + suit[i]);
// Shuffle the deck.
Collections.shuffle(deck);
if (numHands * cardsPerHand > deck.size()) {
System.out.println("Not enough cards.");
return;
}
for (int i=0; i < numHands; i++)
System.out.println(dealHand(deck, cardsPerHand));
}
public static <E> List<E> dealHand(List<E> deck, int n) {
int deckSize = deck.size();
List<E> handView = deck.subList(deckSize - n, deckSize);
List<E> hand = new ArrayList<E>(handView);
handView.clear();
return hand;
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-38-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![The Queue Interface
• The Queue Interface - A Queue is a collection for holding
elements prior to processing. Besides basic Collection operations,
queues provide additional insertion, removal, and inspection
operations.
• Each Queue method exists in two forms: (1) one throws an
exception if the operation fails, and (2) the other returns a special
value if the operation fails (either null or false, depending on the
operation). The regular structure of the interface is illustrated in the
following table.
• In the following example program, a queue is used to implement a
countdown timer. The queue is preloaded with all the integer values
from a number specified on the command line to zero, in
descending order. Then, the values are removed from the queue
and printed at one-second intervals.
39
import java.util.*;
public class Countdown {
public static void main(String[] args)
throws InterruptedException {
int time = Integer.parseInt(args[0]);
Queue<Integer> queue = new LinkedList<Integer>();
for (int i = time; i >= 0; i--)
queue.add(i);
while (!queue.isEmpty()) {
System.out.println(queue.remove());
Thread.sleep(1000);
}
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-39-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![The Map Interface
• A Map is an object that maps keys to values. A map cannot
contain duplicate keys: Each key can map to at most one value. It
models the mathematicalfunction abstraction.
• The Java platform contains three general-purpose Map
implementations: HashMap, TreeMap, and LinkedHashMap. Their
behavior and performance are precisely analogous to HashSet,
TreeSet, and LinkedHashSet.
• The basic operations
of Map (put, get, containsKey, containsValue, size, and isEmpty)
behave exactly like their counterparts in Hashtable. The following
program generates a frequency table of the words found in its
argument list. The frequency table maps each word to the number
of times it occurs in the argument list.
40
import java.util.*;
public class Freq {
public static void main(String[] args) {
Map<String, Integer> m = new HashMap<String, Integer>();
// Initialize frequency table from command line
for (String a : args) {
Integer freq = m.get(a);
m.put(a, (freq == null) ? 1 : freq + 1);
}
System.out.println(m.size() + " distinct words:");
System.out.println(m);
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-40-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Generics
• Generics add stability to your code by making more of your bugs
detectable at compile time.
51
public class Box {
private Object object;
public void add(Object object) {
this.object = object;
}
public Object get() {
return object;
}
}
public class BoxDemo1 {
public static void main(String[] args) {
// ONLY place Integer objects into this box!
Box integerBox = new Box();
integerBox.add(new Integer(10));
Integer someInteger = (Integer)integerBox.get();
System.out.println(someInteger);
}
}
public class BoxDemo2 {
public static void main(String[] args) {
// ONLY place Integer objects into this box!
Box integerBox = new Box();
// Imagine this is one part of a large application
// modified by one programmer.
integerBox.add("10"); // note how the type is now String
// ... and this is another, perhaps written
// by a different programmer
Integer someInteger = (Integer)integerBox.get();
System.out.println(someInteger);
}
}
Exception in thread "main"
java.lang.ClassCastException:
java.lang.String cannot be cast to
java.lang.Integer at
BoxDemo2.main(BoxDemo2.java:6)
X](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-51-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
![Generics Class
• Let's update our Box class to use generics. We'll first create
a generic type declaration by changing the code "public class Box"
to "public class Box<T>"; this introduces one type variable,
named T, that can be used anywhere inside the class. In this
context, we also say that T is a formal type parameter of
the Box class.
• To reference this generic class from within your own code, you
must perform a generic type invocation, which replaces T with
some concrete value, such as Integer:
52
//Generic version of the Box class.
public class Box<T> {
private T t; // T stands for "Type"
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}
public class BoxDemo3 {
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
integerBox.add(new Integer(10));
Integer someInteger = integerBox.get(); // no cast!
System.out.println(someInteger);
}
}](/p?url=https%3A%2F%2Fimage.slidesharecdn.com%2Fjavaplatform-170728094734%2F85%2FJava-platform-52-320.jpg&__src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fjava-platform-78338468%2F78338468&__type=image)
Uploaded byVisithan
Java platform
The document provides an overview of the Java programming language and platform. It discusses the Java language basics including variables, operators, control flow statements, and primitive data types. It also covers object-oriented programming concepts, classes and objects, exceptions, and concurrency. Finally, it outlines the Java platform components including the Java Virtual Machine and Java API.
