Documente Academic
Documente Profesional
Documente Cultură
Java
7/3/2018 2
A programming language
Fully buzzword-compliant:
Java is a phenomenon
Took the world by storm in 1995 when
introduced with the HotJava web Browser
Quickly integrated with Netscape browser
1993 Oak project at Sun
small, robust, architecture independent, Object-Oriented, language to
control interactive TV.
didn’t go anywhere
1995 Oak becomes Java
Focus on the web
1996 Java 1.0 available
1997 (March) Java 1.1 - some language changes, much larger library, new
event handling model
1997 (September) Java 1.2 beta – huge increase in libraries including Swing,
new collection classes, J2EE
1998 (October) Java 1.2 final (Java2!)
2000 (April) Java 1.3 final
2001 Java 1.4 final (assert)
2004 Java 1.5 (parameterized types, enum, …) (Java5!)
2005 J2EE 1.5
Java is a general-purpose, high-level
programming language.
The features of Java
Java program is both compiled and interpreted.
Write once, run anywhere
<file>.java <file>.class
Java
Dis-assembler
Source Computer
Internet
Verification
Your computer
verifier
virtual machine
JIT compiled
bytecode code
compiler
interpreter
CPU
Just-In-Time compiler
Translates bytecode into machine code at
runtime
1-time overhead when run initiated
Performance increase 10-30 times
Now the default for most JVM’s
Can be turned off if desired
JIT can apply statistical optimizations based on
runtime usage profile
JVM (J2EE & J2SE)
Well-known Java Virtual Machine.
CVM, KVM (J2ME)
Small devices.
Reduces some VM features to fit resource-
constrained devices.
JCVM (Java Card)
Smart cards.
It has least VM features.
7/3/2018 21
Prerequisites
Required
Substantial Programming Experience
Know how to write, edit, and compile a program
Know how to design algorithms and data structures to solve a problem
Know how to write clean, legible, maintainable code
Know how to debug a program
Reading knowledge of C
You should know what a for loop looks like.
You should know what ints, floats, and doubles are.
You should be able to recognize a function call and its arguments
You do not need to know pointer arithmetic.
You do not need to understand the preprocessor.
You do not need to understand arcana like enums, unions, structs,
bitwise operators, or typedef.
Some basic computer skills
Know how to use the Web, email, and ftp
Know how to take screenshots on your platform of choice
Know how to manipulate directories
Know how to add a program to your path
Know how to set environment variables
7/3/2018 22
Compiled and Interpreted
Usually a computer language is either compiled or interpreted. Java
combines both these approaches thus making Java a two-stage
system. First, Java compiler translates source code into what is
known as bytecode instructions. Bytecodes are not machine
instructions and therefore, in the second stage, Java interpreter
generates machine code that can be directly executed by the
machine that is running the Java program. We can thus say that
Java is both a compiled and an interpreted language.
7/3/2018 23
Platform-Independent and Portable
The most significant features of Java over other languages is its
portability. Java Programs can be easily moved from one computer
to another, anywhere and anytime. Changes and upgrades in
operation systems, processors and system resources will not force
any changes in Java programs. This is the reason why Java has
become a popular language for programming on internet which
interconnects different kinds of systems worldwide. We can
download a Java applet from a remote computer onto our local
system via internet and execute it locally. This makes the internet
an extension of the user`s basic system proving practically
unlimited number of accessible applets and applications.
Java ensures portability in two ways. First, Java compiler
generates bytecode instructions that can be implemented on any
machine. Secondly, the size of the primitive data types are machine
independent.
7/3/2018 24
Object -Oriented
Java is a true object-oriented language. Almost everything in Java is
object. All the program code and data reside within objects and
classes. Java comes with an extensive set of classes, arranged in
packages, that we can use in our programs by inheritance. The
object model in Java is simple and easy to extend.
method
method
data
method method
Object= Data+method
7/3/2018 25
Robust and Secure
Java is a robust language. It provides many safeguards to ensure
reliable code. It has strict compile time and run time checking for
data types. It is designed as a garbage-collected language relieving
the programmers virtually all memory management problems. Java
also incorporates the concept of exception handling which captures
series errors and eliminates any risk of crashing the system.
Security becomes an important issue for a language that is used
for programming on internet. Threat of issues and abuse of
resources is everywhere. Java systems are not only verify all
memory access but also that no viruses are communicated with an
applet. The absence of pointers in Java ensures that programs
cannot gain access to memory locations without proper
authorization.
7/3/2018 26
Distributed
Java is designed for the distribution environment of the internet,
because it handles TCP/IP protocols. In fact, accessing a resource
using a URL is not much different from accessing a file. Java also
supports Remote Method Invocation(RMI). This feature enables a
program to invoke methods across a network.
7/3/2018 27
Simple, Small and Familiar
7/3/2018 28
Multithreaded and Interactive
Java is inherently multi-threaded. A single Java program can have
many different threads executing independently and continuously.
Three Java applets on the same page can run together with each
getting equal time from the CPU with very little extra effort on the
part of the programmer. This makes Java very responsive to user
input. It also helps to contribute to Java's robustness and provides
a mechanism whereby the Java environment can ensure that a
malicious applet doesn't steal all of the host's CPU cycles.
Unfortunately multithreading is so tightly integrated with Java,
that it makes Java rather difficult to port to architectures like
Windows 3.1 or the PowerMac that don't natively support
preemptive multi-threading. There is a cost associated with multi-
threading. Multi-threading is to Java what pointer arithmetic is to
C, that is, a source of devilishly hard to find bugs. Nonetheless, in
simple programs it's possible to leave multi-threading alone and
normally be OK. The Java runtime comes with tools that support
multi process synchronization and construct smoothly running
interactive systems.
7/3/2018 29
High Performance
Java performance is impressive for an interpreted language, mainly
due to the use of intermediate bytecode. According to Sun, Java
speed is comparable to the native C/C++. Java architecture is also
designed to reduce overheads during runtime. Further, the
incorporation of multithreading enhances the overall execution
speed of Java programs.
7/3/2018 30
Dynamic
Java programs carry with them substantial amounts of run-time
type information that is used to verify and resolve accesses to
objects at run time. This makes it possible to dynamically link code
in a safe and expedient manner. This is crucial to the robustness of
the applet environment, in which small fragments of bytecode may
be dynamically updated on a running system.
7/3/2018 31
How Java differs from C & C++ ?
7/3/2018 32
Java`s interaction with the web
Applet Source
Bytecode Code
HTML Document
Output
Web Server
User
7/3/2018 33
Data types in Java
Primitive Non-Primitive
(Intrinsic) (Derived)
Classes
Numeric Non-numeric
Interface
Integer Character
Arrays
Boolean
Floating-point
7/3/2018 34
byte, short, int, and long
for integer values of various sizes
float and double
for real (rational) values of differing accuracy
boolean
for logical (true/false) values
char
for individual characters
Variables & Data types
7/3/2018 36
String: "This is a string literal"
There are no short or byte literals.
Strings are a reference or object type, not a primitive type. However
the Java compiler has special support for strings so this sometimes
appears not to be the case.
class Variables
{
public static void main (String args[]) {
boolean b = true;
int low = 1;
long high = 76L;
long middle = 74;
float pi = 3.1415292f;
double e = 2.71828; String s = "Hello World!";
}
}
7/3/2018 37
Simple Java program
class HelloWorld
{
public static void main (String args[])
{
System.out.println("Hello World!");
}
}
Hello World is very close to the simplest program imaginable. When you
successfully compile and run it, it prints the words "Hello World!" on
your display. Although it doesn't teach very much programming, it gives
you a chance to learn the mechanics of typing and compiling code. The
goal of this program is not to learn how to print words to the terminal.
It's to learn how to type, save and compile a program. This is often a
non-trivial procedure, and there are a lot of things that can go wrong
even if your source code is correct.
7/3/2018 38
To write the code you need a text editor. You can use any text editor
like Notepad, Brief, emacs or vi, Text pad.
You should not use a word processor like Microsoft Word or
WordPerfect since these save their files in a proprietary format and
not in pure ASCII text. If you absolutely must use one of these, be
sure to tell it to save your files as pure text. Generally this will require
using Save As... rather than Save. If you have an integrated
development environment like Borland JBuilder that will include a text
editor you can use to edit Java source code. It will probably change your
words various colors and styles for no apparent reason. Don't worry
about this yet. As long as the text is correct you'll be fine.
When you've chosen your text editor, type or copy the above program
into a new file. For now type it exactly as it appears here. Like C and
unlike Fortran, Java is case sensitive so system.out.println is not the
same as System.out.println. CLASS is not the same as class, and so on.
However, white space is not significant except inside string literals. The
exact number of spaces or tabs you use doesn't matter.
Save this code in a file called HelloWorld.java. Use exactly that name
including case. Congratulations! You've written your first Java program.
7/3/2018 39
Compiling and Running HelloWorld
Notice that you use the .java extension when compiling a file, but
you do not use the .class extension when running a file.
7/3/2018 42
Provide a mechanism for grouping related
classes
package statement
Indicates a class is part of a package
Java assumes all classes in a particular
package are contained in same directory
Java API consists of many predefined packages
7/3/2018 43
import statement
Allows you to use classes contained in other
packages
Package java.lang is implicitly imported to
all Java code
7/3/2018 44
Figure 1-1
A simple Java Program 31
Data type that specifies data and methods
available for instances of the class
An object in Java is an instance of a class
Class definition includes
Optional subclassing modifier
Optional access modifier
Keyword class
Optional extends clause
Optional implements clause
Class body
7/3/2018 46
Every Java class is a subclass of either
Another Java class
Object class
new operator
Creates an object or instance of a class
33
7/3/2018
Figure 1-2
Components of a class 48
Class members that are either variables or
constants
Data field declarations can contain
Access modifiers
Use modifiers
Modules
7/3/2018 35
Figure 1-3
Modifiers used in data field declarations 36
Used to implement operations
Should perform one well-defined task
Method modifiers
Access modifiers and use modifiers
Valued method
Returns a value
Body must contain return expression;
37
7/3/2018
Figure 1-4
Modifiers used in a method declaration 1-52
Syntax of a method declaration
access-modifier use-modifiers return-type
method-name (formal-parameter-list) {
method-body
}
Arguments are passed by value
Except for objects and arrays
A reference value is copied instead
7/3/2018 1-54
Data fields and methods declared public
Name the object, followed by a period, followed
by member name
Members declared static
Use the class name, followed by a period,
followed by member name
7/3/2018 1-55
Java application
Collection of classes
One class contains the main method
Java programs can also be written as applets
7/3/2018 1-56
Comment line
Begins with two slashes (//)
Continues until the end of the line
Multiple-line comment
Begins with /* and ends with */
Useful for debugging
Cannot contain another multiple-line comment
javadoc comments
Begins with /** and ends with */
7/3/2018 1-57
Types of objects must be declared before
they are used
7/3/2018 1-66
Character constants
Enclosed in single quotes
Default data type is char
Literal character strings
Sequence of characters enclosed in double quotes
7/3/2018 1-67
Have values that do not change
Declared as a variable but using the keyword
final
7/3/2018 1-68
Expressions
Combination of variables, constants, operators,
and parentheses
Assignment statement
Example: radius = r;
Arithmetic expression
Combine variables and constants with arithmetic
operators and parentheses
Arithmetic operators: *, /, %, +, -
7/3/2018 1-69
Relational expressions
Combine variables and constants with relational,
or comparison, and equality operators and
parentheses
Relational orcomparison operators: <, <=, >=. >
Equality operators: ==, !=
7/3/2018 1-70
Logical expressions
Combine variables and constants of arithmetic
types, relational expressions with logical
operators
Logical operators: &&, ||
Evaluate to true or false
Short-circuit evaluation
Evaluates logical expressions from left to right
Stops as soon as the value of expression is apparent
7/3/2018 1-71
Implicit type conversions
Occur during assignment and during expression
evaluation
Right-hand side of assignment operator is
converted to data type of item on left-hand side
Floating-point values are truncated not rounded
Integral promotion
Values of type byte, char, or short are converted
to int
Conversion hierarchy
int → long → float → double
7/3/2018 1-72
Explicit type conversions
Possible by means of a cast
Cast operator
Unary operator
Formed by enclosing the desired data type within
parentheses
Multiple assignments
Embed assignment expressions within assignment
expressions
Example: a = 5 + (b = 4)
Evaluates to 9 while b is assigned 4
7/3/2018 1-73
Other assignment operators
-=
*=
/=
%=
++
--
7/3/2018 1-74
Operator Order of Operation
evaluation
() left - right parenthesis for
explicit grouping
* / % left - right multiplication,
division, modulus
+ - left - right addition,
subtraction
= right - left assignment
Operator Order of Operation
evaluation
++ -- right - left preincrement, predecrement
++ -- right - left postincrement, postdecrement
* / % left - right multiplication, division,
modulus
+ - left - right addition or String
concatenation, subtraction
= += -= right - left assignment
*= /= %=
Numbers without fractional parts
3, 47, -12
Variables can be used to store integers using an
assignment statement
int daysInWeek;
daysInWeek = 7;
In general integer variables may be used any place
an integer literal can be
import CSLib.*;
Inputbox in;
int i;
in = newInputBox();
in.setPrompt(“Enter an integer: “);
i = in.readInt();
Symbol Operation Example
+ Addition 45 + 5 = 50
- Subtraction 657 – 57 = 600
* Multiplication 7000 * 3 = 2100
/ Division 10 / 3 = 3
% Remainder 10 % 3 = 1
1. Evaluate all subexpressions in parentheses
2. Evaluate nested parentheses from the inside out
3. In the absence of parentheses or within
parentheses
a. Evaluate *, /, or % before + or –
b. Evaluate sequences of *, /, and % operators from left to
right
c. Evaluate sequences of + and – operators from left to
right
Example 1
6 + 37 % 8 / 5 is the same as
6 + ((37 % 8) / 5) =
6 + ( 5 / 5) = 7
Example 2
6 + 37 % (8 / 5) =
6 + 37 % 1 =
6+0=6
Self-assignment
temperature = temperature + 10;
Increment
cent++;
equivalent to
cent = cent + 1;
Decrement
cent--;
equivalent to
cent = cent - 1;
May be used to give variables initial values
int x = 5;
int y = 6;
Can be written more concisely
int x = 5,
y = 6;
Can use expressions on the right hand side
int x = 5,
y = x + 1;
Useful when you want a variable whose value
never changes
Use the modifier final in its declaration
Example
final int US_Population = 278058881;
Numbers with fractional parts
3.14159, 7.12, 9.0, 0.5e001, -16.3e+002
Declared using the type double
double pricePerPound = 3.99;
taxRate = 0.05;
shippingCost = 5.55;
The initialization part of the declaration is optional
Symbol Operation Example
+ Addition 4.50e01 + 5.30e00 =
5.03e01
- Subtraction 6.57e02 – 5.7oe01 =
6.00e02
* Multiplication 7e02 * 3.0e00 =
2.1e04
/ Division 9.6e01 / 2e01 =
4.8e00
import CSLib.*;
Inputbox in;
double temp;
in = newInputBox();
in.setPrompt(“Enter a real number: “);
temp = in.readDouble();
Type Size Minimum Value Maximum Value
in Bytes
Example declarations:
int testGrade;
int numPlayers, highScore, diceRoll;
short xCoordinate, yCoordinate;
byte ageInYears;
long cityPopulation;
Numbers with fractional parts
Type Size Minimum Value Maximum Value
in Bytes
float 4 1.4E-45 3.4028235E38
double 8 4.9E-324 1.7976931348623157E308
Example declarations:
float salesTax;
double interestRate;
double paycheck, sumSalaries;
One Unicode character (16 bits - 2 bytes)
Type Size Minimum Value Maximum Value
in Bytes
char 2 character character
encoded as 0 encoded as FFFF
Example declarations:
char finalGrade;
char newline, tab, doubleQuotes;
Two values only:
true
false
Used for decision making or as "flag" variables
Example declarations:
boolean isEmpty;
boolean passed, failed;
Assignment operator =
Value on the right of the operator is assigned to the
variable on the left
Value on the right can be a literal (text representing a
specific value), another variable, or an expression
(explained later)
Syntax:
dataType variableName = initialValue;
Or
dataType variable1 = initialValue1,
variable2 = initialValue2, …;
int, short, byte
Optional initial sign (+ or -) followed by digits
0 – 9 in any combination.
long
Optional initial sign (+ or -) followed by digits
0–9 in any combination, terminated with
an L or l.
***Use the capital L because the lowercase l
can be confused with the number 1.
float
Optional initial sign (+ or -) followed by a
floating-point number in fixed or scientific
format, terminated by an F or f.
double
Optional initial sign (+ or -) followed by a
floating-point number in fixed or scientific
format.
Commas, dollar signs, and percent signs (%)
cannot be used in integer or floating-point
literals
char
Any printable character enclosed in single quotes
A decimal value from 0 – 65535
'\m' , where \m is an escape sequence. For
example, '\n' represents a newline, and '\t'
represents a tab character.
boolean
true or false
See Example 2.2 Variables.java
Syntax:
dataType variable2 = variable1;
Rules:
1. variable1 needs to be defined before this
statement appears in the source code
2. variable1 and variable2 need to be compatible
data types; in other words, the precision of variable1
must be lower than or equal to that of variable2.
Any type in right column can be assigned to type in left column:
out.println(s1.indexOf(“s”)); // prints 6
out.println(s1.indexOf(“x”)); // prints -1
out.println(s1.length()); // prints 22
out.println(s1.substring(8,14));
// prints ‘a test’
import CSLib.*;
Inputbox in;
String input;
in = newInputBox();
in.setPrompt(“Enter a real number: “);
input = in.readString();
Any key you type on the keyboard generates a
character which may or may not be displayed on the
screen (e.g. nonprinting characters)
Characters are a primitive type in Java and are not
equivalent to strings
Examples
char vitamin = ‘’A’,
chromosome = ‘’y’,
middleInitial = ‘’N’;
‘A’, … ,‘Z’ Uppercase letters
‘a’, … ,‘z’ Lowercase letters
‘0’, … , ‘9’ Digits
‘.’,’,’,’!’,’”’,etc. Punctuation Marks
‘ ’ Blank
‘\n’ New line
‘\t’ Tab
‘\\’ Backslash
‘\’’ Single Right Quote
Misleading compiler error messages
Syntax errors indicated on one-line may actually reflect an
error made on an earlier line
Capitalization errors
Java is case sensitive, identifier names must use the same
capitalization rules each time
Logic Errors
Program appears to run correctly, but on closer inspection
the wrong output is displayed
Unlike the integers mathematics the type int is
not infinitely large and it is possible to compute a
value incorrectly because the value is too large to be
stored in an int variable storage location
Unlike the real numbers in mathematics the type
double is not dense, it is not always possible to test
double expressions for equality and obtain a
correct result due to rounding errors in
representations
Java will automatically convert int expressions to double
values without loss of information
int i = 5;
double x = i + 10.5;
To convert double expressions to int requires a
typecasting operation and truncation will occur
i = (int) (10.3 * x)
To round-up instead of truncating add 0.5
i = (int) (10.3 * x + 0.5)
It is important to remember that “13” and 13 are not
the same
Examples
out.println(“4” + “5”) // prints 45
out.println(“4” + 5) // prints 45
out.println(4 + 5) // prints 9
It is legal to assign a char to an int variable
int i = ‘a’; // assigns 97 to i
It is legal to assign an int to an char variable
char c = 97; // assigns ‘a’ to c
It is possible to perform arithmetic on char
variables
char ch = ‘a’;
ch = ch + 1; // assigns ‘b’ to ch
Collection of elements with the same data type
Array elements have an order
Support direct and random access
One-dimensional arrays
Declaration example
final int DAYS_PER_WEEK = 7;
double [] maxTemps = new double[DAYS_PER_WEEK];
Length of an array is accessible using data field
length
Use an index or subscript to access an array element
7/3/2018 1-114
Figure 1-7
One-dimensional array of at most seven elements
1-115
One-dimensional arrays (continued)
Initializer list example
double [] weekDayTemps = {82.0, 71.5, 61.8, 75.0,
88.3};
You can also declare array of object references
Multidimensional arrays
Use more than one index
Declaration example
final int DAYS_PER_WEEK = 7;
final int WEEKS_PER_YEAR = 52;
double[][] minTemps = new
double[DAYS_PER_WEEK][WEEKS_PER_YEAR];
7/3/2018 1-116
Figure 1-8
A two-dimensional array
1-117
Passing an array to a method
Declare the method as follows:
public double averageTemp(double[] temps, int n)
Invoke the method by writing:
double avg = averageTemp(maxTemps, 6);
Location of array is passed to the method
Cannot return a new array through this value
Method can modify content of the array
7/3/2018 1-118
The if statement Nested if
if (expression)
if (expression) {
statement1
statement1
or }
if (expression) else if (expression) {
statement1 statement2
else }
statement2 else {
statement3
} // end if
7/3/2018 1-119
The switch statement
switch (integral expression) {
case 1:
statement1;
break;
case 2, case 3:
statement2;
case 4:
statement3;
break;
default:
statement4;
} //end of switch
7/3/2018 1-120
The while statement
while (expression) {
statement
}
statement is executed as long as
expression is true
statement may not be executed at all
continue expression
Stops the current iteration of the loop and begins
the next iteration at the top of the loop
7/3/2018 1-121
The for statement
for (initialize; test; update)
statement
statement is executed as long as test is
true
for statement is equivalent to a while
statement
The for loop and arrays
for (ArrayElementType variableName : arrayName)
statement
7/3/2018 1-122
The do statement
do {
statement
} while (expression);
statement is executed until
expression is false
do statement loops at least once
7/3/2018 1-123
The Object class
Java supports a single class inheritance hierarchy
With class Object as the root
7/3/2018 1-124
String classes
Class String
Declaration examples:
String title;
String title = “Walls and Mirrors”;
Assignment example:
Title = “Walls and Mirrors”;
String length example:
title.length();
Referencing a single character
title.charAt(0);
Comparing strings
title.compareTo(string2);
7/3/2018 1-125
String classes (continued)
Class String
Concatenation example:
String monthName = "December";
int day = 31;
int year = 02;
String date = monthName + " " + day + ",
20" + year;
7/3/2018 1-126
String classes (continued)
Class StringBuffer
Creates mutable strings
Provides same functionality as class String
More useful methods
public StringBuffer append(String str)
public StringBuffer insert(int offset,
String str)
public StringBuffer delete(int start, int
end)
public void setCharAt(int index, char ch)
public StringBuffer replace(int start, int
end, String str)
7/3/2018 1-127
String classes (continued)
Class StringTokenizer
Allows a
program to break a string into pieces or tokens
More useful methods
public StringTokenizer(String str)
public StringTokenizer(String str, String
delim)
public StringTokenizer(String str, String
delim, boolean returnTokens)
public String nextToken()
public boolean hasMoreTokens()
7/3/2018 1-128
Exception
Handles an error during execution
Throw an exception
To indicate an error during a method execution
Catch an exception
To deal with the error condition
7/3/2018 1-129
Java provides try-catch blocks
To handle an exception
Place statement that might throw an
exception within the try block
Must be followed by one or more catch blocks
When an exception occurs, control is passed to
catch block
Catch block indicates type of exception you
want to handle
7/3/2018 1-130
try-catch blocks syntax
try {
statement(s);
}
catch (exceptionClass identifier) {
statement(s);
}
7/3/2018 1-131
Figure 1-9
Flow of control in a simple Java application
1-132
Types of exception
Checked exceptions
Instances of classes that are subclasses of
java.lang.Exception
Must be handled locally or thrown by the method
Used when method encounters a serious problem
Runtime exceptions
Occur when the error is not considered serious
Instances of classes that are subclasses of
java.lang.RuntimeException
7/3/2018 1-133
The finally block
Executed whether or not an exception is thrown
Can be used even if no catch block is used
Syntax
finally {
statement(s);
}
7/3/2018 1-134
throws clause
Indicates a method may throw an exception
If an error occurs during its execution
Syntax
public methodName throws
ExceptionClassName
throw statement
Used to throw an exception at any time
Syntax
throw new exceptionClass(stringArgument);
You can define your own exception class
7/3/2018 1-135
Input and output consist of streams
Streams
Sequence of characters that either come from or go
to an I/O device
InputStream - Input stream class
PrintStream - Output stream class
java.lang.System provides three stream variables
System.in – standard input stream
System.out – standard output stream
System.err – standard error stream
7/3/2018 1-136
Prior to Java 1.5
BufferedReader stdin = new BufferedReader(new
InputStreamReader(System.in));
7/3/2018 1-137
Java 1.5 – The Scanner class
int nextValue;
int sum=0;
Scanner kbInput = new Scanner(System.in);
nextValue = kbInput.nextInt();
while (nextValue > 0) {
sum += nextValue;
nextValue = kbInput.nextInt();
} // end while
kbInput.close();
7/3/2018 1-138
Java 1.5 – The Scanner class (continued)
More useful next methods
String next();
boolean nextBoolean();
double nextDouble();
float nextFloat();
int nextInt();
String nextLine();
long nextLong();
short nextShort();
7/3/2018 1-139
Methods print and println
Write character strings, primitive types, and
objects to System.out
println terminates a line of output so next one
starts on the next line
When an object is used with these methods
Return value of object’s toString method is
displayed
You usually override this method with your own
implementation
Problem
Lack of formatting abilities
7/3/2018 1-140
Method printf
C-style formatted output method
Syntax
printf(String format, Object... args)
Example:
String name = "Jamie";
int x = 5, y = 6;
int sum = x + y;
System.out.printf("%s, %d + %d = %d",
name, x, y, sum);
//produces output Jamie, 5 + 6 = 11
7/3/2018 1-141
Figure 1-10
Formatting example with printf
1-142
File
Sequence of components of the same type that
resides in auxiliary storage
Can be large and exists after program execution
terminates
Files vs. arrays
Files grow in size as needed; arrays have a fixed size
Files provides both sequential and random access;
arrays provide random access
File types
Text and binary (general or nontext) files
7/3/2018 1-143
Designed for easy communication with people
Flexible and easy to use
Not efficient with respect to computer time and
storage
End-of-line symbol
Creates the illusion that a text file contains lines
End-of-file symbol
Follows the last component in a file
Scanner class can be used to process text files
7/3/2018 1-144
Figure 1-11
A text file with end-of-line and end-of-file symbols
1-145
Example
String fname, lname;
int age;
Scanner fileInput;
File inFile = new File("Ages.dat");
try {
fileInput = new Scanner(inFile);
while (fileInput.hasNext()) {
fname = fileInput.next();
lname = fileInput.next();
age = fileInput.nextInt();
age = fileInput.nextInt();
System.out.printf("%s %s is %d years old.\n",
fname, lname, age);
} // end while
fileInput.close();
} // end try
catch (FileNotFoundException e) {
System.out.println(e);
} // end catch
7/3/2018 1-146
Open a stream to a file
Before you can read from or write to a file
Use class FileReader
Constructor throws a FileNotFoundException
7/3/2018 1-147
Example
BufferedReader input;
StringTokenizer line;
String inputLine;
try {
input = new BufferedReader(new FileReader("Ages.dat"));
while ((inputLine = input.readLine()) != null) {
line = new StringTokenizer(inputLine);
// process line of data
...
}
} // end try
catch (IOException e) {
System.out.println(e);
System.exit(1); // I/O error, exit the program
} // end catch
7/3/2018 1-148
File output
You need to open an output stream to the file
Use class FileWriter
Stream is usually embedded within an instance of
class PrintWriter
That provides methods print and println
7/3/2018 1-149
Example
try {
PrintWriter output = new PrintWriter(new
FileWriter("Results.dat"));
output.println("Results of the survey");
output.println("Number of males: " + numMales);
output.println("Number of females: " +
numFemales);
// other code and output appears here...
} // end try
catch (IOException e) {
System.out.println(e);
System.exit(1); // I/O error, exit the program
} // end catch
7/3/2018 1-150
Closing a file
Syntax
myStream.close();
Adding to a text file
When opening a file, you can specify if file should
be replaced or appended
Syntax
PrintWriter ofStream = new
PrintWriter(new
FileOutputStream("Results.dat",
true));
7/3/2018 1-151
Data persistence
Data stored in a file for later use
Object serialization
Java mechanism to create persistent objects
Serialization
Transforming an object into a sequence of bytes
that represents the object
Serialized objects can be stored to files for later
use
7/3/2018 1-152
Deserialization
Reverse process
Interface java.io.Serializable
Needed to save an object using object
serialization
Contains no methods
Objects referenced by a serialized object are
also serialized
As long as these objects also implement the
Serializable interface
7/3/2018 1-153
Java packages
Provide a mechanism for grouping related classes
import statement
Required to use classes contained in other packages
Object in Java is an instance of a class
Class
Data type that specifies data and methods available
Data fields are either variables or constants
Methods implement object behavior
Method parameters are passed by value
7/3/2018 1-154
Comments in Java
Comment lines
Multiple-line comments
Java identifier
Sequence of letters, digits, underscores, and
dollar signs
Primitive data types categories
Integer, character, floating point, and boolean
Java reference
Used to locate an object
7/3/2018 1-155
Define named constant with final keyword
Java uses short-circuit evaluation for logical
and relational expressions
Array
Collection of references that have the same data
type
Selection statements
if and switch
Iteration statements
while, for, and do
7/3/2018 1-156
String
Sequence of characters
String classes: String, StringBuffer,
StringTokenizer
Exceptions
Used to handle errors during execution
Files are accessed using Scanner class or
streams
Data persistence and object serialization
7/3/2018 1-157