Start Lecture #1
I start at 0 so that when we get to chapter 1, the numbering will agree with the text.
There is a web site for the course. You can find it from my home page, which is http://cs.nyu.edu/~gottlieb
The course text is Liang,
Introduction to Java Programming (Brief Version)
,
Eighth Edition (8e)
Replyto contribute to the current thread, but NOT to start another topic.
top post, that is, when replying, I ask that you either place your reply after the original text or interspersed with it.
musttop post.
Grades are based on the labs and the final exam, with each
very important.
The weighting will be approximately
(but see homeworks below).
I use the upper left board for lab/homework assignments and announcements. I should never erase that board. Viewed as a file it is group readable (the group is those in the room), appendable by just me, and (re-)writable by no one. If you see me start to erase an announcement, let me know.
I try very hard to remember to write all announcements on the upper left board and I am normally successful. If, during class, you see that I have forgotten to record something, please let me know. HOWEVER, if I forgot and no one reminds me, the assignment has still been given.
I make a distinction between homeworks and labs.
Labs are
Homeworks are
Homeworks are numbered by the class in which they are assigned. So any homework given today is homework #1. Even if I do not give homework today, the homework assigned next class will be homework #2. Unless I explicitly state otherwise, all homeworks assignments can be found in the class notes. So the homework present in the notes for lecture #n is homework #n (even if I inadvertently forgot to write it to the upper left board).
You may solve lab assignments on any system you wish, but ...
request receiptfeature from home.nyu.edu or mail.nyu.edu and select the
when deliveredoption.
I sent it ... I never received itdebate. Thank you.
I believe you all have accounts on i5.nyu.edu. Your username and password should be the same as on home.nyu.edu (at least that works for me).
Good methods for obtaining help include
You labs must be written in Java.
Incomplete
The rules for incompletes and grade changes are set by the school and not the department or individual faculty member. The rules set by CAS can be found in http://cas.nyu.edu/object/bulletin0608.ug.academicpolicies.html. They state:
The grade of I (Incomplete) is a temporary grade that indicates that the student has, for good reason, not completed all of the course work but that there is the possibility that the student will eventually pass the course when all of the requirements have been completed. A student must ask the instructor for a grade of I, present documented evidence of illness or the equivalent, and clarify the remaining course requirements with the instructor.
The incomplete grade is not awarded automatically. It is not used when there is no possibility that the student will eventually pass the course. If the course work is not completed after the statutory time for making up incompletes has elapsed, the temporary grade of I shall become an F and will be computed in the student's grade point average.
All work missed in the fall term must be made up by the end of the following spring term. All work missed in the spring term or in a summer session must be made up by the end of the following fall term. Students who are out of attendance in the semester following the one in which the course was taken have one year to complete the work. Students should contact the College Advising Center for an Extension of Incomplete Form, which must be approved by the instructor. Extensions of these time limits are rarely granted.
Once a final (i.e., non-incomplete) grade has been submitted by the instructor and recorded on the transcript, the final grade cannot be changed by turning in additional course work.
This email from the assistant director, describes the policy.
Dear faculty,
The vast majority of our students comply with the
department's academic integrity policies; see
www.cs.nyu.edu/web/Academic/Undergrad/academic_integrity.html
www.cs.nyu.edu/web/Academic/Graduate/academic_integrity.html
Unfortunately, every semester we discover incidents in
which students copy programming assignments from those of
other students, making minor modifications so that the
submitted programs are extremely similar but not identical.
To help in identifying inappropriate similarities, we
suggest that you and your TAs consider using Moss, a
system that automatically determines similarities between
programs in several languages, including C, C++, and Java.
For more information about Moss, see:
http://theory.stanford.edu/~aiken/moss/
Feel free to tell your students in advance that you will be
using this software or any other system. And please emphasize,
preferably in class, the importance of academic integrity.
Rosemary Amico
Assistant Director, Computer Science
Courant Institute of Mathematical Sciences
The university-wide policy is described here
Introductionwith a Programming Prerequisite
How weird is this?
The formal prerequisite for 0101 is 0002, which teaches the Python programming language. (I had a tiny, insignificant part in the development of Python when I first arrived at NYU, 30 years ago.)
If instead of taking 0202, you have programmed in some other language (say C/C++), that is fine.
If, however, you are already a wizard Java programmer (or even a mere expert), you are taking the wrong course—you would be wasting somebody's money and, more significantly, wasting much of your time.
This course, indeed the CS major sequence, emphasizes software, i.e., computer programs, rather than hardware, i.e., the physical components of a computer.
We teach a little hardware in 201, Computer Systems Organization, giving a high-level, non-detailed view, and present much more in 436, Computer Architecture.
In general, the NYU course sequence offers a top-down view: we first show you how to program in high-level languages such as Java and Python, later we present the assembly language that is essentially the language understood by the computer itself, and later still we describe the how the electronic components in a computer are able to actually execute these programs.
Many universities follow this approach. Others provide a bottom-up sequence beginning with the components, then low-level (assembly) languages, and then high-level languages.
Computers store and process data.
Modern computers store the programs on the same media as the data.
Figure 1.1 in the book is quite dated: It shows the design of 1980s computers. Modern machines do not have a single bus over which all information must travel. Compare the diagrams in sections 1.3 and 1.3.6 of my OS class note.
The CPU contains the electronic components that actually execute the instructions given to the computer.
First of all the CPU decodes the instruction (i.e., determines what is to be done, for example the contents of two CPU memory units called registers are to be added and the result placed in another register). Other instructions require the CPU to access additional components of the computer, e.g., the central memory.
In addition to determining the action needed, the CPU performs many of the operations required. For example the ALU (Arithmetic/Logic Unit) portion of the CPU contains an adder and thus performs the register add mentioned above.
Within a computer all data is stored as a sequence of bits, each of which can take on one of two values. Computers today mostly represent numbers as words, each consisting of 32 or 64 bits.
A 32-bit word can take on 232 (approximately 4 billion) different values.
I very much believe that you should remember just one value,
210=1024.
Then you can deduce that
232 = 22*230
= 4*23*10 =
4*210*210*210 =
4*1024*1024*1024,
which is a little more than 4*1000*1000*1000 = 4,000,000,000.
Modern computers cannot access a single bit of memory. They can access a single word and most computers (including all those we shall consider) can access a smaller unit called a byte, which consists of 8 bits.
Since a byte is the smallest unit of memory that can be referred to directly, modern computers are called byte-addressable.
Since the bytes can be accessed in any order (not just sequentially in order byte #1, byte #2, ...), the memory is said to support random access and is called random access memory or RAM.
Computers can access any byte in RAM quite quickly, which is wonderful. However, there are at least three problems with RAM.
Today's (personal) computers have around a gigabyte GB of RAM.
The exact size of a gigabyte is controversial.
It is either a billion (109) bytes or the binary
equivalent
(230).
When you purchase a gigabyte of RAM you are getting the latter, but
when you purchase a gigabyte of disk storage you are getting only
the former.
It is clearly nonsensical that an 80GB disk cannot
hold 10 copies of the data contained in an 8GB RAM.
Nonetheless, it is true.
In fact, the proper
terminology is that the disk contains
only 80GiB (abbreviating 80 gibibytes) not 80GB.
However common usage is still 80GB.
Although a gigabyte of RAM is huge by historical standards, it is still insufficient to hold all the data we want on a computer system. For example, my (lavishly equipped) laptop has 8GB, which can store one movie in standard definition (one DVD) but not one hi-def movie (one blu-ray).
Disks (i.e., so called hard drives
) provide several hundred
times more bytes per dollar than does RAM.
Disks are not byte addressable (i.e., you can't refer to a single
byte store on a disk).
Instead the smallest addressable unit is called a sector,
which is typically 512 bytes.
Disks form the primary storage medium for most computer systems that
are at least as big as a laptop.
Current RAM does not maintain its contents when the power is shut off and hence is not suitable for storing permanent data. Hard drives, various types of CDs, and flash storage do maintain their contents without power.
The book's words are a little garbled.
CDs come in basically three flavors: read-only, write-once, and
rewritable.
(In this course CDs refer to data CDs
; audio CDs organize the
data stored in a different manner).
DVDs and Blu-ray are (for us) simply higher density CDs (in 202 you
will learn that the filesystems stored on DVDs differs from that of
CDs).
blanked) and then CD-RW can be rewritten. The user cannot simply rewrite a single word or byte, leaving the remaining data unchanged. So it is not rewritable the way RAM is.
Flash drives are physically small storage units (they are often
called thumb drives
due to their size and shape).
Unlike disks and CDs, flash drives have no moving parts and are thus
potentially much faster.
Like disks they are not byte addressable; their smallest accessible
unit is called a block.
Blocks can be rewritten a large number
of times.
However, the large number
is not large enough to be ignored.
Flash drives are sometimes called solid-state disks
.
These are becoming less important and we will not discuss them.
RAM cannot be moved easily from one machine to another. You would lose the data present (due to volatility) and if done often or carelessly, might damage the device. Some disk drives (called external disks) can be transported, but CDs and flash drives are much better in this regard.
Note the CPU-centric terminology. Devices that produce output, such as mice and keyboards, are called input devices and devices that accept input such as monitors are called output devices.
How does moving a mouse, cause the pointer to move?
How does a keyboard send a 'X' as opposed to a 'x'?
Screen resolution and dot pitch of a monitor are defined correctly in the book, but the statements about quality and clarity are too simplistic; the size of the monitor must be considered as well.
We will not study these. The book is somewhat dated here. Some homes (e.g., mine) have LANs; a typical NIC now is at least 100 megabits per second not 10 (many are now 1000 megabits per second).
I assume you have written programs (perhaps in 0002) and thus know what they are..
An operating system (OS) is a software system that raises the level
of abstraction provided by the hardware to a more convenient
virtual machine
that other software can then use.
For example, when we write programs accessing disk files, we do not
worry about (or even have knowledge of) how the data is actually
stored on the disk.
Indeed, they very concept of a file is foreign to a disk and is an
abstraction provided by the OS.
The OS also acts as a resource manager
permitting multiple
users to share the hardware resources.
Naturally much more detail is provided in my OS class notes. A short summary is in section 1.1 of those notes.
Java is a very popular, modern, general purpose, programming language. It comes with an extensive standard library that aids in writing graphical programs, especially those, called applets, that are invoked from browsers, e.g., firefox.
Java has extensive support for the modern software development
methodology called object-oriented programming
.
Java is a full-featured, and thus large, programming language. In its entirety, Java is not simple; but we will be able to avoid most of the tricky parts.
Any programming language needs a detailed, precise specification describing the syntax and semantics of the language. It is basically the rules that determine a legal Java program. We will not need this level of precision.
Changing the specification essentially changes the language. The Java spec is stable.
The Application Program Interface (API) is defined by the standard library that comes with Java. It is comparatively easy to extend the API—write another library routine—and this does occur.
There are several versions of Java; we use Java SE 1.6, which we will just call Java.
The programs used to compile and run Java programs are part of the Java Development Toolkit (JDK).
Instead of using the JDK, one can use an Integrated Development Environment (IDE). Several IDEs are available. I will use only the JDK. You may develop your labs using either the JDK or an IDE, but the final product must be a Java program that can be run with just the JDK
// Hello world in Java
public class Hello {
public static void main (String[] args) {
System.out.println("Hello, world.");
}
}
// Hello world in the C programming language
#include <stdio.h>
void main(int argc, char *argv[]) {
printf("Hello, world.\n");
}
On the right we see a simple Java program that prints the sentence
Hello, world.
.
This program is contained in the file Hello.Java.
For comparison, the corresponding C program is below it. I put this program in a file called hello.c, but it could have been in a file called xyxxy.c (the .c is important).
Although they may look different, these two programs are basically the same. We now discuss briefly the Java version, line by line.
Homework: 1.1, 1.3.
For the benefit of those students with the 7th edition, here are the problems.
1.1 (Displaying three messages) Write a program that displays Welcome to Java, Welcome to Computer Science, and Programming is fun.
1.3 (Displaying a pattern) Write a program that displays the following pattern:
J A V V A
J A A V V A A
J J AAAAA V V AAAAA
J J A A V A A
Unless otherwise stated homeworks are from the
Programming Exercises
at the end of the current chapter.
They are not from the Review Questions
Start Lecture #2
A Java program is created using a text editor. I use emacs. Others use vi, notepad, or a variety of alternatives. One possibility is the editor included with a Java IDE.
Java programs are compiled using a Java compiler. The standard compiler included with a JDK is called javac. To compile our Hello program (in the file Hello.java), one would write
javac Hello.java
Javac translates Java into an intermediate form normally called
bytecode.
This bytecode is portable.
That is the bytecode produced on one type of computer can be
executed on a computer of a different type.
The bytecode is placed in a so-called class file, in this case the file Hello.class
Our C version of Hello, if contained in the file Hello.c, could be compiled via the command
cc -o Hello Hello.c
The resulting file Hello is not portable.
Instead it has instructions suitable for one specific machine type
(and software system).
Portability of Java bytecode has been obtained by defining a virtual machine on which to run the bytecode. This virtual machine is called the JVM, Java Virtual Machine.
Each platform (hardware + software, e.g., Intel x86 + MacOS or SPARC + Solaris) on which Java is to run includes an emulator of this virtual machine. Somewhat ambiguously, the emulator of the Java Virtual Machine is itself also called the JVM.
The penalty for this portability is that executing bytecode by the (typically software) JVM is not as efficient as executing non-portable, so-called native, code tailored for a specific machine.
Since essentially no hardware/OS can execute Java bytecode directly, another program is run and is given the bytecode as data. This program is typically included in any Java IDE. For the JDK the program is called java (lower case).
For our example the bytecode located in the file Hello.class is executed via the JDK command
java Hello
(Note that we must write Hello and not Hello.class.)
// Hello world in Java -- gui version
public class HelloGui {
public static void main (String[] args) {
javax.swing.JOptionPane.showMessageDialog(null, "Hello, world.");
}
}
Java comes with a large library of predefined functions. The top example on the right shows how just changing the output function causes a dialog box to be produced. Naturally, this code only works on a graphical display.
Another difficulty is that actually explaining how the dialog box appears on the screen is quite complicated, involving widgets, fill-rectangle, and other graphics concepts.
// Hello world in Java -- pedantic version
public class HelloPedantic {
public static void main (String[] args) {
java.lang.System.out.println("Hello, world.");
}
}
In fact, our original hello example used a shortcut. The class System is actually found in the package java.lang (which is searched automatically by javac). The bottom example shows the program without using this shortcut.
These have answers on the web in the companion. See the book for details. I tried it and it works.
If you cannot understand an answer, ask! A good question for the mailing list.
Let's solve quadratic the equations Ax2 + Bx + C = 0. Computational problems like this often have the form
For our first example we will hard-wire
the inputs and not
do it again.
What is the input?
Ans: The three coefficients A, B, and C.
How is the output computed?
Ans: -B +- sqrt(B2-4AC)
What about sqrt of a negative number?
What about it?
Mathematically, you get complex numbers.
We will choose A, B, C avoiding this case.
A better program would check.
public class Quadratic1 {
public static void main (String[] args) {
double A, B, C; // double precision floating point
A = 1.0;
B = -3.0;
C = 2.0;
double discriminant = B*B - 4.0*A*C;
// We assume discriminant >= 0 for now
double ans1 = (-B + Math.pow(discriminant,0.5))/(2.0*A);
double ans2 = (-B - Math.pow(discriminant,0.5))/(2.0*A);
System.out.println("The roots are " + ans1 + " and " + ans2);
}
}
The program is on the right. Note the variables are declared to have type double. This is the normal representation of real numbers in Java.
We can assign values to variables either when we declare them or separately. Both are illustrated in the example.
Note that the first two lines and the last two lines are the same as from the first example.
How does the println work?
In particular, what are we adding?
Ans: The + is overloaded
.
X+Y means add if X and Y are numbers it means concatenate if X and Y
are strings.
But in the program we have both strings and numbers.
When the operands are mixed, numbers are converted to strings.
The name double is historical.
On early systems real numbers were called
floating point because the decimal point was not in a fixed
location but instead could float.
This way of writing real numbers is often called
scientific notation
.
The keyword double signifies that the variable
would be given double the amount of storage as a would be given to
a variable declared to be float.
The previous example was quite primitive. In order to solve a different quadratic equation it is necessary to change the program, recompile, and re-run.
In this section we will save the first two steps, by having the program read in the coefficients A, B, and C. Later we will use a loop to enable one run to solve many quadratic equations.
On the right is the program in a pedantic style. We show the program as it would normally be written below.
public class Quadratic2Pedantic {
public static void main (String[] Args) {
double A, B, C;
double discriminant, ans1, ans2;
java.util.Scanner getInput;
getInput = new java.util.Scanner(java.lang.System.in);
A = getInput.nextDouble();
B = getInput.nextDouble();
C = getInput.nextDouble();
discriminant = B*B - 4.0*A*C;
// We assume discriminant >= 0 for now
ans1 = (-B + Math.pow(discriminant,0.5))/(2.0*A);
ans2 = (-B - Math.pow(discriminant,0.5))/(2.0*A);
java.lang.System.out.println("The roots are " + ans1
+ " and " + ans2);
}
}
Note the following new features in this program.
import java.util.Scanner;
public class Quadratic2 {
public static void main (String[] Args) {
Scanner getInput = new Scanner(java.lang.System.in);
double A = getInput.nextDouble();
double B = getInput.nextDouble();
double C = getInput.nextDouble();
double discriminant = B*B - 4.0*A*C;
// We assume discriminant >= 0 for now
double ans1 = (-B + Math.pow(discriminant,0.5))/(2.0*A);
double ans2 = (-B - Math.pow(discriminant,0.5))/(2.0*A);
System.out.println("The roots are " + ans1 + " and
" + ans2);
}
}
On the right we see the program rewritten in the style that would normally be used.
The above explanation is way more complicated that the program itself! For now it is fine to just remember how to read doubles. Other methods in the Scanner class include nextInt, nextString, and nextBoolean.
Homework: 2.1, 2.5
For those without the 8e.
2.1: Write a program that reads Celsius degrees (in double), converts it to Fahrenheit, and displays the result. The formula is F=(9/5)C+32.
2.5: Write a program that reads in the subtotal and the gratuity rate, then computes the gratuity and the total.
These are the names that appear when writing a program. Examples include variable names, method names, and object names. There are rules for the names.
keyword. (e.g., class, double, if, and else).
As we have said classes contain data (normally called fields) and methods. Fields are examples of variables, but we haven't seen any yet. Later we shall learn that there are two kinds of fields, static and non-static.
Another kind of variable is the local variable, which is a variable declared inside a method. We have seen several, e.g. discriminant.
The final kind of variable is the parameter. We have seen one example so far, the args parameter always present in the main method.
Many programming languages have assignment statements, which in Java are of the form
variable = expression ;
Executing this statement evaluates the expression and
places the resulting value in the variable.
This ability to change the value of a variable (so called mutable state) is a big deal in programming language design. Proponents of functional languages believe that imperative languages, such as Java, are harder to understand due to the changing state.
Java, like the C language on which the Java syntax is based, also includes assignment expressions, which are of the form
variable = expression
(NO semicolon).
An assignment expression evaluates the RHS (right hand
side) expression, assigns the value to the LHS variable, and then
returns this value as the result of the
assignment expression itself.
System.out.println(x = Math.pow(2,0.5));
a = b = c = 0;
a = 1 + (b = 2 + (c = 0));
The first example evaluates the square root of 2, assigns the value to
x, and then passes this value to println.
The second example first performs c=0, which results in c becoming 0 and the value 0 returned. This 0 is then assigned to b and returned where it is assigned to a. Note the right to left evaluation.
The third example is ugly, confusing, and not recommended. It works as follows: c=0 is evaluated assigning 0 to c and returning 0. Then 2+0 is evaluated to 2, assigned to b, and returned. Then 1+2 is evaluated to 3, assigned to a, and discarded.
Java, again like C, uses = for assignment and == to test if two values are equal. Another common choice is to use := for assignment and = to test for equality.
We have seen constant numbers and constant strings. But these were literal constants; that is the value itself was used (e.g., 2 or "Hello, world.").
A string constant like "Hello, world." is certainly descriptive, but a numeric constant like 2 is not (does its usage signify that we are computing base 2, that our computer game program is playing 2-handed cribbage, or what?). In addition, if we wanted to change either constant, we would need to change all relevant occurrences.
Instead of explicitly writing the 2 or "Hello, world." at each occurrence, we can defined a named constant (a.k.a a symbolic constant) for each value.
final int numberBase = 2;
final int cribbageHands = 2;
final String msg = "Hello, world.";
The first two lines on the right could be used in a two-handed
cribbage program that somehow relied on base 2 representations.
Then if the program was to be extended to 4-handed cribbage as well,
we would have a clue where to look.
The final keyword says that definition gives the final value this identifier will have. That is, the identifier will not be assigned a new value. It is read-only or constant.
Numerical values in Java come in two basic types, corresponding to mathematical integers and real numbers. However each of these come in various sizes.
Mathematical integers have four Java types.
Mathematical real numbers have two Java types
The difference between the four integer types and the four real types is the amount of memory used for each value. As the name suggests a byte is stored in a byte. A short is stored in two bytes; an integer is stored in four; and a long is stored in eight.
A float is stored in four bytes and a double is stored in eight.
For integers, allocating more storage permits a wider range of values.
Floating point is more complicated. The extra storage is used to extend the range of both the fractional part and the exponent. Recall that floating point numbers are represented in what is essentially scientific notation, so they store both a fractional part and an exponent (unlike customary scientific notation, the exponent represents a power of 2 not 10).
Start Lecture #3
Remark: I mistakenly typed in the wrong problem 2.5 (I typed in 2.2). You may do either. By tomorrow the notes will be corrected.
Java, like essentially all languages, defines +, -, *, and / to be addition, subtraction, multiplication, and division.
(-1) % 5 == -1
(-1) modulo 5 == 4
Java defines % to be the remainder operator.
Some people (and some books and some web pages) will tell you that
Java defines % to be the mathematical modulo operator.
Don't believe them.
Remainder and modulo do agree when you have positive arguments, but
not in general.
Literals are constants that appear directly in a program. We have already seen examples of both numeric and string literals.
For integers, if the literal begins with 0 followed by a digit, the value is interpreted as octal (base 8). If it begins with 0x, it is interpreted as hexadecimal (base 16). Otherwise, it is interpreted as decimal (base 10).
What is the use of base 8 and base 16 for us humans with 10 fingers
(i.e, digits)?
Ans: Getting at individual bits.
The literal is considered an int unless it ends with an l or an L
Real numbers are always decimal. If the literal ends with an f or an F, it is considered a float. By default a real literal is a double, but this can be emphasized by ending it with a d or a D.
Literals such as 6.02×1023 (Avogadro's number) can also be expressed in Java (and most other programming languages). Although the exact rules are detailed, the basic idea is easy: First write the part before the × then write an e or an E (for exponent) then write the exponent. So Avogadro number would be 6.02E23. Negative exponents get a minus sign (9.8E-3).
The details
concern the optional + in the
exponent, the optional trailing d or D, the
trailing f or F for float, and
the ability to omit the decimal point if it is at the right.
This is quite a serious subject if one considers
arbitrary Java expressions.
In general, to find the details, one should search the web using
site:sun.com
.
This leads to the Java Language Specification
http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html.
The chapter on expressions
http://java.sun.com/docs/books/jls/third_edition/html/expressions.html
is 103 pages according to print preview on my browser!
For now we restrict ourselves to arithmetic expressions involving just +, -, *, /, %, (, and ). In particular, we do not now consider method evaluation. In this case the rules are not hard and are very similar to the rules you learned in algebra.
The last step illustrated integer division, which in Java rounds
towards zero.
So (5 - 12) / 4 = (-7) / 4 == -1.
Note that these operators are binary.
We have unitary operators as well, e.g., unitary -, which are
evaluated first.
So 5 + - 3 == 2 and - 5 + - 3 == -8
Unary + is defined as well, but doesn't do much.
Unary (prefix) operators naturally are applied right to left
So 5 - - - 3 == 2 and 5 + + + + 3 == 8
// Silly version of How Long Ago
import java.util.Scanner;
public class HowLongAgo {
public static void main (String[] args) {
final int daysInMonth = 30; // ridiculous
final int daysInYear = 360; // equally ridiculous
Scanner getInput = new Scanner(System.in);
System.out.println("Enter today's day, month, and year");
int day = getInput.nextInt();
int month = getInput.nextInt();
int year = getInput.nextInt();
System.out.println("Enter old day, month, and year");
int oldDay = getInput.nextInt();
int oldMonth = getInput.nextInt();
int oldYear = getInput.nextInt();
// Compute total number of days ago
int deltaDays = (day-oldDay) + (month-oldMonth)*daysInMonth
+ (year-oldYear)*daysInYear;
// Convert to days / months / years
int yearsAgo = deltaDays / daysInYear;
int monthsAgo = (deltaDays % daysInYear) / daysInMonth;
int daysAgo = (deltaDays % daysInYear) % daysInMonth;
System.out.println ("The old date was " + yearsAgo +
" years " + monthsAgo + " months and "
+ daysAgo + " days ago.");
}
}
It is no fun to do one from the book so instead we do a silly
version of a program to tell how long it is from one date to
another.
For example from 1 July 1980 to 5 September 1985 is
5 years, 2 months and 4 days
.
However, we will do a silly version since we don't yet know about arrays and if-then-else.
The program (on the right) performs this task in three steps.
Note that monthsAgo is not the total
number of months ago since we have already removed
the
years.
I computed the three values in the order days, months, years, which is from most significant to least significant. You can instead compute the values in the reverse order (least to most significant). To see an example, read the book's solution.
Splitting a combined value into parts is actually quite useful. Consider splitting a 3-digit number into its three digits. For example given six hundred fifteen, we want 6, 1, and 5. This is the same problem as in our program but daysInYear is 100 and daysInMonth is 10.
How would you convert a number into millions, thousands, and
the rest?
Ans: Set daysInYear = 1,000,000 and daysInMonth = 1,000.
How would you convert dollars into hundreds, twenties, and
singles?
Ans: Set daysInYear to 100 and daysInMonth to 20.
How can an operating system convert a virtual address into
segment number, page number, and offset
Ans: Set daysInYear to the number of bytes in a segment and
... oops wrong course (and real OSes do it differently).
Homework: 2.7 Write a program that prompts the user to enter the number of minutes and then calculates the (approximate) number of years and days it represents. Assume all years have 365 days.
Statements like x = x + y; are quite common and several languages, including Java have a shorthand form x += y;.
Similarly Java et al. has -=, *=, /=, and %=. Note that there is no space between the arithmetic operator and the equal sign.
An especially common case is x = x + 1; and Java and friends have an especially short form x++. Similarly, we have x-- (but NOT ** or // or %%).
In fact x++ can be part of an expression rather than as a statement by itself. In this case, a question arises. Is the value used in the expression the old (un-incremented) value of x, or the new (incremented) value? Both are useful and both are provided.
x = 5;
y1 = x++ + 10;
y2 = ++x + 10;
y3 = x-- + 10;
y4 = --x + 10;
Consider the code sequence on the right where all 5 variables are
declared to be ints.
On the board show how to calculate the index for queues (rear++ and front++) and for stacks (top++ and --top). What about moving all four ++ and -- operators to the other side?
What happens if we try to add a short to an int? How about multiplying a byte by a double?
Even simpler perhaps, how about assigning an integer value to a real variable, or vice versa?
The strict answer is that you can't do any of these things directly. Instead one of the values must be converted to another type.
Sometimes this happens automatically (but it does happen). Other times it must be explicitly requested and some of these requests fail.
When the programming language automatically converts a value of one type (e.g. integer) to another type (e.g., double), we call the conversion a coercion. When the programmer explicitly requests the conversion, we call it type casting.
Any short value is also a legal int. Similarly any float value is a legal double.
Conversions of this kind are called widenings since the new type in a sense is wider than the old. Similarly, the reverse conversions are called narrowing.
public class Test {
public static void main (String[] args) {
int a = 1234567891; // one billion plus
short b;
double x;
float y;
x = a;
y = a;
b = a; // error coercions cannot narrow
b = (short)a; // narrowing cast
System.out.println(a + " " + b + " "
+ x + " " + y);
}
}
javac Test.java; java Test
1234567891 723 1.234567891E9 1.23456794E9
Java will perform widening coercions but not narrowing coercions. To perform a narrowing conversion, the programmer must use an explicit cast. This is done by writing the target type in parenthesis.
The code on the right illustrates these points. Two problems have arisen.
The load payment problem requires you to accept some complicated formula for monthlyPayment. That is not my style. Instead, we will do a simpler problem where we can understand the formula used.
Say you have a bank account with $1000 that pays 3% interest per year and want to know what you will have after a year.
finalBalance = origBalance + interest = origBalance + origBalance * interestRate
= origBalance * (1 + interestRate)
finalBalance = origBalance * (1 + interestRate/12)12
finalBalance = origBalance * (1 + interestRate/365)365
finalBalance = origBalance * (1 + interestRate/n)n
import java.util.Scanner;
public class CompoundInterest {
public static void main (String[] args) {
Scanner getInput = new Scanner(System.in);
double origBal = getInput.nextDouble();
double interestRate = getInput.nextDouble();
int n = getInput.nextInt(); // numberCoumpoundings
double finalBal = origBal*Math.pow(1+interestRate/n,n);
System.out.println(finalBal);
}
}
javac CompoundInterest.java; java CompoundInterest
1000. .03 1
1030.0
java CompoundInterest
1000. .03 2
1030.2249999999997
java CompoundInterest
1000. .03 12
1030.4159569135068
java CompoundInterest
1000. .03 100000
1030.4545293116412
java CompoundInterest
1000. .03 1000000
1030.4545335307425
The program on the right is fairly straigtforward, given what we have done already. First we read the input data: the original balance, the (annual) interest rate, and the number of compoundings.
Then we compute the final balance after one year. We could do k years by changing the exponent from n to k*n.
Finally, we print the result
The only interesting line is the computation of finalBal. Let's read it carefully in class to check that it is the same as the formula above.
We show five runs, the first for so called simple interest (only compounded once). We did this above and sure enough we again get $1030 for 3% interest on $1000.
The second is semi-annual compounding. Note that we do not need to recompile (javac).
The third is monthly compounding.
The fourth and fifth suggest that we are approaching a limit.
char c = 'x'; string s = "x"; s = c; // compile error
The char (character) datatype is used to hold a single character. A literal char is written as a character surrounded by single quotes.
The variables c and s on the right are most definitely not the same.
Java's char datatype uses 16-bits to represent a character, thereby allowing 216=65,536 different characters. This size was inspired by the original Unicode, which was also 16 bits. The goal of Unicode was that it would supply all the characters in all the world's languages.
However, 65,536 characters proved to be way too few; Unicode has since been revised to support many more characters (over a million), but we won't discuss how it was shoehorned into 16-bit Java characters. It turns out that the character 'A' has the 16-bit value 0000000000100001 (41 in hex, 65 in decimal).
There are two ways to write this character.
Naturally 'A' is one, but the other looks wierd, namely
'\u0041'.
This representation consists of a backslash, a lower case u
(presumably for unicode), and exactly
4 hexadecimal digits
.
I don't like this terminology—to me digit implies base
10—but it is standard.
public class As {
public static void main(String[] Args) {
String str = "A\u0041\u0041A \u0041";
System.out.println(str);
}
}
javac As.java; java As
AAAA A
So 'A' is the 4*16+1=65th character in the Unicode set.
The two character representations can be mixed freely, as we see on the right.
In the not so distant past, computers (at least US computers) used the 7-bit ASCII code (rather nationalistically, ASCII abbreviates American Standard Code for Information Interchange). The 65th ASCII character is also 'A'. All the normal letters, digits, etc are in both ASCII and are in the same position (65 for A). It might be right that the 127 ASCII codes make up the first 127 unicode characters and are at the same position, but I am not sure.
Although it will not be emphasized in this course, it is indeed wonderful that alphabets from around the world can be represented.
| Esc Seq | Becomes |
|---|---|
| \" | Double quote |
| \\ | Backslash |
| \' | Single quote |
| \t | Tab |
| \n | Newline |
| \b | Backspace |
| \f | Formfeed |
| \r | (carriage) Return |
We have a problem. The character " is used to end a string. What do we do if we want a " to be part of a string?
We use an escape sequence beginning with \. In particular we use \" to include a " inside a string.
But then how do we get \ itself?
Ans: We use a \\ (of course).
On the right is a list of Java escape sequences. The ones above the line are more commonly used than the ones below.
public class Test {
public static void main (String[] args) {
int i;
short s;
byte b;
char c = 'A';
i = c;
s = c;
b = c;
System.out.println(c + " " + i + " " + s + " " + b);
}
}
I believe a better heading would be converting between char and numeric types since not all of the conversions used are (explicit) casts; some are (implicit) coercions.
The code on the right has two errors. Clearly a (16-bit) char may not fit into an (8-bit) byte. The (subtle) trouble with the short is that it is signed.
So coercions will not work. You may write casts such as b=(byte)c; this will compile but will produce wrong answers if the actual value in the char c does not fit in the byte b.
Similarly, integer values may be cast into chars (but not coerced).
We already did a simpler version of this.
Let's do the design of a more complicated version: Read in a double containing an amount of dollars and cents, e.g., 123456.23 and prints the number of twenties, tens, fives, singles, quarters, dimes, nickels, pennies.
There is a subtle danger here that we will ignore (the book doesn't even mention it). A number like 1234.1 cannot be represented exactly as a double since 0.1 cannot be written in base 2 (using a finite number of bits) just as 1/3 cannot be written as a decimal.
Ignoring the problem, the steps to solve the problem are
Start Lecture #4
In Java a String (note the capital S) is very different from a double, short, or char. Whereas all the latter are primitive types, String is actually a class and hence the String type is a reference type.
So what?
It actually is an important distinction, but not yet. Remember that Java was not designed as a teaching language but as a heavy-duty production language. Once consequence is that doing simple things (reading an integer, declaring a string) uses fairly sophisticated concepts.
Now we just want to learn how to declare String variables, write String constants, assign Strings and concatenate Strings. Fortunately, we can do all of these tasks without having to deal with the complications. Later we will learn much more about classes.
"This is A string" "This is \u0041 string"
String s1, s2; s1 = "A string"; String s3 = "Another string"; s2 = s1 + " " + s3; s2 += " and more";
A string A string Another string and more Another string
The top line on the right shows a string.
The syntax is very simple: a double quote, some characters, a double
quote.
The second line is the same string.
Below the horizontal line are legal Java statements.
The first declares two strings; they are currently
uninitialized.
The second line assigns a string to the first variable
The line declares a third string and initializes it.
The last two lines perform string concatenation
The last group of lines show the output when we println() each of the three strings.
There are three types of Java comments.
I will use only the first form, but you may use any of the three.
To learn about javadoc, see the reference in the book.
Java programmers tend to use the following conventions. I will try to adhere to them. I don't know if you can ask javac to tell you if you have violated the conventions.
You should all be familiar with proper indenting to show the meaning of the program since Python requires it.
I use the end-of-line style
but many prefer the
next-line style
.
You may use either (see the book for examples of next-line style).
I wish I could write a few words or pages (or books) that would show you how to avoid making errors and to find and fix error made by others. The best I can do, is to write programs in class. I will doubtless have errors and we can fix them together.
Homework: 2.11 (copy of problem handed out in class for those w/o 8e).
Essentially computer languages have a way to indicate that some statements are executed only if a certain condition holds.
Java syntax is basically the same as in C, which is OK but not great.
We have seen four integer types (byte, short, int, and long), two real types (float and double), and a character type (char). These 7 types are primitive.
We have also see one reference type (the String class). Note the capitalization, which reminds you that String is a class.
Java has one more primitive type (boolean), used to express truth and falsehood.
| Operator | Name |
|---|---|
| == | equal to |
| != | not equal to |
| < | less than |
| <= | less than or equal to |
| > | greater than |
| >= | greater than or equal to |
Mathematicians, when discussing Boolean algebra, capitalize Boolean
since it is named after a person, specifically the logician George
Boole.
Java of course does not capitalize boolean.
Why?
Because boolean is a primitive type, not a class.
There are two boolean constants, true and false.
There are 6 comparison operators that are used to compare values in an ordered type (a type in which values are ordered). So we can compare ints with ints, doubles with doubles, and chars with chars. The result of a comparison is a boolean, namely true or false.
If values from different (ordered) types are being compared, one must be converted to the type of the other. Again this can be via coercion or type casting
int i = 1, j = 2; boolean x, y = true, z; x = i == j; // false z = i < j; // true
On the right we see some simple uses of booleans.
The one point to note is the distinction between = and ==
in Java.
The single = is the assignment operator that causes the value on the
RHS to be placed into the variable on the LHS.
The double == is the comparison operator that evaluates its LHS and
RHS, compares the results, and results in either true or
false.
No fun to use booleans before learning about if.
Found in basically all languages.
We will see that the C/Java syntax for if permits the
infamous dangling else
problem.
if (boolean expression) {
one or more statements;
}
The simplest form of if statement is shown on the right.
The semantics (meaning) of a one-way if statement is simple and the same as in many languages.
Read
Write a program to read in the coefficients A,B,C of a quadratic equation and print the answers. Handle the cases of positive, zero, and negative discriminant separately.
Let's do this in class. One solution is here.
if (boolean expression) {
one or more statements;
} else {
one or more statements;
}
Often if is used to choose between two actions, one when the Boolean expression is true and one when it is false.
The skeleton code for this if-then-else
construct is shown
on the right.
The previous simpler skeleton is normally called an if-then
even though Java and C do not actually employ a then
keyword.
As the name suggests, the semantics of an if-then-else
is to do the
then
or the else
depending on the if.
Specifically,
if (boolean expression) exactly one statement
if (boolean expression) exactly one statement else exactly one statement
if (boolean expression) { one or more statements } else exactly one statement
If any of the three blocks (the then block in the if-then statement, the then block in the if-then-else statement, or the else block in the if-then-else statement) consists of only one statement, its surrounding {} can be omitted.
Experienced Java programmers would almost always omit such {}, but it is probably better for beginners like us to leave them in so that all if-then's and all if-then-else's have the same structure. There is an exception, see below.
On the right we see three of the four possibilities.
What is the remaining possibility?
Ans: The then block
has exactly one statement and no {} while
the else
block has one or more statements and does have the
{}.
if (be1) { // be is Boolean expr
if (be2) {
ss1 // ss is statement(s)
} else {
ss2
} else {
if (be3) {
ss3
} else {
ss4
}
}
The statement(s) in either the then block or the else block can include another if statement, in which case we say the two if statements are nested.
On the right we see three if statements, with the second and third nested inside the first.
If be1, the Boolean expression of the outside if statement evaluates to true, the second if statement is executed. If instead be1 is false, the third if statement executes.
There are eight possible truth values for the three Boolean
expressions, but only four possible actions
(ss1–ss4).
Why?
Because for be1==true the value of be3 is
irrelevant and for be1==false, the value of
be2 is irrelevant.
if (be1) {
ss1
} else {
if (be2) {
ss2
} else {
if (be3) {
ss3
} else {
ss_default
}
}
}
Often deeply nested if-the-else's have the nesting only in the else part. This gives rise to code similar to that shown on the right.
Be sure you understand why this is not the same as separate (non-nested) if statements.
The trouble with the code shown is that it keeps moving to the right and, should there be many condition, you either get very wide lines or only have a few columns to use.
This is one situation where it pays to make use of the fact that the {} can be omitted when they enclose exactly one statement. To make use of this possibility, you must realize that an if statement, in its entirety, is only one statement. For example, the entire nested if structure we just saw is only one statement, even though it may have hundreds of statements inside its many {} blocks.
if (be1) {
ss1
} else if (be2) {
ss2
} else if (be3) {
ss3
} else {
ss_default
}
As a result we can remove the { and } from else { if ... } and convert the above to the code on the right.
Please read the code sequence carefully and understand why it is the same as the one above.
Note, in particular, that the indenting is somewhat misleading as the symmetric placement of ss1, ss2, s3, and ss_default suggests that they have equal status. In particular since be1==true implies that ss1 gets execute, you might think that be3==true implies that ss3 gets executed. But that is wrong! Be sure you understand why it is wrong (hint what if all the boolean expressions are true).
Indeed this pattern with all the statements in the
then block
is so common that some languages (but not Java)
have a keyword elsif that is used in place of
the else if above.
Other languages require an explicit ending to an if statement, most commonly end if. In that case no {} are ever needed for if statements.
Homework: 3.7 and 3.9. Handout for those w/o 8e.
Don't forget the {} when you have more that one statement in the
then block
or else block
.
I recommend that, while you are learning Java, you use {} for each
ss even if it is just one statement (except for the
else if situation illustrated above).
Don't mistakenly put a ; after the boolean expression right before
the then block
.
Don't write if (be==true). Instead, write the equivalent if (be). Although the first form is not wrong; it is poor style.
if (be1)
if (be2)
ss2
else
ss1
The indenting on the right mistakenly suggests that should be1 evaluate to false, ss1 will be executed. That is WRONG. The else in the code sequence is part of the second (i.e., inner) if. Indeed, the Java (and C) rule is that an else pairs with the nearest unfinished if
In a language like Python that enforces proper indentation no such misleading information can occur.
if (be1) { if (be1) {
if (be2) if (be2) {
ss2 ss2
} else { } else {
ss1 ss1
} }
}
On the right, I have added {} to make the meaning clear. The code on the far right has the same semantics as the dangling else code above. There is no ambiguity: the outer then has not yet ended so the else must be part of the inner if.
The code on the near right has the semantics that the original
indentation above mistakenly suggested.
Again there is no ambiguity:
The inner if has ended (it is part of the outer
then block
) so the else must be part of the outer
if
Read
Start Lecture #5
Homework: The problems from lecture 4 that weren't assigned (3.7 and 3.9).
Let's fix two problems with our previous solution to solving the quadratic equation Ax2+Bx+C=0.
Let's do this in class; one possible solution is here.
Read.
Let's do this one in class. Handout sheet with tax table. A scan of the table is here.
| Operator | Name |
|---|---|
| ! | not |
| && | and |
| || | or |
| ^ | exclusive or |
Like most computer languages, Java permits Boolean expressions to contain so-called "logical operators". These operators have Boolean expressions as both operands and results.
The table on the right shows the four possibilities.
The not
operator is unary (takes one operand) and returns the
opposite Boolean value as result.
The and
operator is binary and returns false unless
when both operands are true.
The (inclusive) or
operator is binary and returns
true unless both operands are false.
That is, the meaning of || is
one or the other or both
.
The exclusive or
operator is binary and returns
true if and only if exactly one operand is true.
That is, the meaning of ^ is
one or the other but not both
.
As you know a day is the time it takes the earth to rotate about its axis, and a year is the time it takes for the earth to revolve around the sun.
By these definitions a year is a little less than 365.25 days. To keep the calendars correct (meaning that, e.g., the vernal equinox occurs around the same time each year), most years have 365 days, but some have 366.
A very good approximation, which will work up to at least the year 4000 and likely much further is as follows (surprisingly, we are not able to predict exactly when the vernal equinox will occur far in the future; see wikipedia).
Let's write in class a program that asks for the year and replies by saying if the year is a leap year. One solution is in the book.
The book has an interesting lottery game. The program generates a random 2-digit number and accepts another 2-digit number from the user.
We will write this in class, but need a new library method from Java, Math.random returns a random number between 0 and 1. The value returned, a double, might be 0, but will not be 1.
One solution is in the book.
Start Lecture #6
We have seen how to use if-then-else to specify one of a number of different actions, with the chosen action determined by a series of Boolean expressions.
Often the Boolean expressions consist of different values for a single (normally arithmetic) expression.
switch(expression) {
case value1: stmts1
case value2: stmts2
...
case valueN: stmtsN
default: def-stmts
}
For example we may want to do one action if i+j is 4, a different action if i+j is 8, a third action if i+j is 15, and a fourth action if i+j is any other value. In such cases the switch statement, shown on the right, is appropriate.
When a switch statement is executed the expression is evaluated and the result specifies, which case is executed.
The semantics of switch are somewhat funny. Specifically, given the similarity with if-then-else, one might assume that after stmts1 is executed, control transfers to the end of the switch. However, this is wrong: Unless explicitly directed, control flows from one case to another.
computed gotoof Fortran.
switch (expression) {
case value1: stmts1
break;
case value2: stmts2
break;
...
case valueN: stmtsN
break;
default: def-stmts
}
It is quite easy to explicitly transfer control from the end of one case to the end of the entire switch. Java, again borrowing from C, has a break statement that serves this purpose.
We see on the right the common form of a switch in which the last statement of stmts1...stmtsN is a break.
When a break is executed within a switch, control
breaks out of
the switch.
That is, execution proceeds directly to the end of
the switch.
In particular, the code on the right will execute exactly one
case or the default.
Homework: 3.11, 3.25, Handout for those w/o 8e.
bool-expr ? expr1 : expr2
if (x==5) y = 2; else y = 3;
y = x==5 ? 2 : 3;
Recall that Java has += that shortens x=x+5 to x+=5. Java has another shortcut, the tertiary operator ?...: that can be used to shorten an if-then-else.
The general form of the so-called conditional expression
is
shown on the top right.
The value of the entire expression is either expr1 or
expr2, depending on the value of the Boolean expression
bool-expr.
For example, the middle right if-then-else can be replaced by the bottom right assignment statement containing the equivalent conditional expression.
Note that this is not limited to arithmetic and can often be used to produce grammatically correct output.
System.out.println ("Please input " + N + "number" + N ? "." : "s.");
I realize this looks weird; be sure you see how it works.
Homework: Redo 3.7, this time using a switch.
A comparatively recent addition to Java is the C-like printf method. (It was added in Java 2 Standard Edition 5; we are using J2SE 6).
System.out.printf(format, item1, item2, ..., item n);
The first point to make is that printf() takes a variable number of arguments as indicated on the right. The required first argument, which must be a string, indicates how many additional arguments are needed and how those arguments are to be printed.
Wherever the first argument contains a %
, the value
of the next argument is inserted (a double %%
is
printed as a single %
).
System.out.printf("i = %d and j = %d", i, j);
System.out.printf("x = %f and y = %e", x, y);
The first line on the right prints the integer values of x and
y.
The second line prints two real values, the second using scientific
notation.
| Specifier | Output |
|---|---|
| %b | Boolean |
| %c | Character |
| %d | Integer |
| %f | Floating Point |
| %e | Scientific Notation |
| %s | String |
The table on the right gives the most common specifiers. Although Java will perform a few conversions automatically (e.g., an integer value will be converted to a string if the corresponding specifier is %s), most conversions are illegal. For example
int i; double x; int one=1, two=2;
System.out.printf("Both %f and %d are bad\n", i, x);
System.out.printf("%d plus %d is %d\n", one, two, one+two);
You could try to find which conversions are OK, but I very much suggest that instead you do not use any. That is use %f and %e only for floats and doubles; use %d only for the four integer types; use %s only for Strings, etc.
System.out.printf("%d\n%d\n",45,7);
45
7
45
7
System.out.printf("%2d\n%2d\n",45,7);
System.out.printf("%2d\n%2d\n",45,789);
45
789
Note that %d uses just enough space to print the actual number; it does not pad with blanks. If you print several integers one per line using %d they won't line up properly. For example, the printf() on the right will produce the first output, not the second.
To remedy this problem you can specify a minimum width between the
% and the key-letter
.
For example the second printf() does produce the second
output.
But what would happen if we tried to print 543 using %2d? There are two reasonable choices.
Java chooses the second option. So the bottom printf() produces the bottom output.
These same considerations apply to the other 5 specifiers in the table: if the value is not as wide as the specified width, the value is right justified and padded on the left with blanks.
For the real number specifiers %f and %e one can specify the precision in addition to the (minimum) width. This is done by writing the width, then a period, and then the precision between the % and the letter.
For example %6.2 means that the floating-point value will be written with exactly 2 digits after the decimal point and if the result (including a minus sign if needed) is less than 6 characters, the value will be padded with blanks on the left.
As we have seen, when the width is specified (with or without precision), the value is right justified if needed and padded on the left with blanks. This is normally just what you want for numbers, but not for strings.
For all specifiers (numbers, strings, etc) Java supports left justification (padding on the right with blanks) as well: Simply put a minus sign right before the width as in %-9f, %-10.2e, or %-7s.
| Operator | Associativity |
|---|---|
| var++, var-- | Left-to-right |
| +,- (unary), ++var, --var | Right-to-left |
| (type) | Right-to-left |
| ! | Left-to-right |
| *,/,% | Left-to-right |
| +,- (binary) | Left-to-right |
| <,<=,>,>= | Left-to-right |
| ==,!= | Left-to-right |
| ^ | Left-to-right |
| && | Left-to-right |
| || | Left-to-right |
| ?: (tertiary) | Right-to-left |
| =,+=,-=,*=,/=,%= | Right-to-left |
The table on the right lists the operators we have seen in decreasing order of precedence. That mean that, in the absence of parentheses, if an expression contains two operators from different rows of the table, the operator in the higher row is done first.
The second column gives the associativity of the operators. If an expression contains two operators from the same row and that row has left-to-right associativity, the left operator is done first. Similarly if the row has right-to-left associativity, the right operator is done first. As with precedence, parentheses can be used to override this default ordering.
Not many programmers have the entire table memorized (not to mention the fact that there are other operators we have not yet encountered). Instead, they use parenthesis even when their use might not be necessary due to precedence and associativity.
However, it is wise to remember the precedence and associativity of
some of the frequently used operators.
For example, one should remember that *,/,% are executed before
(binary +,-) and that both groups have left-to-right associativity.
It would clutter up a program to see an expression like
((x*y)/z)/(((-x)+z)-y) rather than the equivalent
(x*y/z)/(-x+z-y)
As you know from Python, loops are used to execute the same block
of code multiple times.
There are several kinds of loops:
The while (and do-while) are fairly general;
the for is most convenient when the loops are
counting
, but can be used (abused?) in quite general ways.
while (BE) {
stmts
}
Some early languages (notable FORTRAN) did not have a while loop, but essentially all modern languages (including Fortran) do.
The semantics are fairly simple:
The idea of a while loop is that the body is executed while (i.e, as long as) the Boolean expression is true.
The flowchart on the right illustrates these simple semantics.
Note that if the Boolean expression is false initially, the loop body (the statements in the diagram) are not executed at all. We shall see in the next section a loop in which the body is executed at least once.
Note that when right after the while loop is executed, the
BE is FALSE.
Please don't get this wrong.
while ((i=getInput.nextInt) >= 0) {
// process the non-negative i
}
For example, when the loop on the right ends (assuming no EOF), the value of i is negative!
Lets write a program that adds two positive numbers just using ++ and --. One solution is here.
This is actually how one defines addition starting with Peano's postulates
The program picks a random number between 0 and 100 inclusive (101
possibilities).
The users repeatedly guess until they are correct.
For each guess, the program states higher
, lower
,
or correct
.
Let's do in class; one solution is in the book.
Start Lecture #7
Remark:
There are four parts to a loop and hence 4 tasks for the programmer to accomplish.
As you have seen in Python and we shall see in Java, loops can be quite varied. For one thing the body can be almost arbitrary. For now let's assume that the body is the quadratic equation solver that we have written in class. Currently it just solves one problem and then terminates. How can we improve it to solve many quadratic equations?
final int n=10;
int i = 0;
while (i<n) {
// input A, B, C
// solve one equation
i++;
}
n=getInput.nextInt();
int i = 0;
while (i<n) {
// input A, B, C
// solve one equation
i++;
}
// input A, B, C
while (A!=0 || B!=0 || C!=0) {
// solve one equation
// input A, B, C
}
while (true) {
// input A, B, C
if (A==0 && B==0 && C=0) {
break;
}
// solve one equation
}
There are at least four techniques, each of which can be applied to many different problems.
extra.
extra.
import java.util.Scanner;
public class Quadratic5 {
public static void main (String[] Args) {
System.out.println("Solving quadratic equations Ax^2 + Bx + C");
// The next line is for hardwiring; we are reading the count
// final int count = 10;
int count;
System.out.println("How many equations are to be solved?");
Scanner getInput = new Scanner(System.in);
count = getInput.nextInt();
while (count-- > 0) {
System.out.println("Enter real numbers A, B, C");
double A = getInput.nextDouble();
double B = getInput.nextDouble();
double C = getInput.nextDouble();
double discriminant = B*B - 4.0*A*C;
double ans;
if (A == 0) {
System.out.println("A linear equation; only one root");
ans = -C/B;
System.out.println("The one root is " + ans);
} else if (discriminant < 0) {
System.out.println("No (real) roots");
} else if (discriminant == 0) {
System.out.println("One (double) root");
ans = -B/(2*A);
System.out.println("The double root is/are " + ans);
} else { // discriminant > 0
double ans1 = (-B + Math.pow(discriminant,0.5))/(2.0*A);
double ans2 = (-B - Math.pow(discriminant,0.5))/(2.0*A);
System.out.println("The roots are " + ans1 + " and " + ans2);
}
}
}
}
On the right is the code for a yet further improved quadratic equation solver. This code illustrates several of the points made above.
import java.util.Scanner;
public class SumN {
public static void main (String[] args) {
Scanner getInput = new Scanner(System.in);
double x, sum;
int i, n;
while (true) {
System.out.println("How many numbers do you want to add?");
n = getInput.nextInt();
if (n < 0) {
break;
}
System.out.printf("Enter %d numbers: ", n);
i = 0;
sum = 0;
while (i++ < n) {
x = getInput.nextDouble();
sum += x;
}
System.out.printf("The sume of %d values is %f\n", n, sum);
}
}
}
On the right is a simple program to sum n numbers. Since it does not make sense to sum a negative number of numbers, we let n<o be the sentinel that ends the program.
There are again a few points to note.
n and 1/2times loop: The first part of the body is executed one more time than the second part.
public class UseEOF {
final static int EOF = -1;
public static void main(String[] args) {
int c;
while ( (c = nextCharOrEOF()) != EOF) {
System.out.write(c);
}
System.out.flush();
}
public static int nextCharOrEOF() {
try { return System.in.read(); }
catch (java.io.IOException e) { return EOF; }
}
}
On the right is a very simple loop that is terminated by EOF (end-of-file). However, it does use an advanced feature of Java, namely exceptions.
The method (think of function) nextCharOrEOF either returns the next character from System.in or it returns the value EOF.
EOF is not special; it is declared in the program.
The magic is the try/catch mechanism. The read() method will raise an exception, namely an IOException if the end of file is reached. This is caught by nextCharOrEOF and the value EOF is returned instead of the value returned by read().
As you know System.in is normally the keyboard and System.out is normally the display. However, they can be redirected to be an ordinary file in the file system. When System.in is redirected to a file f, input is taken from f instead of the keyboard, and when System.out is redirected to a file g, output goes to g.
For example the program UseEOF with the mysterious implementation, simply copies all its input to its output.
I copied it to i5 so we can run it (ignore how it works).
If we type simply java UseEOF, then whatever we type will appear on the screen.
If we type instead java UseEOF <f, then the file f will appear on the screen.
Similarly java UseEOF <f >g copies the file f to the file g.
As we have seen a while loop repeatedly performs a test-action sequence: first a BE is tested and then, if the test passes, the body is executed.
do {
stmts
} while (BE);
In particular, if the test fails initially, the body is not executed at all.
Most of the time, this is just what is wanted; however, there are occasions when we want the body to be first and the test second. In such situations we use a do-while loop.
We see the code skeleton for this loop on the near right and the flowchart on the far right.
final int quota = 250;
int count=0;
do {
count++;
} while ((quota-=getInput.nextInt()) > 0);
System.out.printf("Needed %d values.\n", count);
In the code on the right a quota is hardwired for brevity. Then the user inputs a series of numbers (say the dollar value of a sale). When he finally reaches or surpasses the quota, the program ends and reports how many values were needed.
Recall the four components of a loop as stated in 4.2.2
Parts 1, 2, and 4 can all be written in one for statement. After the word for comes a parenthesize list with three elements separated by semicolons. The first component is the initialization, the second the test, and the third the update to prepare for the next iteration.
The first code shown on the right presents the for loop corresponding to the example mentioned in the list. Indeed, this is a common usage of for, to have a counter step through consecutive values.
for(i=0; i<10; i++){
body
}
for(int i=0; i<10; i++)
for(i=0, j=n; i*j < 100; i++, j--)
for( ; ; )
The second for on the right shows that the loop variable can be declared in the for itself. One effect of this declaration is that the variable, i in this case, is not visible outside the loop. If there was another declaration of i inside another loop, the two variables named i would be unrelated.
It is also possible to initialize and update more than one variable as the third example shows.
Finally, the various components can be omitted, in which case the omitted item is essentially erased from the flowchart. For example, if the first component is omitted, there is no initialization performed; if the middle item is omitted there is no test (it is better to say that the test always yield true); and, if the third item is omitted there is no update. So the last, rather naked for will just keep executing the body until some external reason ends the loop (e.g., a break).
Homework: 4.5, 4.1 (the book forgot to show inputing the number of numbers), 4.9
They are equivalent. Any loop written with one construct can be written with either of the other two.
The for loop puts all the non-body in one place. If these pieces are small, e.g., for(i=0;i<n;i++), this is quite convenient. If they are large and or complicated, the while form is generally easier to read.
Much of this is personal preference.
I don't believe there is a right
or wrong
answer.
We have already done a nested loop in section 4.2.4.
for (int i=1; i<n-1; i++) {
for (int j=i+1; j<n; j++) {
// if the ith element exceeds the jth,
// swap them
}
}
It is essentially the same as in Python or any other programming language. The inner loop is done repeatedly for each execution of the outer loop.
For example, once we learn about arrays, we will see that the code on the right is a simple (but, alas, inefficient) way to sort an array.
This concerns the hazards of floating point arithmetic. Although we will not be emphasizing numeric errors, two general points can be made.
Given two positive integers, the book just tries every number from one up to the smaller input and chooses the largest one that divides both of the inputs.
Let try a different way to get the GCD. Keep subtracting the smaller from the larger until you get a zero, at which point the nonzero value is the GCD (if they are equal call one of them larger).
(54, 36) → (18, 36) → (18, 18) → (18, 0).
(7, 6) → (1, 6) → (1, 5) → ... → (1, 1) →
(1, 0).
Start Lecture #8
Remark: Lab1 part three 40% (we will be covering methods today).
public static int second(int a, int b, int c, int d);
This method returns the second largest value of its four
parameters.
Remark: Tutor/E-tutor available.
Anagha Ashok Pande <anagha.pande@nyu.edu> is the tutor/e-tutor
for this class.
Anagha is reading the mailing list and may respond to questions
there and also via the direct email addr above.
In addition, Anagha will be in room 328 WWH the following 5 hours
each week for office hours.
Feel free to drop by with questions, no appointment is necessary.
On Mondays and Tuesdays the hours are 1-2:30;
on Wednesdays and Thursdays the hour is 11-12.
I hate to take problems straight from the book since you can read it there, but this is too good to pass up.
Calculate π by choosing random points in a square and seeing how many are inside a circle.
Do in class. One solution is here.
We have already seen break for breaking out
of a
switch statement.
When break is used inside a loop, it does the analogous thing: namely it breaks out of the loop. That is execution transfers to the first statement after the loop. This works for any of the three forms of loops we have seen: while, do-while, or for.
In the case of nested loops, the break just breaks out of the inner one.
The continue statement can be used only inside a loop.
When executed, it continues
the loop by ending the current
iteration of the body and proceeding to the next iteration.
Specifically:
We want to display the first N primes. Unlike the book, we will
Although the second improvement does make the program much faster for large primes, it is still quite inefficient compared to the best methods, which are quite complicated and use very serious mathematics.
Start it in class.
Homework: Write this program in Java and test it for N=25.
Like all modern programming languages, Java permits the user to abstract a series of actions, give it a name, and invoke it from several places.
Many programming languages call the abstracted series of actions a procedure, a function, or a subroutine. Java, and some other programming languages, call it a method.
We have seen a method already, namely main().
We know how to do this since we have repeatedly defined the main method. The general format of a method definition is.
modifiers returnType name (list of parameters) { body }
For now we will always use two modifiers
public static
.
The main() method had returnType void since it did not return a value. It also had a single argument, an array of Strings.
The returnType and parameters will vary from method to method.
public static int myAdd(int x, int y) {
return x+y;
}
On the right we see a very simple method that accepts two int parameters and returns an int result. Note the return statement, which ends execution of the method and optionally returns a value to the calling method.
The type of the value returned will be the returnType named in the method definition.
public class demoMethods {
public static void main(String[]) {
int a = getInput.nextInt();
int b = getInput.nextInt();
System.out.println(myAdd(a,b));
}
public static int myAdd(int x, int y) {
return x+y;
}
}
We have called a number of methods already. For example getInput.nextInt(), Math.pow(), Math.random(). There is very little difference between how we called the pre-defined methods above and how we call methods we write.
One difference is that if we write a method and call it from a sibling method in the same class, we do not need to mention the class name.
On the right we see a full example with a simple main() method that calls the myAdd() method written above.
Method such as myAdd() that return a value are used in expressions the same way as variables and constants are used, except that they contain a (possibly empty) list of parameters. They act like mathematical functions. Indeed, they are called functions in some other programming languages.
Note that the names of the arguments in the call do NOT need to agree with the names of the parameters in the method definition. For example, how could we possibly have gotten the parameter names we used with Math.pow() correct, since we have never seen the definition?
The LIFO (Last In, First Out) semantics of method invocation (f calls g and then g calls h, means that, when h returns, control goes back to g, not to f.
Method invocation and return achieves this semantics as follows.
return address(the address in f where g should return to). This is called a stack frame, or simply frame.
Homework: 5.1, 5.3.
public class demoMethods {
public static void main(String[]) {
int a = getInput.nextInt();
int b = getInput.nextInt();
printSum(a,b);
}
public static void printSum(int x, int y) {
System.out.println(x+y);
}
}
Methods that do not return a value (technically their return type is void) are invoked slightly differently. Instead of being part of an expression, void methods are invoked as standalone statements. That is, the invocation consists of the method name, the argument list, and a terminating semicolon.
An example is the printSum() method is invoked by main() in the example on the right.
Homework: 5.5, 5.9.
Referring to the example above, the arguments a,b in main() are paired with the parameters x,y in printSum in the order given, a is paired with x and b is paired with y.
The result is that the x and y are initialized to the current values in a and b. Note that this works fine if an argument a or b is a complex expression and not just a variable. So printSum(4,a-8) is possible.
public class demoPassByValue {
public static void main(String[]) {
int a = 5;
int b = 6;
int c = 7;
tryToAdd(a,b,c);
}
public static void tryToAdd(int x, int y, int z) {
x = y + z;
}
}
The parameters, however, must be variables.
Java is a pass-by-value language. This means the on invocation the values in the arguments are transmitted to the corresponding parameters, but, at method return, the final values of the parameters are not, repeat NOT sent back to the parameters.
For example the code n the right does not set a to 13.
When we learn about objects and their reference semantics, we will need to revisit this section.
Programs are often easier to understand if they are broken into smaller pieces. When doing so, the programmer should look for self-contained, easy to describe pieces.
public class demoModularizing {
public static void main(String[] args) {
// input 3 points (x1,y1), (x2,y2), (x3,y3)
double perimeter = length(x1,y1,x2,y2) +
length(x2,y2,x3,y3) + length(x3,y3,x1,y1);
System.out.println(perimeter);
}
public static length(double x1, double y1,
double x2, double y2) {
return Math.sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
}
}
Another advantage is the ability for code reuse
.
In the very simple example on the right, we want to calculate the
perimeter of a triangle specified by giving the (x,y) coordinates of
its three vertices.
Of course the perimeter is the sum of the lengths of the three sides and the length of a line is the square root of the sum of the squares of the difference in coordinate values.
Without modularization, we would have one large formula that was the sum of the three square roots.
As written on the right, I abstracted out the length calculation, which in my opinion, makes the code easier to understand.
Other examples are the methods in the Math
class.
Imagine writing a geometry package and having to code the square
root routine each time it was used.
Read.
A very nice feature of Java and other modern languages is the ability to overload method names.
public class DemoOverloading {
public static void main(String[] args) {
System.out.printf ("%d %f %f\n", max(4,8),
max(9.,3.), max(9,3.));
}
public static int max(int x, int y) {
return x>y ? x : y;
}
public static double max(double x, double y) {
return x>y ? x : y;
}
public static double max(int x, double y) {
return ((double) x)>y ? x : y;
}
}
Of course if you use a method named max and another named min each with two integer arguments, Java is not confused and invokes max when you write max and invokes min when you write min.
All programming languages do that.
But now look on the right and see three methods all named max, one returning the maximum of two ints one returning the maximum of two double, and the third returning (as a double) the max of an int and a double.
When compiling a method definition javac notes
the signature
of the method, which for overloading consists
of the method name, the number of parameters, and the type of each
parameter.
When an overloaded method is called, the method chosen is the one with signature matching the arguments given at the call site.
Technical fine points: Java would coerce a 9 to a double if needed. But if the overloaded method has two signatures, one requiring coercion and the other not, the second is chosen. If the overloaded method has two signature, each with two parameters, having types so that one would require coercing the first argument and the other would require coercing the second argument, the program does not compile.
The scope of a variable is the portion of the program in which the variable can be referenced.
The rules for scope vary from language to language.
In Java a block is a group of statements enclosed in {}. For example the body of most loops, the body of most then and else clauses of an if, and the body of a method are all blocks. The exceptions are one statement bodies of then clauses, else clauses, and loops that are written without {}.
In Java the scope of a local variable begins with its declaration and continues to the end of the block containing the declaration. We have seen the one exception: if the initialization portion of a for statement contains a declaration, that local variable has scope including the body of the loop.
On the right we see two skeletons. The near right skeleton contains two blocks block1 and block2, neither of which is nested inside the other.
something { | something {
block1 | start of block3
} | something {
something { | block4
block2 | }
} | }
In this case it is permitted to declare two variables with the same name, one in block1 and one in block2. These two variables are unrelated. That is, the situation is the same as if they had different names.
On the far right we again see two blocks, but this time block4 is nested inside block3. In this situation it is not permitted to have the same variable name declared in both blocks. Such a program will not compile.
We have already used a few methods from the Math class.
In addition to various methods, some of which are described below, the Math class defines two important mathematical constants, E, the base of the natural logarithm, and PI, the ratio of a circle's perimeter to its diameter.
public static double sin(double theta) public static double cos(double theta) public static double tan(double theta) public static double asin(double x) public static double acos(double x) public static double atan(double x)
public static double toDegrees(double radians) public static double toRadians(double degrees)
The six routines on the upper right compute the three basic trig functions and their inverses. In all cases, the angles are expressed in radians.
The two below are used to convert to and from degrees.
public static double pow(double a, double b) public static double sqrt(double a)
public static double log(double x) public static double exp(double x)
public static double log10(double x)
The first routine on the right computes ab. Since the special case of square root, where b=.5 is so widely used it has its own function, which is given next.
Mathematically, logs and exponentials based on Math.E are more important than the corresponding functions using base 10. They come next.
The base 10 exponential is handled with pow, but there is a special function for the base 10 log as shown.
Given a floating point value, one can think of three integer values that correspond to this floating point value.
public static double floor(double x) public static double ceil(double x) public static double rint(double x)
The Math class has three methods that correspond directly to these mathematical functions, but return a type of double. They are shown on the upper right. For the third function, ties are resolved toward the even number so rint(-1.5)==rint(-2.5)==-2..
public static int round(float x) public static long round(double x)
In addition Math has an overloaded method round() that rounds a floating point value to an integer value. The two round method are distinguished by the type of the argument (as normal for overloaded methods). Given a float, round returns an int. Given a double, round returns a long.
This choice prevents the loss of precision, but of course there are many floats and doubles (e.g., 10E30) that are too big to be represented as an ints or longs.
These three methods are heavily overloaded, they can be given int, long, float, or double arguments (or, for min and max) one argument of one type and the other of another type.
We have already used Math.random() several times in our examples. As mentioned random() returns a double x satisfying 0≤x<1.
To obtain a random integer n satisfying m≤x<n you would write m+(int)((n-m)*Math.random()). For example, to get a random integer 10≤x<100, you write 10+(int)(90*random()).
Let's do one slightly different from the book's.
Print N (assumed an even number) random characters, the odd ones lower case and the even ones upper case.
public class RandomChars {
public static void main(String[] args) {
final int n = 1000; // assumed EVEN
for(int i=0; i<n/2; i++) {
System.out.printf("%c", pickChar('a'));
System.out.printf("%c", pickChar('A'));
}
}
public static char pickChar(char c) {
return (char)((int)(c)+(26*Math.random()));
}
}
The program on the right is surprisingly short. The one idea used to create it was the choice of the pickChar() method. This method is given a character and returns a random character between the given argument and 26 characters later. So, when given 'a, it returns a random lower case character and, when given 'A, it returns a random upper case character.
Remember that in Unicode lower case (so called latin) letters are contiguous as are upper case letters.
Be sure you understand the value returned by pickChar().
Start Lecture #9
Homework: 5.17, 5.35.
One big advantage of methods is that users of a method do not need to understand how the method is implemented. The user needs to know only the method signature (parameters, return value, thrown exceptions) and the effect of the method.
Although I remember enough calculus to derive the Taylor series for sine, that might not be the best way to implement sin(). Moreover, I would need to work very hard to produce an acceptable implementation of atan(). Nonetheless, I would have no problem writing a program accepting a pair (x,y) representing a point in the plane and producing the corresponding (r,θ) representation. To do this I need to just use atan, not implement it.
As mentioned previously, when given a problem that by itself is too complicated to figure out directly, it is often helpful to break it into pieces. A very simple example was in the previous section. Separating out pickChar() made the main program easy and pickChar itself was not very hard.
We haven't done anything large enough to illustrate top-down design in all its glory. The idea is to keep breaking up the problem. That is, you first specify a few methods that would enable you to write the main() method.
Then for each of these new methods M you define other
submethods
that are used to implement M and the
process repeats.
The figure on the right (a very slightly modified version of figure 5.12 from the 8e) shows this design philosophy applied to the problem of printing a calendar for any given month.
You can guess the functionality of most of the methods from their name (an indication of good naming). Only getTotalNumberOfDays requires explanation. It calculates the number of days from 1 January 1800 to the first day of the month read from the input.
Given a fleshed out design as in the diagram, we now need to implement all the boxes. There are two styles: top-down and bottom-up.
In the first, you perform a pre-order traversal of the design. That is, you start by implementing the root calling the (unimplemented) child methods as needed.
In order to test what you have done before you are finished, you
implement stub
versions of the methods that have been called
but not yet implemented.
For example, the stub for a void method such
as printMonthBody might do nothing or might just print
something like printMonthBody called.
Stubs for non-void methods need to return a value of the correct type, but that value need not be correct.
In a bottom-up approach, you perform a post-order traversal of the design tree. That is, you only implement boxes all of whose children have been implemented (we are ignoring recursive procedures here). In the beginning this means you implement a leaf of the tree.
Since you implement the main program last, you need to write test programs along the way to test what you have implemented so far.
Read. In particular read over the full implementation of printCalendar.java
Arrays are an extremely important and popular data structure that are found in essentially all programming languages. An array contains multiple elements all of the same type.
In this chapter we restrict ourselves to a 1-dimensional (1D) array, which is essentially a list of values of a given type. The next chapter presents the more general multi-dimensional array.
In Java the ith element of a 1D array named myArray is referred to as myArray[i]. Note the square brackets [].
main(String[] args)
In the example on the right, which we have used in every program we have written, the only parameter args is a 1D array of Strings.
Note the syntax, first the base type (the type of each element of the array), then [], and finally the name of the array.
double[] y;
When the array is not a parameter as above, but is instead a locally declared variable, the syntax is essentially identical and is shown on the right. The only difference being a semicolon added at the end.
You may recall that early in the course I sometimes wrote String args[] and noticed that it worked as well as String[] args. In fact this has been added to Java just so that C language programmers would be comfortable. However, the String[] args format is preferred.
There is an important difference between declaring scalars as we have done many times previously and declaring an array. When the scalar is declared, it can be used (i.e., given a value). For an array another step is needed.
double[] x; x = new double[10];
double[] x = new double[10];
The declaration double[] x, declares x but does not reserve space for any of the elements x[i]. This must either be done separately as shown on the above right or written together as shown below the line.
The new operator allocates space, in the example on the right, enough space for 10 doubles. The effect is that the array x can hold 10 elements.
In Java the first element always has index 0, so x consists of x[0], x[1], ..., x[9].
The size of an array is fixed; it cannot be changed.
To retrieve the size of a 1D array is easy, just write name.length. For example x.length would be 10 for the example above.
Another difference between arrays and scalars is that when the array is created (using the new operator), initial values are given to each element.
for (int i=0; i<x.length; i++) {
x[i] = 34;
}
As suggested above, elements of a 1D array are accessed by giving the array name, then [, then a value serving as index, and finally a ]. For example, the code on the right, sets every element of the array x to 34.
Note the use of .length.
Creating an integer array containing the values 1, 8, 29, and -2 is logically a three step procedure.
int[] A; A = new int[4];
int[] A = new int[4];
int[] A; A = new int[4]; A[0]=1; A[1]=8; A[2]=29; A[3]=-2;
int[] A = {1,8,29,-2};
We have already seen how the first two steps can be combined into one Java statement. For example see the first two sections of code on the right.
In fact the Java programmer can write one statement that combines all three steps. The third code group on the right can be written much more succinctly as shown on the fourth group.
Note that the usage of curly brackets as shown is restricted to initialization and a few other situations, you cannot use {1,8,29,-2} in other places.
public class Test {
public static void main(String[] args) {
int[] a = new int[10];
int[] b = new int[10];
int[] c = new int[10];
for (int i=0; i<a.length; i++) {
b[i] = 2*i;
c[i] = i+100;
a[i] = b[i] + c[i]; // 3i+100
System.out.printf("a[%d]=%d b[%d]=%2d c[%d]=%d\n",
i, a[i], i, b[i], i, c[i]);
}
}
}
Very often arrays are used with loops, one iteration of the loop corresponding to one entry in the array.
In particular for loops are often used since they are the most convenient for stepping through a range of values. The first entry of the array is always index 0 and the last entry of an array A is A.length-1.
For example the simple code on the right steps through three arrays, setting the value of two of them and calculating from these values the value of the third.
We have seen several short-cuts provided by Java for common
situations.
Here is another.
If you want to loop through an array accessing (but
not changing) the ith element
during the ith iteration, you can use the
for-each
variant of a for loop.
for(int i=0; i<a.length; i++) { | for(double x: a) {
use (NOT modify) a[i] | use (NOT modify) x
} | }
Assume that a has been defined as an array of doubles.
Then instead of the standard for loop on the near right,
we can use the shortened, so-called for-each
variant on the
far right.
import java.util.Scanner;
public class StdDev {
public static void main(String[] args) {
Scanner getInput = new Scanner(System.in);
System.out.println("How many numbers do you have?");
final int n = getInput.nextInt();
System.out.printf("Enter the %d numbers\n", n);
double[] x = new double[n];
double sum=0;
for (int i=0; i<n; i++) {
x[i] = getInput.nextDouble();
sum += x[i];
}
double mean = sum / n;
double diffSquared=0; // std dev is sqrt(diffSquared/n)
for (double z : x) {
diffSquared += Math.pow(mean-z,2);
}
System.out.printf("Mean is %f; standard deviation is %f\n",
mean, Math.sqrt(diffSquared/n));
}
}
Read
Given n values, x0, ..., xn-1, the mean (often called average and normally written as μ) is the sum of the values divided by n.
The variance is the average of the squared deviations from the mean.
That is, [ (x0-μ)2 + ... +
(xn-1-μ)2 ] / n
A Java program to calculate these two values is on the right.
Note that the first loop, which modifies the x array, must
use the conventional for loop; whereas, the second loop,
which only uses the x array can use the for-each
variant.
public class DeckOfCards {
public static void main(String[] args) {
int[] deck = new int[52];
String[] suits = {"Spades", "Hearts", "Diamonds",
"Clubs"};
String[] ranks = {"Ace", "2", "3", "4", "5", "6",
"7", "8", "9", "10", "Jack", "Queen", "King"};
// Initialize cards
for (int i = 0; i < deck.length; i++)
deck[i] = i;
// Shuffle the cards
for (int i = 0; i < deck.length; i++) {
// Generate an index randomly
int index = (int)(Math.random() * deck.length);
int temp = deck[i];
deck[i] = deck[index];
deck[index] = temp;
}
// Display the shuffled deck
for (int i = 0; i < 4; i++) {
String suit = suits[deck[i] / 13];
String rank = ranks[deck[i] % 13];
System.out.println("Card number " + deck[i]
+ ": " + rank + " of " + suit);
}
}
}
Let's look at this example from the book with some care. I downloaded it from the companion web site. You can download all the code examples.
The idea is to have a deck of cards represented by an array of 52 integers, the ith entry of the array represents the ith card in the deck.
How does an integer represent a card?
First of all the integers are themselves between 0 and 51.
Given an integer C (for card), we divide C by 13 and look at the
quotient and remainder.
The quotient (from 0..4) represents the suit of the card and the
remainder (from 0..12) represents the rank.
Look at the String arrays; they give us a way to print the name of the card given its integer value (by using the quotient and remainder).
The deck initialized to be in order
starting wit the Ace of
Spades and proceeding down to the 2 of Clubs (Liang had Clubs and
Diamonds reversed).
Notice how the deck is shuffled: The card in deck[i] is swapped with one from a random location. This can move a single card multiple times. Notice the 3 statement sequence used to swap two values.
Liang printed the first 4 cards; I print the entire deck.
The last loop could be written as a one-liner
.
for (int C : deck)
System.out.printf("Card number %2d: %s of %s\n", C, ranks[C%13], suits[C/13]);
Serious business. We can no longer put off learning about references.
Consider the situation on the near right. We have created two arrays each holding 6 integers. The first has been initialized, the second has not. The goal is to make the second a copy of the first.
Note that the array name is not the array itself. Instead it points to (technically, refers to) the contents of the array. One consequence is that the size of Array1 does not depend on the number of elements in the array, which turns out to be quite helpful later on.
If we simply execute Array1 = Array2;, we get the situation in the upper right. Both arrays refer to the same content. In this state, changing the contents of one, changes the other.
If the goal is to get the situation in the lower right, you need a loop to copy each entry (or use some built in method that itself has a loop).
int a, b; a = 5; b = a; b = 10;
Look at the simple code on the right. According to the picture with arrays, after we execute b=a;, both a and b will refer to the same value, namely 5. Then when we execute b=10;, both a and b will refer to the same value, namely 10.
But this does NOT happen. Instead, b==10, but a==5 as we expected.
Why?
The technical answer is that primitive types, for example int, have value semantics; whereas, arrays (and objects in general) have reference semantics.
Looking at the diagram on the right we see that the array Array1 refers to (or points at) the actual array where the values reside; whereas, the int a and the int b ARE the values 5 and 10. There are no pointers or references involved.
When you change a or b, you change the value; when you change Array1, you change the reference (pointer).
Liang first talks about passing the entire array and then about passing individual members. I will reverse the order since I believe passing individual members is easier.
There is very little to say about passing an element of a one dimensional array as an argument. The element is simply a value of the base type of the array.
public static void printSum(int x, int y) {
System.out.println(x+y);
}
On the right is the simple printSum method that we saw earlier. It has two integer parameters. If our main method has a declaration int[] A=new int[10], then we can write, printSum(A[4],A[1]). The printSum() method will add the two values and print the sum just as if it was invoked via printSum(8,2);
public static void printArray(int[] A) {
for (i : A) {
System.out.println(i);
}
}
The printArray() method on the right has an (entire) int array as parameter. To call the array is easy: printArray(B) where B is a single-dimensional array of integers. Note that printArray can handle any size array.
The tricky part is the melding of pass by value method invocation and reference semantics for arrays, which we address next.
Assume we have a method, such as printArray that has an array parameter A and that we call it with an array argument named B.
At the point of the method call the value in B is copied to A, but, as we know, when the method returns any new value in A is NOT copied back to B. This rule still holds for arrays; no change.
The diagram at the right show the configuration when the method is called. Even, if the method changes the value in A, the value in B will not change. It will remain a pointer to the 6 element structure shown.
But now consider what happens if the called method executes A[0]+=1;. This changes not the value in B (a pointer) but instead changes the value in a cell pointed to by B. Hence when the method returns, assuming nothing else happened, the value in B[0] has been increased.
Summary, the call above cannot change the value B, but it can change the value of an individual B[i].
Java also has anonymous arrays, i.e., arrays without a name. So you can write printArray(new int[]{1,5,9});
Start Lecture #10
Remark: The username for the homework solutions is introCS (case sensitive). The password is [to be given orally in class].
Homework: 6.1. Write a program that reads student scores, tets the best score, and then assigns grades based on the following scheme.
public static int[] reverse(int[] a) {
int[] b = new int[a.length];
for (int i=0; i<a.length; i++) {
b[a.length-1-i] = a[i];
}
}
We have seen how arrays can be passed into a method. They can also be the result of a method as shown on the right. Note the following points about reverse (which returns an array that has the same elements as its input but in reverse order).
Remark: Lab1 part4 assigned.
Read
Homework: 6.3 Write a program that reads integers between 1 and 100 and counts the occurrences of each. Assume the input ends with 0. (Hint: Declare a counts array of 100 integers. When you read in x, execute counts[x]++.)
import java.util.Scanner;
public class Histogram {
public static void main(String[] args) {
System.out.printf("How many random numbers? ");
Scanner getInput = new Scanner(System.in);
int numRandom = getInput.nextInt();
int[] count = {0,0,0,0,0,0,0,0,0,0};
double[] limit = {0.0,0.1,0.2,0.3,0.4,0.5,0.6,
0.7,0.8,0.9,1.0};
for(int i=0; i<numRandom; i++) {
double y = Math.random();
for (int j=0; j<10; j++) {
if (y < limit[j+1]) { // one will succeed
count[j]++;
break;
}
}
}
for (int j=0; j<10; j++) {
System.out.printf("The number of random numbers "
+ "between %3.1f and %3.1f is %d\n",
limit[j], limit[j+1], count[j]);
}
}
}
If Math.random() is any good, about 1/10 of the values should be less than 0.1, about 1/10 between 0.1 and 0.2, etc.
The program on the right tests that out by taking a bunch of numbers returned by Math.random() counting how many fall in each 0.1 range.
Note the following points.
The program can be downloaded from here.
Lets compile and run it for different number of random numbers and see what happens.
public class VarArgsDemo {
public static void main(String args[]) {
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax(double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}
We have used System.out.printf() which has a variable number of arguments and the types of the arguments cannot be determined until run time.
I don't believe you can write printf() in Java since Java does not support such a general version of varargs. Of course that does not prevent you from using printf().
Java does permit the last parameter to be of varying length but all of the arguments corresponding to that parameter must be of the same type. Java treats the parameter as an array.
The example on the right is from the book.
Pay attention to the parameter of printMax. Java uses ellipses to indicate varargs. In this case a variable number of double arguments are permitted and will all be assigned to the array double... numbers.
Other non-vararg parameters could have preceded the double... numbers parameter.
Homework: 6.13. Write a method that returns a random number between 1 and 54, excluding the numbers passin the argument. The method header is specified as follows:
public static int getRandom(int... numbers)
public static int search(int[] A, int val)
Given an array A and a value val, find an index i such that A[i]==val.
What if there is more than one i that works?
Normally, we just report one of them.
What if there are no is that work?
We must indicate this in some way, often we return -1, which cannot
be an index (all Java arrays have index starting at 0).
What if we want to search integers and also search reals?
We define two overloaded searches.
public static int linearSearch(int[] A, int val) {
final int NOT_FOUND = 1;
for (int i=0; i<A.length; i++)
if (A[i] == val)
return i;
return NOT_FOUND;
}
There is an obvious solution: Try A[0], if that fails try A[1], etc. If they all fail return -1. This is shown on the right.
The only problem with this approach is that it is slow if the array is large. If the item is found, it will require on average about n/2 loop iterations for an array of size n and if the item is not found, n iterations are required.
Homework: 6.15. Write a method to eliminate the duplicate values in the array using the following method header
public static int[] eliminateDuplicates(int[] numbers)
Write a test program that reads in ten integers, invokes the method,
and displays the result.
mid = (hi + lo) / 2; // 1. if (A[mid]==val) return mid; // 2. else if (A[mid]<val) lo = mid + 1; // 3. else // A[mid]>val hi= mid-1; // 4.
public static int binarySearch(int[]A, int val) { final int NOT_FOUND = -1; int lo = 0; int hi = A.length -1; int mid = (hi+lo)/2; while (lo <= hi) { // 5 // above if-then-else } return NOT_FOUND; // 6 }
If the array is unsorted, there is nothing better than the above. But of course if we are doing many searches it pays to have the array sorted.
Given a sorted array, we can preform a divide and conquer attack. Assume the array is sorted in increasing order (smallest number first).
Sorting is crucial. As we just saw, fast searching depends on sorting.
There are many sorting algorithms; we will learn only two, both are bad. That is, both take time proportional to N2, where N is the number of values to be sorted. Good algorithms take time proportional to N*logN. This doesn't matter when N is a few hundred, but is critically important when N is a few million.
Moreover, serious sorting does not assume that all the values can be in memory at once.
Having said all this, sorting is important enough that it is quite worth our while to learn some algorithms. Naturally, it also helps us learn to translate algorithms into Java.
Read.
The basic idea in both the 8e and my selection sort is that you first find the minimum element and put it into the first slot (A[0]) and then repeat for the rest of the array (A[1]...A[A.length-1]).
for (j=0; j<A.length; j++)
if (A[j] < A[0]) {
temp = A[0];
A[0] = A[j];
A[j] = temp;
}
The difference is in how you find the minimum and get it into
A[0].
The code on the right shows the simple method used by bubble sort.
The code in the book is very slightly more complicated and perhaps
very slightly faster (both give bad
,
i.e., N2, sorts).
What remains is to wrap the code with another loop to find the 2nd smallest element and put it in A[1], etc.
Let's do that in class.
for (i=1; i<A.length; i++) // Insert A[i] correctly into A[0]..A[i-1]
Insertion sort is well described by the code on the right. The remaining question is how do we insert A[i] into A[0]..A[i-1] maintaining the sorted order?
In looking for the correct place to put A[i], we could either start with A[0] and proceed down the array or start with A[i-1] and proceed up the array. Why do we do the latter?
Consider an example where i is 20 and the right place to
put A[i] is in slot A[10].
Where are we going to put A[10]?
Answer: in A[11].
Then where does A[11] go?
Answer: in A[12].
public static void insSort(int[] a) {
for (int i=1; <a.length; i++) {
int ai = a[i];
int j = i-1;
while (j>=0 && ai<a[j]) {
a[j+1] = a[j];
j--;
}
a[j+1] = ai;
}
}
Thus we need to move the higher elements before we can move the lower. We can easily do this while searching for the correct spot to put A[i], providing we are traveling from higher to lower indices.
The code on the right deserves a few comments.
Homework: Eliminating
duplicates.
Write a method that accepts an array of integers and prints out the
elements in sorted order with a count of how many times it appeared.
For example if the array contains. 1,5,2,3,8,2,1,5,5 you would
print
1 appears 2 times
2 appears 2 times
3 appears 1 time
5 appears 3 times
8 appears 1 time
The book notes that Java has many predefined methods for arrays. In particular java.util.Arrays.sort(a) would have sorted the array a (for any primitive type, thanks to overloading).
The best place to see all the methods (and classes, and more) that are guaranteed to be in all Java implementations is http://download.oracle.com/javase/6/docs/api/ (really http://java.sun.com/javase/6/docs/api/).
As we have seen, a one-dimensional arrays corresponds to a list of
values of some type.
Similarly, two-dimensional arrays correspond to tables of such
values and arrays of higher dimension correspond to analogous
higher dimensional tables
.
double [][] M; // M for Matrix M = new double [2][3]; M[0][0]=4.1; M[0][1]=3; M[0][2]=4; M[1][0]=6.1; M[1][1]=8; M[1][2]=3;
double [][] M = new double [2][3];
double [][] M = { {4.1, 3, 4}, {6.1, 8, 3} };
double [][] M = {{4.1, 3, 4}, {6.1, 8, 3}};
As with one-dimensional arrays, there are three steps in declaring and creating arrays of higher dimension.
On the right we see three possibilities, the analogue of what we did last chapter for one-dimensional (1D) arrays. I wrote the third possibility twice using different spacings.
In fact there are other possibilities since a 2D array in Java is really a 1D array of 1D arrays as we shall see in the very next section.
The simple diagram on the right is very important. It illustrates what is meant by the statement that Java does not have native 2D arrays. Instead, Java 1D arrays can have elements that are themselves 1D arrays.
The M in the diagram is the same as in the example code above.
Note first of all, that we again have reference semantics for the arrays. Specifically, M refers to (points to) the 1D array of length two in the middle of the diagram. Similarly M[0] refers to the top right 1D array of size 3. However, M[0][0] is a primitive type and thus it IS (as opposed to refers to) a double.
Next note that there are three 1D arrays in the diagram (M, M[0], and M[1]) of lengths, 2, 3, and 3 respectively.
Finally, note that you cannot write M[1,0] for M[1][0], further showing that Java does not have 2D arrays as a native type.
One advantage of having 1D arrays of 1D arrays rather than true 2D arrays is that the inner 1D arrays can be of different lengths. For example, on the right, M is a length 1 array, M[0], is a length 3 array, and M[1] is a length 1 array.
Text that does not have its right margin aligned is said to have
ragged right
alignment.
Since the right hand boundary
of the component 1D arrays
look somewhat like ragged right text, arrays such as M are
called ragged arrays.
double [][] M = { {3.1,4,6}, {5.5} };
double [][] M;
M = new double [2][]; // the 2 is needed
M[0] = new double [3];
M[1] = new double [1];
M[0][0]=3.1; M[0][1]=4; M[0][2]=6;
M[1][0]=5.5;
There are several ways to declare, create, and initialize a ragged array like M. The simplest is all at once as on the upper right.
The most explicit is the bottom code. Note how clear it is that M has length 2, M[0] has length 3, and M[1] has length 1.
Intermediates are possible. For example the first two lines can be combined. Another possibility is to combine the initialization of M[0] with its creation.
for (int i=0; i<n; i++) { | for (int i=0; i<M.length; i++) {
for(int j=0; j<m; j++) { | for (int j=0; j<M[i].length; j++) {
// process M[i][j] | // process M[i][j]
} | }
} | }
On the far right is the generic code often used when processing a single 2D array (I know 2D arrays are really 1D arrays of 1D arrays). This code works fine for ragged and non-ragged (often called rectangular) arrays. Note that the bound in the inner loop depends on i.
When the array is known to be rectangular (the most common case) with dimensions n and m, the simpler looking code on the near right is used.
double maximum = Matrix[0][0]
double minimum = Matrix[0][0];
double sum = 0;
for (int i=0; i<n; i++)
for (int j=0; j<m; j++) {
if (Matrix[i][j]>maximum)
maximum = Matrix[i][j];
else if (Matrix[i][j]<minimun)
minimum = Matrix[i][j];
sum += Matrix[i][j];
}
These are quite easy since the computation for each element of the matrix is independent of all other elements. The idea is simple, use 2 nested loops to index through all the all the elements. The loop body contains the computation for the generic element.
For a possible ragged array, simply replace n by Matrix.length and replace n by Matrix[0].length.
for (int i=0; i<A.length; i++)
for (int j=0; j<A[0].length; j++)
A[i][j] = 1 + (int)((N+1)*Math.random());
We use the nested loop construction appropriate for ragged arrays. The body requires remembering how to scale Math.random() to produce numbers from 1 to N.
The reason for (int) is in case the matrix A is floating point (but we want integer values).
Read
Start Lecture #11
Remark: Using the PC browse, http://java.sun.com/javase/6/docs/api
public static void matrixMult (double [][] A,
double [][] B, double [][] C) {
// check that the dimensions are legal
for (int i=0; i<A.length; i++)
for (int j=0; j<A[0].length; j++) {
A[i][j] = 0;
for (int k=0; k<C.length; k++)
A[i][j] += B[i][k]*C[k][j];
}
}
Remark: Write the formula on the board. I do not assume you have memorized the formula. If it is needed on an exam, it will be supplied.
For multiplication the matrices must be rectangular. Indeed, if we are calculating A=B×C, then B must be an n×p matrix and C must be a p×m matrix (note the two ps). Finally, the result A must be an n×m matrix.
The code on the right does the multiplication, but it omits the dimensionality checking. Note that this checking will involve loops (to ensure that the arrays are not ragged).
An alternative would be to ask the user for the array bounds and trust that the arrays are of the size specified. Then the method definition would begin
public static void matrixMult (int n, int m, int p, double [][] A, double [][] B, double [][] C) {
// A is an n by m matrix, B is n by p matrix, C is a p by m matrix
A full program for rectangular matrices is here.
Homework: 7.5.
Remark: Lab 2, Part 1 assigned. Due in 7 days. Changed to 9 days due to midterm.
Read
Read
import java.util.Scanner;
public class Intermediate {
public static void main (String[] args) {
final double [][] points = { {0,0}, {3,4}, {1,9}, {-10,-10} };
System.out.println("Input 4 doubles for start and end points");
Scanner getInput = new Scanner(System.in);
double [] start = {getInput.nextDouble(),getInput.nextDouble()};
double [] end = {getInput.nextDouble(), getInput.nextDouble()};
int minIndex = 0;
double minDist = dist(start, points[0]) + dist(points[0], end);
for (int i=1; i<points.length; i++)
if (dist(start,points[i])+dist(points[i],end) < minDist) {
minIndex = i;
minDist = dist(start,points[i])+dist(points[i],end);
}
System.out.printf("Intermediate point number %d (%f,%f) %s%f\n",
minIndex, points[minIndex][0], points[minIndex][1],
" is the best. The distance is ", minDist);
}
public static double dist(double [] p, double [] q) {
return Math.sqrt((p[0]-q[0])*(p[0]-q[0])+
(p[1]-q[1])*(p[1]-q[1]));
}
}
Assume you are given a set of (x,y) pairs that represent points on a map. For this problem we join the Flat Earth Society and assume the world is flat like the map.
Read in two (x,y) pairs S and E representing your starting and ending position and find which of the given points P minimizes the total trip, which consists of traveling from S to P and from P to E.
Note the following points about the solution on the right.
Not as interesting as the title suggests. The program in this section just checks if an alleged solution is correct.
double x[][][] = {
{ {1,2,3,4}, {1,2,0,-1}, {0,0,-8,0} },
{ {1,2,3,4}, {1,2,0,-1}, {0,0,-8,0} }
];
There is nothing special about the two in two-dimensional arrays. We can have 3D arrays, 4D arrays, etc.
On the right we see a three 3D array x[2][3][4]. Note that both x[0] and x[1] are themselves 2D arrays.
double[][][] data =
new double[numDays][numHours][2];
double[][] temperature =
new double[numDays][numHours];
double[][] humidity =
new double[numDays][numHours];
The three dimensional array data on the upper right holds
the temperature and humidity readings for each of 24 hours during a
10 day period.
data[d][h][0] gives the temperature on day d at
hour h.
data[d][h][1] gives the humidity on day d at
hour h.
However, I do not like this data structure since the temperature and humidity are really separate quantities so I believe the second data structure is better (the naming would be better).
double[][][] temperature =
new double[numLatitudes][numLongitudes][numAltitudes];
On the right we see a legitimate 3D array that was used in a NASA computer program for weather prediction. The temperature is measured at each of 20 altitudes sitting over each latitude and longitude.
A cute guessing game. The Java is not especially interesting, but you might want to figure out how the game works.
Homework: 7.7
Remark: lab 2 part 2 assigned. Due in 7 days. Changed to 9 days due to midterm.
Remark: End of material on midterm.
Object-oriented programming (OOP) has become an important methodology for developing large programs. It helps to support encapsulation so that different programming teams can work on different aspects of the same large programming project.
Java has good support for OOP.
In Java, OOP is how gui programs are usually developed.
An object is an entity containing both data (called fields in Java) and actions (called methods in Java). Two examples would be a circle in the plane and a stack.
For a circle, the data could be the radius and the (x,y) coordinates of the center. Actions might include, moving the center, changing the radius, or (in a graphical setting) changing the color in which the circle is drawn.
For a stack, the data could include the contents and the current top of stack pointer.
In Java, objects of the same type, e.g., many circles, are grouped together in a class.
Publis class Longstack {
int top = 0;
long[] theStack;
void push(long elt) {
theStack[top++] = elt;
}
long pop() {
return theStack[--top];
}
}
On the right is the beginnings of a class for
stacks containing Java long's.
The fields
in the class are top and
theStack; the methods are push() and
pop().
Two obvious problems with this class are.
Given a class, a new object is created by instantiating the class. Indeed, an object is often called an instance of its class.
Many classes supply a special method called a constructor that Java calls automatically whenever an object is instantiated. Although a constructor can in principle perform any action, normally its task is to initialize fields. For example the longStack constructor would create the array theStack.
public class TestCircle1 {
/** Main method */
public static void main(String[] args) {
// Create a circle with radius 5.0
Circle1 myCircle = new Circle1(5.0);
System.out.println("The area of the circle of radius "
+ myCircle.radius + " is " + myCircle.getArea());
// Create a circle with radius 1
Circle1 yourCircle = new Circle1();
System.out.println("The area of the circle of radius "
+ yourCircle.radius + " is " + yourCircle.getArea());
// Modify circle radius
yourCircle.radius = 100;
System.out.println("The area of the circle of radius "
+ yourCircle.radius + " is " + yourCircle.getArea());
}
}
// Define the circle class with two constructors
class Circle1 {
double radius;
/** Construct a circle with radius 1 */
Circle1() {
radius = 1.0;
}
/** Construct a circle with a specified radius */
Circle1(double newRadius) {
radius = newRadius;
}
/** Return the area of this circle */
double getArea() {
return radius * radius * Math.PI;
}
}
On the right is the example from the book. Note several points.
The last two points above are closely related.
Start Lecture #12
Remark: reviewed practice midterm
Homework: UML diagrams are not required for all homework. 8.1, 8.3 (all ch 8 problems are at the 7th floor front desk of 715 bway.)
A static method (also called a class method) is associated with the class as a whole; whereas a non-static method (called an instance method) is associated with an individual object. The Circle1 class has one instance method along with the two constructors.
Thus when the two Circle1 objects are created, each gets its own getArea() method.
In a like manner a field can be declared to be static (none are in this example) in which case it is called a class field and there is only one that is shared by all objects instantiated from the class. (An object instantiated from a class is often called an instance of the class).
A field not declared to be static is called an instance field and each object gets its own copy; changing one, does not affect the others.
Putting this together we see that when the main() class invokes getArea() it must specify which getArea() is desired, i.e., which object's getArea() should be invoked. So myCircle.getArea() invokes the getArea() associated with myCircle and hence when it mentions radius (an instance field) it gets the radius associated with myCircle.
Start Lecture #13
Remark: Midterm
Start Lecture #14
Remark: Lecture given by Prof. Victor Shoup. (8.7 covered in lecture #15).
public class TV {
int channel = 1; // Default channel is 1
int volumeLevel = 1; // Default volume level is 1
boolean on = false; // By default TV is off
public TV() {}
public void turnOn() {
on = true;
}
public void turnOff() {
on = false;
}
public void setChannel(int newChannel) {
if (on && newChannel >= 1 && newChannel <= 120)
channel = newChannel;
}
public void setVolume(int newVolumeLevel) {
if (on && newVolumeLevel >= 1 && newVolumeLevel <= 7)
volumeLevel = newVolumeLevel;
}
public void channelUp() {
if (on && channel < 120)
channel++;
}
public void channelDown() {
if (on && channel > 1)
channel--;
}
public void volumeUp() {
if (on && volumeLevel < 7)
volumeLevel++;
}
public void volumeDown() {
if (on && volumeLevel > 1)
volumeLevel--;
}
}
public class TestTV {
public static void main(String[] args) {
TV tv1 = new TV();
tv1.turnOn();
tv1.setChannel(30);
tv1.setVolume(3);
TV tv2 = new TV();
tv2.turnOn();
tv2.channelUp();
tv2.channelUp();
tv2.volumeUp();
System.out.println("tv1's channel is "
+ tv1.channel + " and volume level is "
+ tv1.volumeLevel);
System.out.println("tv2's channel is "
+ tv2.channel + " and volume level is "
+ tv2.volumeLevel);
}
}
Above and to the right we see our first program written in two files. It is straight from the book. Each file has one public class that determines the name of the file.
Again note that the instance methods are referred to as className.methodName.
To compile and run this program you would type.
javac TestTV.java TV.java java TestTV
The last line could not have been java TV since you must invoke the file that has the main() method.
We have seen constructors above. Note the following points.
The purpose of constructors is to initialize the object being created via new.
Normally, a class provides a constructor with no parameters (as well
as other constructors with one or more parameters).
This constructor is often called the no argument
or
no-arg
constructor.
If the class contains NO constructors at all, the system provides a no-arg constructor with empty body. Thus the no-arg constructor in class TV could have been omitted.
class LongStack {
int top = 0;
long[] theStack;
LongStack() {
theStack = new long[100];
}
LongStack(int n) {
theStack = new long[n];
}
void push(long elt) {
if (top>=theStack.length)
System.out.println("No room to push");
else
theStack[top++] = elt;
}
long pop() {
if (top<=0) {
System.out.println("Nothing to pop.");
return -99; // awful!!
}
return theStack[--top];
}
}
public class DemoLongStack {
public static void main (String[] args) {
long x = 333, y = 444;
LongStack myLStk = new LongStack(4);
myLStk.push(x);
myLStk.push(y);
System.out.printf("Before: x=%d and y=%d\n", x, y);
x = myLStk.pop();
y = myLStk.pop();
System.out.printf("After: x=%d and y=%d\n", x, y);
}
}
Before: x=333 and y=444
After: x=444 and y=333
Now that we know a little more about constructors, we can add them to class LongStack, and, while we are at it, put in some error checks. The revised code is on the right.
If we knew about Java exceptions, it would be good to utilize them for these errors. In particular, returning a -99 is awful.
The default stack, i.e., the one created with the no-arg constructor, has room for 100 elements. The user can, however, specify the size when invoking new and then the other constructor will be called.
Note that LongStack is no longer a public
class.
With no public (or private or protected)
declaration, the default is that LongStack is visible
withing the current package
.
Since we don't know about packages, we will say it is visible within
the current directory.
The main() method declares a longStack and uses it a little. Below the line, we see the output produced, which indeed exhibits stack-like (FIFO) semantics.
Note especially the command myLStk.push(x), which we now discuss.
When compared to most programming languages something looks amiss
with this statement.
The purpose of the command is to push x on to the stack
myLStk and hence should
be written something like
push(x,myLStk).
Similarly, the purpose of x=myLStk.pop() is to pop the
stack and place the value into x.
So it should be something like x=pop(myLStk).
However, in Java, and other object-oriented languages, it is written as on the right. The idea is that the LongStack object myLStk contains not only the data (in this case top and theStack) but the methods push() and pop() as well.
We have previously seen this dotted notation (object dot methodname). For example, getInput.nextInt().
Recall the serious business
we mentioned in
section 6.5 when discussing copying arrays.
Liang finally comes to grips with it here.
As with arrays, variables for objects contain references to the objects not the objects themselves.
The diagram on the right illustrates the situation right after main() executes
LongStack myLStk = new LongStack(4);
We see that myLStk refers to (points at) the new object.
We also see that the object has three pieces.
int top, which is a primitive type so actually contains the value.
The above is very important. It is a key tenant of Java that primitive types have value semantics and that both arrays and objects have reference semantics.
After creation, methods and data fields within objects are referenced using dot notation as mentioned above and illustrated by getInput.nextInt(), myLStk.pop(), and myLStk.top.
Note that the fields and methods just mentioned do not have the static modifier (we will see f static fields later and have seen many static methods already. Fields and methods that are not static are called instance fields (or instance variables) and instance methods.
If in the DemoLongStack example above, the main() method created two LongStack's, each one would have its own top, theStack, push(), and pop().
As I mentioned several lectures ago, Java assigns default values to many variables, but I do not use or recommend learning the default values. I always (try to remember to) explicitly give the variables values at their declaration or ensure that they are assigned a value before there value is requested.
We see here that in some cases, Java does not assign a default value. Since I suggest not making use of default values, I don't see a need to remember which variables get defaults (and what the default is) and which variables do not.
Nonetheless there is one default you will need to recognize as it will indicate a fairly common error. If you declare an object or array but do not create it, then it receives the default value (really default reference or pointer) null. If you then use the object, you can get a nullpointerexception.
For example, if LongStack class had no constructors, then the declaration/creation of myLStk in DemoLongStack would be erroneous and the program would not compile since there would be no constructor to match the new operator. If, in addition. the declaration/creation was changed to not specify the size, the program would compile and the default do-nothing, no-arg constructor would be called. The result would be that theStack would be declared but not created. Then, when the first push is invoked, a nullpointerexception would be raised because theStack contains null.
int[] a = {1,2,3}, b;
b = a;
b[1] = 999;
System.out.println(a[1]);
This section finally gives the pictures showing that reference types only point to values; they do not contain the values. All this applies equally well to arrays where we previously discussed it.
The example on the right illustrates reference semantics: The value printed is 999.
A significant strength of Java is its very extensive class library.
Let's use opportunity as an excuse for learning how to obtain information from http://java.sun.com/javase/6/docs/api.
The 8e mentions two constructors and three methods (toString(), getTime(), and setTime).
If you knew that Date was java.util.Date you could restrict the classes, but let's not and use the default of all classes.
The same two constructors are present as in the 8e (along with several that are deprecated). The methods are there as well, together with many others (some deprecated).
import java.util.Date Date myDate = new Date(); System.out.println(myDate.toString());
Don't forget the syntax of ClassName.methodName.
On the right is a simple example basically from the book.
The one difference is that I used an import statement.
How would it have differed without the import?
Answer: Date would have been java.util.Date twice
in the declaration/creation.
Again use the web and find the same constructors and a superset of the methods().
Skipped for now.
Homework: 8.3.
We have now seen several methods in classes that are associated with objects. For example myDate.toString() invokes the toString() method that is associated with the object myDate. If we had also declared another Date, say yourDate, then myDate.toString() would be a different method from yourDate.toString().
This is a good thing since the string format of myDate is different from the string format of yourDate (unless myDate and yourDate happen to refer to the exact same time).
Similarly, we have seen several data fields defined in classes that are associated with each instance of the class. For example, the top of each instance of LongStack is unique.
This is also good. If you have several LongStack's, you don't expect their top's to be equal and surely pushing one LongStack does not affect the top of any other LongStack.
class ShortStack {
int top = 0;
short[] theStack;
ShortStack() {
theStack = new short[100];
}
ShortStack(int n) {
theStack = new short[n];
}
// Maintain total number of items stacked
static int totalStacked = 0; // should be pvt
static int getTotalStacked() {
return totalStacked;
}
void push(short elt) {
if (top>=theStack.length)
System.out.println("No room to push");
else
theStack[top++] = elt;
totalStacked++;
}
short pop() {
if (top<=0) {
System.out.println("Nothing to pop.");
return -99; // awful!!
}
totalStacked--;
return theStack[--top];
}
}
public class DemoShortStack {
public static void main (String[] args) {
ShortStack mySStk1 = new ShortStack(4);
ShortStack mySStk2 = new ShortStack();
mySStk1.push((short)12); mySStk1.push((short)13);
mySStk2.push((short)22); mySStk2.push((short)23);
System.out.printf("Before pops: stacked=%d\n",
ShortStack.getTotalStacked());
short x = mySStk1.pop();
short y = mySStk1.pop();
System.out.printf("After pops: x=%d, y=%d %s%d\n",
x, y, "and stacked=",
ShortStack.getTotalStacked());
}
}
Before pops: stacked=4
After pops: x=13, y=12 and stacked = 2
But sometimes having separate instances of each method and field for each object is not what we want. On the right we see ShortStack. I derived it from LongStack, by first replacing all long's with short's.
Then I decided to keep track of the total number of items stacked on all the ShortStack's. This single variable totalStacked is incremented by every push(), no matter which ShortStack is being pushed, and is decremented by every pop(). We indicate that there is one totalStacked associated with the entire class ShortStack rather than one totalStacked associated with each instance of totalStacked (i.e., one associated with each object) by declaring totalStacked to be static.
A variable like totalStacked that is associated with the class and not with each instance is called a static variable or a class variable.
I could have printed this value in the main() method, but did not. Instead, I defined a method getTotalStacked() that simply returns its value and had the main() method call getTotalStacked(). As we will see in the next section, it is possible to prevent other classes from seeing a variable, which has the great advantage that the programmer of the original class can be sure that no other class either changes the variable or depends on how the variable is implemented.
In such cases it is common to supply an accessor method
like getTotalStacked()
to get the value and sometimes another
method to alter the value.
We could have writen getTotalStacked() as an instance method, so that there would be one associated with each object of type ShortStack. However, that would be a little silly (but would work) since the method just returns the value of a class field and hence all instances of the method would be the same. Hence we declare getTotalStacked() to be static so that there is only one getTotalStacked() method for the entire class. That is, we make it a class method or static method.
One more point, one that will reveal a great secret. Since a class method is dependent on only the class and not on any object of the class, we can define and use a class method even if there are no objects of the class. At long last we can understand
public static void main (String[] args)
which must be used in every Java program.
Some of our classes, data fields, and methods have been
public and some have not.
What gives?
There are actually four possibilities, of which we have used two.
(Top level classes, i.e., classes not inside any other class, can not be declared private or protected.)
An entity (a class, field, or method) that is declared to be public can be accessed from any class.
An entity that is declared to be private is accessible only within its own class.
public class PubClass {
public int x; // accessible everywhere
private int f2() { // accessible only in PubClass
return 2;
}
private class PvtClass {
// x and f2() accessible here
}
}
// Following is a new file
public class C2 {
// x accessible f2() is not
private class C1 {
// x accessible f2() is not
}
}
Look at the example on the right and note the following.
Java includes the notion of a package, which is a
collection of classes.
A .java file can begin with a line
package packageName;
which declares all the classes in the file to be in the package
packageName.
Packages are very important for large programs, but less so for those we write.
None of our .java files have included a
package statement.
In such cases Java places the classes declared in the file into the
so called default package
.
If an entity is declared without a visibility modifier (public, private, or protected), then the entity has package visibility, which means it is visible in all classes belonging to the same package as does the entity.
The protected visibility modifier comes into play only when there are subclasses and inheritence so we defer it to Chapter 11.
Until we learn about subclasses and protected, our use of modifers will be fairly simple (in part because we are not learning about packages).
Homework: 8.7
class ShortStack {
int top = 0;
short[] theStack;
class ShortStack {
private int top = 0;
private short[] theStack;
int getTop() {
return top;
}
On the upper right we see the beginning of the ShortStack class we saw previously. In the second group, we added private visibility modifiers, which improves the class considerably. Why?
public class Circle3 {
private double radius = 1;
private static int numberOfObjects = 0;
public Circle3() {
numberOfObjects++;
}
public Circle3(double newRadius) {
radius = newRadius;
numberOfObjects++;
}
public double getRadius() {
return radius;
}
public static int getNumberOfObjects() {
return numberOfObjects;
}
public double getArea() {
return radius * radius * Math.PI;
}
public void setRadius(double newRadius) {
radius = (newRadius >= 0) ? newRadius : 0;
}
}
Until we learn about packages and subclasses, we need only
distinguish public and private.
Both protected and the default package-private
are
equivalent to public
in the absence of subclasses and
packages.
On the right we see an improved circle class, now called Circle3 (we did not do Circle2).
mutatormethod is interesting. If we want to let clients modify the radius field, why didn't we just make it public?
Homework: 8.9.
class ShortStack {
private int top = 0;
private short[] theStack;
ShortStack() {
theStack = new short[100];
}
ShortStack(int n) {
theStack = new short[n];
}
private static int totalStacked = 0;
static int getTotalStacked() {
return totalStacked;
}
int getTop() {
return top;
}
void push(short elt) {
if (top>=theStack.length)
System.out.println("No room to push");
else
theStack[top++] = elt;
totalStacked++;
}
short pop() {
if (top<=0) {
System.out.println("Nothing to pop.");
return -99; // awful!!
}
totalStacked--;
return theStack[--top];
}
}
public class DemoShortStack2 {
public static void main (String[] args) {
ShortStack mySStk1 = new ShortStack(4);
ShortStack mySStk2 = new ShortStack();
mySStk1.push((short)12); mySStk1.push((short)13);
mySStk2.push((short)22); mySStk2.push((short)23);
System.out.printf("Before pops: stacked=%d\n",
ShortStack.getTotalStacked());
short x = mySStk1.pop();
short y = mySStk1.pop();
System.out.printf("After pops: x=%d, y=%d %s%d\n",
x, y, "and stacked=",
ShortStack.getTotalStacked());
System.out.println("Printing and emptying stack #1");
printAndEmptyShortStack(mySStk1);
System.out.println("Printing and emptying stack #2");
printAndEmptyShortStack(mySStk2);
}
public static void printAndEmptyShortStack(ShortStack SStk){
System.out.printf("The stack has %d items.\n",
SStk.getTop());
for (int i=1; SStk.getTop()>0; i++)
System.out.printf("Item #%d is %d\n", i, SStk.pop());
System.out.println();
}
}
Before pops: stacked=4
After pops: x=13, y=12 and stacked=2
Printing and emptying the first stack
2 items stacked, 0 in this stack.
Printing and emptying the second stack
2 items stacked, 2 in this stack.
Item #1 is 23
Item #2 is 22
As with arrays, passing an object to a method actually passes a reference (pointer) to the object.
The book illustrates this with one of the circle classes. You should read that.
For variety (i.e., a different example) we consider our ShortStack class.
As illustrated on the right, we have included the following improvements/enhancements.
The diagram shows the situation when main() has called the method for the first time.
We see that the integers are using value semantics (they are their values); whereas the objects (in this case ShortStack's) have reference semantics and only refer to (point at) their values.
Also note the call-by-value semantics. The contents of the argument myStk1 is copied into the parameter SStk.
Start Lecture #15
Remark: Reviewed most of midterm.
Start Lecture #16
Remark: Finished review of midterm.
Remark: Covered section 8.7.
Arrays of objects just puts together the semantics of arrays with the semantics of objects. Consider the diagram on the right.
In Java a String is an object. Thus, like a ShortStack, a String has reference semantics.
In some languages a string is an array of characters. Although an array of char's is similar to a Java String (e.g., both have reference semantics), an array of char's is not the same as a String (e.g., you do not use [] to extract a char from a String).
As shown on the right, String's can be created several ways.
String s1 = new String();
String s2 = new String("A string");
char[] c1 = {'c','h','a','r','','a','r','r','a','y'};
String s3 = new String(c1);
String s4 = "Another String";
String s1 = "joe"; s1 = "linda"; String s2 = "linda";
String objects are immutable, they cannot be changed. However, a string variable is mutable and can reference different string objects at different times.
On the right we have two String objects "joe" and "linda", and two String variables s1 and s2. The objects cannot change but we have changed one of the variables.
Interned
Java creates only one copy of each string literal, even if you write it several times. Thus after the code above is executed, there is only one object "linda". The technical term is that the literal is interned.
String s3 = new String ("linda");
if (s1==s2) YES
if (s1==s3) NO
Both s1 and s2 refer to this one literal. That is, s1 and s2 contain the same reference and, as indicated to the right they are equal (==).
However, again as mentioned previously, when you create a string from another using the constructor as on the right, a copy is made. Since s3 refers to this copy it is NOT equal (!=) to either s1 or s2.
The last paragraph seems very bad. You have two variables s1 and s2 both of which evaluate to "linda", but they are unequal. We can't seem to tell that the referred values are equal. Fortunately, there are more sections to this chapter.
The problem we just had was that we were comparing the references and not the values they referred to. To do the latter we need to use a method in the String class.
boolean equals (Object anObject)
On the right we see the equals() method. Technically, it has an Object as parameter, but for now pretend that the only permitted Object is a String.
String s1 = "joe";
String s2 = new String(s1);
if ("joe".equals(s1)) YES
if ("joe".equals(s2)) YES
Something looks wrong! How come equals has only one parameter. Surely, we want to see if two strings are equal. The answer is that equals() is an instance method and this is attached to a string object, which it then compares to its parameter. We see an example of the usage on the right. Note that in this example if(s1==s2) would be NO.
There are other string comparison methods defined, e.g., one that
ignores case and one (compare.To() that distinguishes
less than
from greater than
(see below).
Java has many methods dealing with strings. We will just touch on a few. See the API for a list.
int length() char charAt(int index) String concat (String s)
The three methods on the right length(), charAt(), and concat() are all instance methods. That is, they are associated with an instance of a class, i.e., an object. The notation used is objectName.methodName(args). Note that the named object is a de facto extra parameter.
Start Lecture #17
String substring(int start) String substring(int start, int end)
There are two overloaded substring() instance methods. The first, one argument, variant gives the substring starting at the position specified by the argument. The other, two argument, variant gives the substring starting at the position specified by the first argument and ending just before the position specified by the second argument.
For example, "jane".substring(1,2)=="a" .
String toLowerCase() String toUpperCase() String trim() String replace(char old, char new) String replaceFirst(String old, String new) String[] replaceAll(String old, String new) String split(String delim)
String[] ans = "ab cd e".split(" ");
ans[0]=="ab" ans[1]=="cd" ans[2]=="e"
The methods on the right are well described by their names except perhaps for trim() and split.
trim() removes leading and trailing blanks.
split() is quite nice splitting the original string at the specified delimiter returning the pieces as an array.
For example, executing the statement shown in the middle right, declares ans to be an array of strings having three elements. These elements are shown on the bottom right.
Many of the string arguments in the preceding section are
interpreted as regular expressions
, which can be quite
useful.
For example the regular expression *\.java would match any string
that ended in .java.
In addition to the methods in 9.2.6, we note matches(), which is like equals() except that its string argument is interpreted as a regular expression.
int indexOf(char c) int indexOf(String s)
The two methods on the right find the first occurrence of the character or string in the object. They return -1 if the character or string does not occur.
There are variants that look for the first occurrence after a specified position, the last occurrence, or the last occurrence before a specified index. They all return -1 if the search is unsuccessful.
We have already seen the String(char[] charArray) constructor. The inverse operation is provided by the toCharArray() method.
char[] ca = "Joseph".toCharArray(); String s1 = new String(ca);
String s2 = new String("Joseph".toCharArray());
For example, the first code snippet initializes s1 to
Joseph in a complicated way, using the character array
ca as an intermediary.
The second (one-line, no intermediary) snippet, is perhaps even more
complicated.
So far we have see constructors and instance methods. No we will see two class methods, one of which is heavily overloaded.
The class method String.valueOf() converts many data types into strings. Note again that this is a class (i.e., static) method so is associated with the class String and not with any specific string. It is heavily overloaded; there are versions with a char argument, a char[] argument, a double argument, an int argument, a boolean argument, and others as well.
The other class method is String.format(). It takes the same arguments as System.out.printf() but, instead of printing the result, it returns it as a String.
For example,
String s = String.format("3.777 rounded to 2 places is %4.2f", 3.777);
sets s equal to 3.78
A palindrome is a string that reads the same from left to right as from right to left. Note that blanks count. For example the following are palindromes.
import java.util.Scanner;
class DemoPalindrome {
public static void main (String[] Args) {
Scanner getInput = new Scanner(System.in);
while (true) {
System.out.println("Type a string, use !!EXIT!! to exit");
String s = getInput.nextLine();
if (isPalindrome(s))
System.out.println
(String.format("\"%s\" is a palindrome.", s));
else
System.out.println
(String.format("\"%s\" is not a palindrome.", s));
}
}
public static boolean isPalindrome(String s) {
int lo = 0;
int hi = s.length()-1;
while (lo < hi) { // this works for *all* s
if (s.charAt(lo) != s.charAt(hi))
return false;
lo++;
hi--;
}
return true;
}
}
The program on the right, queries the user for a string and then checks if it is a palindrome. Note the following points.
Read
The compareTo() String instance method makes alphabetizing essentially the same as sorting integers, as shown by the side by side code comparison below.
public class DemoSortString {
public static void main (String[] args) {
String[] strArray = {"a","zzz","abc","ab","Z","6"};
System.out.println("Before");
for (int i=0; i<strArray.length; i++)
System.out.println(strArray[i]);
sortString(strArray);
System.out.println("After");
for (int i=0; i<strArray.length; i++)
System.out.println(strArray[i]);
}
public static void sortString(String[] strArray) {
for (int i=0; i<strArray.length-1; i++)
for (int j=i+1; j<strArray.length; j++)
if(strArray[i].compareTo(strArray[j]) > 0) {
String t = strArray[i];
strArray[i] = strArray[j];
strArray[j] = t;
}
}
}
public class DemoSortInt {
public static void main (String[] args) {
int[] intArray = {6, 9, 2, 4, 1, 8};
System.out.println("Before");
for (int i=0; i<intArray.length; i++)
System.out.println(intArray[i]);
sortInt(intArray);
System.out.println("After");
for (int i=0; i<intArray.length; i++)
System.out.println(intArray[i]);
}
public static void sortInt(int[] intArray) {
for (int i=0; i<intArray.length-1; i++)
for (int j=i+1; j<intArray.length; j++)
if(intArray[i] > intArray[j]) {
int t = intArray[i];
intArray[i] = intArray[j];
intArray[j] = t;
}
}
}
The only real difference between the two code snippets is that the integer comparison via > is replaced by compareTo(), which returns a positive, zero, or negative integer depending on whether the given object is greater than, equal to, or less than the argument.
For fun let's try to write a class method compareStr() that takes two arguments and returns a positive, zero, or negative integer depending on whether the first argument is greater than, equal to, or less than the second.
public static int compareStr(String s1, String s2) {
final int EQUAL=0, LESS=-123, GREATER=321;
for (int i=0; i<s1.length() && i<s2.length(); i++)
if (s1.charAt(i) < s2.charAt(i))
return LESS;
else if (s1.charAt(i) > s2.charAt(i))
return GREATER;
if (s1.length() < s2.length())
return LESS;
else if (s1.length() > s2.length())
return GREATER;
else // s1.length() == s2.length()
return EQUAL;
}
This is one of those programs where I found it useful to think first and just sketch out the idea before starting to code. It is actually fairly easy, but you can be lead astray.
The code on the right has two parts.
Wrapper) Class(es)
As mentioned, Java is an object oriented (OO) language and objects/classes play a central part in serious Java programming.
However, the advantages of OO languages comes in to play mostly for large programs, much larger than any we will write. So, for us as of now there isn't all that much advantage to using an object of type Character rather than a value of type char.
We call the class Character a wrapper
for the
primitive type char
.
Similarly, Java provides wrapper classes Boolean,
Byte, Short, Integer, Long,
Float, and Double for the corresponding primitive
types boolean, byte, short, int,
long, float, and double.
Do remember that the wrapper classes provide objects, and thus have reference semantics.
It is easy to obtain the Character corresponding to a given char: The Character class provides a constructor for just this purpose. Thus, new Character('a') produces the Character corresponding to the char 'a' .
boolean isDigit(char c) boolean isLetter(char c) boolean isLetterOrDigit(char c) boolean isLowerCase(char c) boolean isUpperCase(char c) char toLowerCase(char c) char toUpperCase(char c)
Perhaps the piece of the Character class most useful to us now, is the collection of class methods that operate on char's (not Character's).
On the right we see seven of these useful class methods. As an example to test if the char c) is a digit, you would write
if (String.isDigit(c))
Note the consistent naming: the prefix is used for a test, and the prefix to used for a conversions.
Homework: 9.1 and 9.5.
Java has 3 classes whose objects are strings
, namely
String, StringBuilder, and StringBuffer.
import java.util.Date;
class Test {
public static void main (String[] Args) {
StringBuilder sb = new StringBuilder("Hello");
String s = new String ("Hello");
System.out.printf("s is \"%s\" and sb is \"%s\"\n", s, sb);
System.out.printf("The lengths of s and sb are %d and %d\n",
s.length(), sb.length());
System.out.printf("The capacity of sb is %d\n", sb.capacity());
s = s.concat(", world.");
sb.append(", world.");
System.out.printf("s is \"%s\" and sb is \"%s\"\n", s, sb);
}
}
s is "Hello" and sb is "Hello"
The lengths of s and sb are 5 and 5
The capacity of sb is 21
s is "Hello, world." and sb is "Hello, world."
Superficially a String s and a StringBuilder Sb can appear to act the same. Indeed, a quick glance at the code on the right suggests that StringBuilder adds nothing.
In this case, however, looks can be deceiving. Specifically, s.concat() and sb.append() are really quite different because the String referenced by s is immutable; whereas, the StringBuffer referenced by sb is not.
The expression sb.append(", world") actually appends the argument onto the object referenced by sb. It does not copy the original contents of that object.
In contrast s.concat(", world") does not, indeed cannot change the string referenced by s. What happens is that
There are other StringBuilder instance methods that permit insertions and modifications in the middle of the object as well as deletion of parts of the object. One could write String methods to do the same, but they would be a little more complicated.
There are other methods as well.
For our programs it hardly matters at all. The real advantage of StringBuilder is that these manipulations are done on the original, with no copy being made. For strings of length a few dozen, making copies is no big deal (unless done very many times). However, for much larger strings, the copying can become expensive.
All of these are instance methods. As expected sb.toString() returns the String equivalent of the StringBuilder sb, sb.length() returns the length, and sb.charAt() returns the character at the position specified by the argument.
The capacity() instance method is less obvious. A Java StringBuilder object is generally bigger than its current length (this larger size is called the capacity). That way it is easy to append characters. Except for efficiency considerations, we can ignore capacity since the JVM will extend the StringBuilder whenever needed.
You can also reduce the length of a StringBuilder (eliminating characters at the end) or increase its length (padding with null characters).
The book's solution is basically an exercise in using a few of the methods. The basic steps are
The reason for converting back to String's is that (surprisingly?) I don't think StringBuilder has an equals() or compareTo() method.
Homework: 9.11
We know that the main() method has a single parameter, which is an array of String's. However, we have not yet made use of this. Technically, we have used it all the time; we just had the empty array.
Recall that, if we have a program Prog.java, we compile it with the command javac Prog.java and run the result with the command java Prog.
To introduce command-line arguments, there is no change to the compilation, but we run the program differently. Specifically we add the arguments after the name of the program.
Say we want to give Prog three arguments, one integer and two strings. Specifically the arguments are: 25, arg 2, last. We would write
java Prog 25 "arg 8" last
Several comments are needed.
Start Lecture #18
Homework: 9.1, 9.5, 9.11.
Remark: On monday night I was editing my magazine column and needed a function to reverse a number. Since I just taught it a few hours previously, I actually wrote one of those routines that is all library method calls. Then, for fun I made it an ugly one-liner. Here is the result.
import java.util.Scanner;
import java.io.File;
public class TechRev {
public static int reverse (int n) {
// StringBuilder sb = new StringBuilder(Integer.toString(n));
// return Integer.parseInt(sb.reverse().toString());
return Integer.parseInt(new StringBuilder(Integer.toString(n)).reverse().toString());
}
}
Remark: Added the missing two lines to the Calculator.
public class Calculator {
public static void main(String[] args) {
if (args.length != 3 || args[1].length != 1) {
System.out.println(
"Usage: java Calculator operand1 [+-*/] operand2");
System.exit(0);
}
char operator = args[1].charAt(0);
int result;
switch (operator) {
case '+': result = Integer.parseInt(args[0]) +
Integer.parseInt(args[2]);
break;
case '-': result = Integer.parseInt(args[0]) -
Integer.parseInt(args[2]);
break;
case '*': result = Integer.parseInt(args[0]) *
Integer.parseInt(args[2]);
break;
case '/': result = Integer.parseInt(args[0]) /
Integer.parseInt(args[2]);
break;
default: System.out.printf("Illegal operator %c\n",
operator);
System.exit(0);
}
System.out.printf("%s %c %s = %d\n",
args[0], operator, args[2], result);
}
}
The code on the right (only slightly modified from the book) is for a trivial calculator that can do one operation, providing the operation is +, -, *, or /. There are a few points to say about it.
Homework: 9.13, 9.15
One of the major uses of command-line arguments is to tell programs which files to process. We next learn how to do that.
In Java reading and writing files is divided into two tasks.
The File class is used to construct a File object from a file name and to perform certain operations on the object. However, it is not used to create a file, to read a file, or to write a file.
File(String pathname) File(String parent, String child) File(File parent, String child)
The primary form of the File constructor is the first one shown on the right. This form accepts a single String fn as parameter and constructs a file object corresponding to the file with name fn.
This file may or may not exist and the constructor does not create the file in any case. The name may be relative (to the current directory) or may be absolute. One downside of absolute addresses is that they are OS dependent.
The File class includes exists(), canRead(), canWrite(), isDirectory(), isFile, isAbsolute(), and isHidden().
Their names describe well their actions.
The File class includes getName(), getPath(), and getParent().
They return respectively the file name without any directories, the full file name, and the full file name of the parent.
System.out.println(new java.util.Date(file.lastModified()));
prints the modification date in a human-readable format.
Once we have an object File f1 we can actually perform input/output on the corresponding file in the file system.
One complication that can occur is that the I/O operation can fail. For example, you might try to read from a file that doesn't exits or write to a file for which you do not have the needed permissions. The technical term is that an I/O exception can occur. We will learn about exceptions later; for now we simply add throws Exception to the header line for any method that (directly or indirectly) invokes I/O.
The first step in writing data to a file is to create a PrintWriter object, which in turn needs a File object. We can create both at once with
java.io.PrintWriter output = new java.io.PrintWriter(new java.io.File("x.text"));
If the above looks too imposing, use some import statements.
import java.io.PrintWriter;
import java.io.File;
PrintWriter output = new PrintWriter(new File("x.text"));
Now we can use output the way we have used System.out in the past. For example we can write output.printf("hello");
After all the data has been sent to the PrintWriter object, its close() instance method should be called.
We have used the Scanner class many times, but always with System.in, which is predefined to correspond to the keyboard. In order to obtain a Scanner capable of reading from the file named existing.text we write
Scanner input = new Scanner(new File ("existing.text"));
(assuming the necessary import's have been executed.
You can also write this declaration (and the one for PrintWriter) in two steps.
File f = new File("existing.text");
Scanner input = new Scanner(f);
Remark: Note that the book is rather confusing at the end of this section. It seems to be saying that the behavior is different when you change from an input file to input from the keyboard. As far as I can see, the real change is where the newlines are placed.
import java.util.Scanner;
import java.util.Date;
import java.io.File;
public class Test {
public static void main (String[] Args) throws Exception {
Scanner input = new Scanner (new File ("t.txt"));
Scanner getInput = new Scanner (System.in);
String s1 = input.next();
String s2 = input.next();
String line = input.nextLine();
System.out.printf("s1=\"%s\" and s2=\"%s\"\n", s1, s2);
System.out.printf("line=\"%s\"\n", line);
s1 = getInput.next();
s2 = getInput.next();
line = getInput.nextLine();
System.out.printf("s1=\"%s\" and s2=\"%s\"\n", s1, s2);
System.out.printf("line=\"%s\"\n", line);
}
}
File t.txt contains one line (ending with a newline)
34 567 |<-- the line ends here
I entered the same characters from the keyboard
s1="34" and s2="567"
line=" "
s1="34" and s2="567"
line=" "
The instance methods nextByte(), nextShort(),
nextInt(), nextLong(), nextFloat(),
nextDouble(), and next() are often referred to as
token-reading methods.
They all work basically the same and depend on the value of the
delimiter
, which by default is equal to whitespace
.
Although there are other characters often considered whitespace and
one can change the delimiter, for now just think of delimiter as
meaning any non-empty mixture of blanks, tabs, and newlines.
Then the token-reading methods work as follows.
The nextLine() method is different and is not considered token-reading. It acts as follows.
import java.io.*;
import java.util.*;
public class ReplaceText {
public static void main(String[] args) throws Exception {
if (args.length != 4) {
System.out.printf("Usage: java ReplaceText %s\n",
sourceFile targetFile oldStr newStr");
System.exit(0);
}
File sourceFile = new File(args[0]);
if (!sourceFile.exists()) {
System.out.println("Source file " + args[0] +
" does not exist");
System.exit(0);
}
File targetFile = new File(args[1]);
if (targetFile.exists()) {
System.out.println("Target file " + args[1] +
" already exists");
System.exit(0);
}
Scanner input = new Scanner(sourceFile);
PrintWriter output = new PrintWriter(targetFile);
while (input.hasNext()) {
String s1 = input.nextLine();
String s2 = s1.replaceAll(args[2], args[3]);
output.println(s2);
}
input.close();
output.close();
}
}
The program on the right illustrates many of the concepts we have just learned and is worth some study.
The program is executed with four command-line arguments, the first two are file names and the second two are strings (technically, all command-line arguments are Strings; the first two are interpreted by the program as names of files).
The program copies the first file to the second replacing all occurrences of the third argument with the fourth argument.
Start Lecture #19
Homework: 9.19.
We have seen already some differences when using objects. With instance methods one of the parameters is the object itself and is written differently. For example given a String s1, we get its length via s1.length() rather than length(s1). Designing (large) systems using objects as centerpieces (so called object-oriented design) has deeper differences from conventional design than the essentially syntactic change in length().
An object is called immutable if, once created, it cannot be changed.
Let me be clearer about that. When we say the object cannot be change, we mean the data fields of the object cannot be changed.
For example, any String object is immutable (its only data field is the sequence of characters that constitute the string). A class, such as String, all of whose objects are immutable is also called immutable.
public class NoChanges {
private int x;
public NoChanges(int z) {
x = z;
public int getX() {
return x;
}
}
public class Changes {
public int a;
public int b;
public Changes(int r, int s) {
a = r; b = s;
}
}
public class Maybe {
private Changes c;
public Maybe(int w) {
c = new Changes (w,w);
}
public Changes getC() {
return c;
}
}
public class Immutable {
public static void main (String[] Args) {
NoChanges nc = new NoChanges(5);
Changes c = new Changes (5,6);
c.a = 9;
Maybe mb = new Maybe(12);
System.out.println(mb.getC().a);
// mb.c.a = 1; Will not compile but
mb.getC().a = 1; // works fine
}
}
What must we do to write an immutable class?
Naturally, we must make all the data fields private and
no public method can change a data field.
Such methods are often called mutators
.
But that is not enough!
Looking to the right, clearly the class NoChanges is immutable: the only data field is x, which cannot be directly accessed (it is private). With the accessor getX() we can find the value of x, but cannot change it. Thus once we create a NoChanges object with say
Nochanges nc = new NoChanges(5).
then nc.x==5 and will never change.
Similarly the class Changes is not immutable (it is mutable). We can say
Changes c = new Changes (5,6);
c.a = 9;
and have changed the object c by changing its first
component from 5 to 9.
The interesting case is class Maybe. At first (and even second) glance it looks like class NoChanges. Indeed each line of Maybe looks like the corresponding line of NoChanges. The only difference is the initialization of c. But just as with NoChanges, we do not have direct access to c (it is private) and the accessor lets us only find c's current value, not change it.
But there is a difference! The variable c is of type Changes, which is an object and hence has reference semantics. Also the object to which we now have a reference is itself mutable. Therefore the accessor has returned a reference that enables us to change the value of the components. Code to exploit this hole is shown in the bottom frame on the right.
Thus there are three requirements for a class to be immutable.
There are two kinds of variables found in a class.
Data fields (a.k.a. class variables).
These have scope the entire class (except where hidden
,
see below) including prior to their declaration.
If one data field, say x, is initialized to an expression involving another field y, then y must be declared before x.
Variables (including parameters) declared in a method.
These are referred to as local variables
.
Naturally, the same variable name can be declared in multiple methods. As we have seen previously, the same name can be declared in disjoint blocks in the same method. In both these cases each instance of the name refers to a separate variable.
If a local variable has the same name as a data field, the field is hidden (i.e., not directly accessible) in that method. For this reason as well as for increased clarity, it is not recommended (but is permitted) to use the same name for both a class variable and a non-parameter local variable.
We shall see next section that it is common to have parameters with the same name as fields.
The special name this is used in several ways with respect to objects and classes. We see two of them on the right as well as an illustration of a few other points. Although the code is quite simple, it warrants some careful study.
public class C {
int i;
static int si = 4;
C (int i) {
this.i = i;
}
C () { // no-arg constructor
this(8);
}
int getI () { // nothing hidden
return i;
}
void setI (int i) { // instance field
this.i = i;
}
void setSi (int si) { // class field
C.si = si;
}
public static void main (String[] args) {
C c = new C();
System.out.println(c.i);
}
}
set methods, one for setting each of the two fields, and a main() method.
set methodsthe convention is to use as parameter the name of the field being set, thus hiding the field name. For an instance set method, we need to reference the current object and hence use this.
exposesthe hidden field name.
Class abstraction is the separation of how a class is used from how a class is defined.
Another name is information hiding
, the implementation of
the class is hidden from the users of the class.
How to use a given class is described by the class specification, also called is public interface. In Java classes, fields and methods declared public form the interface. In contrast, private fields and methods form the implementation.
When looked at from the user's point of view, the class encapsulates the knowledge needed to use these object. In the next section we discuss an example.
public class CheckingAcct {
private String acctName;
private double balance = 0;
CheckingAcct(String acctName) {
}
public void makeDeposit (double amt) {
}
public boolean makeWithdrawal (double amt) {
}
}
public class TestChecking {
public static void main (String [] Args) {
CheckingAcct acct = new CheckingAcct(
"Allan Gottlieb's checking acct");
acct.makeDeposit(100.00);
acct.makeWithdrawal(30.00);
}
}
Allan Gottlileb's checking account
Description Amount Balance
Deposit 100.00 100.00
Withdrawal 30.00 70.00
The book discuss a loan example, which you should read. We will do the beginnings of a checking acct example.
On the right is the very beginning of a CheckingAccount class. Currently, we can open an account (in Java-speak we can create a CheckingAccount object), make deposits, and make withdrawals.
The bottom section shows the output produced.
This is not what a bank would use, but what customers would used for themselves. For example, we will not generate monthly statements, but might process a monthly statement received by the bank. Also banks do not permit withdrawals that drive the balance negative, but we will permit it since the user may know that certain previous debits have not cleared. Most significantly, we do not do any of the hard work involving actually money.
To handle writing a check, we need a data structure for the check itself, including the date, amount, payee, and note. We would also need a data structure for a statement. These would also be objects so would need class definitions. The class for checks might contain no methods.
A CheckingAccount object would need to contain (many instances of) a Check object, each of which would contain String objects for the payee and note.
Since a Check object can belong to only one
CheckingAccount object, we call this a composition
between the Check class and the CheckingAccount
class.
You should read this section in the book.
We will continue with our checking account.
An obvious omission is that we can't handle checks themselves. Before taking on that task, let's try something that should be simpler.
Each transaction should have a date. Many times the date of the transaction is today, but sometimes you might enter the transaction days after it was performed (remember this is our personal account history, not the bank's).
public class TestChecking {
public static void main (String[] Args) {
CheckingAcct acct = new CheckingAcct(
"Allan Gottlileb's checking account");
acct.makeDeposit(100.0, 7,15,2010);
acct.makeWithdrawal(30.0);
acct.makeDeposit(50.00);
}
}
Allan Gottlileb's checking account
Date Description Amount Balance
---------- ------------------------- ------- --------
7/15/2010 Deposit 100.00 100.00
10/13/2010 Withdrawal 30.00 70.00
10/13/2010 Deposit 50.00 120.00
public void makeDeposit (double amt, int month, int day,
int year) {...}
import java.util.Date;
private Date now = new Date();
private int nowMonth = now.getMonth();
private int nowDate = now.getDate();
private int nowYear = now.getYear()+1900;
Hence the public interface of CheckintAcct must be changed so that there are two makeDeposit() methods, one accepting a date and the other defaulting to today's date. Similarly, for makeWithdrawal().
On the right, the top frame is what we expect the client (user) of our class to write. Below that we see the output we wish to have.
What changes are needed to CheckingAcct.java?
abstract classand we don't yet know how to deal with those.
Here is my version.
import java.util.Date;
public class CheckingAcct {
private Date now = new Date();
private int nowMonth = now.getMonth();
private int nowDate = now.getDate();
private int nowYear = now.getYear()+1900;
private String acctName;
private double balance = 0;
CheckingAcct(String acctName) {
this.acctName = acctName;
printHeading();
}
public void makeDeposit (double amt) {
makeDeposit(amt, nowMonth, nowDate, nowYear);
}
public void makeDeposit (double amt, int month, int day, int year) {
balance += amt;
String dateString = String.format("%d/%d/%d", month, day, year);
System.out.printf("%10s Deposit %26.2f %9.2f\n", dateString, amt, balance);
}
public void makeWithdrawal (double amt) {
makeWithdrawal(amt, nowMonth, nowDate, nowYear);
}
public void makeWithdrawal (double amt, int month, int day, int year) {
balance -= amt;
String dateString = String.format("%d/%d/%d", month, day, year);
System.out.printf("%10s Withdrawal %23.2f %9.2f\n", dateString, amt, balance);
}
private void printHeading() {
System.out.printf("%40s\n\n", acctName);
System.out.printf("%10s %-25s %8s %9s\n",
"Date","Description", "Amount", "Balance");
System.out.printf("%s %s %s %s\n", "----------","-------------------------","-------","--------");
}
}
We already did stacks.
You should read this.
A class should describe a single entity. So having a class StacksAndQueues does not sound like a good idea.
But you might say that both stacks and queues are related; they both have insert and remove methods and perhaps boolean methods saying the structure is full, empty, or neither. We will learn about inheritance in the next chapter.
Follow the Java naming and style conventions (see this short section for a brief review).
Most fields should be private to ease maintenance and modifiability. Provide get and set methods as appropriate. In general only expose to the user what you guarantee will not change.
Read.
Read.
Declare data fields to be static if the value is constant for all objects in the class. Static fields should be set with a set method not via a constructor (why set the same variable to the same thing everything a new object is made).
Some methods do not need any object of the class; typically the main method has this property. Such methods must be declared static as there is no object they can be attached to.
Instance methods can reference both instance and class fields, as well as both instance and class methods.
Class methods can reference class methods and fields, but cannot invoke instance methods and fields (what object would the instance method or field refer to?).
Homework: 10.3
The idea of inheritance, which is fundamental in object-oriented programming, is that sometimes classes B and C are refinements of class A and it is silly to have to reproduce all the A methods for both B and C.
For example, you could have a class for quadrilaterals that would have as data fields the four vertices, the color to draw the figure in, and some complicated method for calculating the area.
Then you would have a subclass for a rhombus that would include, in addition, the (unique) side length. You would also have a subclass for rectangles that would override the area method with a much simpler one as well as providing additional data fields for height and width.
The terminology for the situation in the previous section is that quadrilateral is called a superclass, parent class, or base class. Both rectangle and rhombus would be called a subclass, a child class, an extended class, or a derived class.
Consider the example on the right.
public class GeometricalObject {
String color = "blue";
}
public class Point extends GeometricObject {
double x;
double y;
}
public class Quadrilateral extends GeometricObject {
private Point p1, p2, p3, p4;
// constructors
double area() {
// complicated general area formula
}
// more
}
public class Rhombus extends Quadrilateral {
private double sideLength;
// constructors (check side lengths equal)
// more
}
public class Rectangle extends Quadrilateral {
private double width, height;
// constructors
double area() {
return width * height;
// more
}
}
every quadrilateral is a point. The
is-arelationship is normally needed for a subclass to be appropriate. A quadrilateral is a geometric object.
every rhombus is a quadrilateral.
A terminology comment. A subclass usually contains more information (data fields) than the superclass. It is called a subclass because each object in the subclass is also a member of the superclass. Thus the set of objects in the subclass can be considered a subset of the set of objects in the superclass.
We mentioned above that there is a complicated formula
for
the area of a quadrilateral.
Just for fun, not part of the course, I worked it out.
Assume the 4 points p1, p2, p3, and p4 are given in the order so that the resulting quadrilateral is convex as shown in the diagram on the right. Draw one of the diagonals, say connecting p1 and p3.
It is easy to get the lengths of each side as the square root of delta-x squared + delta-y squared. So in the diagram we know all the sij.
Now the quadrilateral is composed of two triangles and we know the side lengths for each triangle. There is a cute formula for the area of any triangle with side lengths a, b, and c. Let s be the semiperimeter s=(a+b+c)/2, then the area of the triangle is the square root of s(s-a)(s-b)(s-c).
This analysis enables us to compute the complicated formula
for the quadrilateral area mention above.
Start Lecture #20
Recall that this refers to the current object. In an analogous way super refers to the superclass of the current class. It is used to
When we create a new object, a constructor is called. Let's say that class Child is a child of the class Parent and we make a new Child object child. The Child constructor is called and produces/initializes any relevant data fields in child.
But the Child object child contains, in addition to its own data, the data fields in Parent as well. How are these created/initialized?
The answer is that a constructor in the subclass invokes a constructor in the superclass. In our case, constructors in Child invoke constructors in Parent. How is this done. If, in the child constructor, we write new Parent(), we would create a new object rather than creating/initializing a part of the current object, namely child.
Indeed it is an error to mention the superclass constructor inside a subclass; instead super() is used.
public class Rhombus extends Quadrilateral {
private double sideLength;
public Rhombus (Point p1, Point p2,
Point p3, Point p4) {
super(p1, p2, p3, p4);
sideLength = p1.distTo(p2);
}
}
public class Quadrilateral extends GeometricObject {
Point p1, p2, p3, p4;
public Quadrilateral (Point p1, Point p2,
Point p3, Point P4) {
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
}
}
On the right we see a part of an improved class for Rhombus and below it part of the base class Quadrilateral. Although not explicitly included in the class, a derived class inherits the fields from its base. Thus a Rhombus object has 4 Point fields that must be created/initialized by the constructor.
Were there no inheritance involved, the rhombus constructor would have 4 assignment statements using this. However, the points are not declared in Rhombus so should not be referenced by this. Instead we invoke super() to have a constructor in the base class Quadrilateral do the necessary work.
The idea is that the constructors in a derived class deal with the fields introduced in the derived class; dealing with the fields inherited from the base class is left to the base class constructors, furthering abstraction/encapsulation.
When super() is used in a constructor, it must be the first statement.
You might wonder why these same considerations don't apply to Quadrilateral as they did to Rhombus. After all, Quadrilateral is itself a derived class.
The answer is that they do apply; a default super() has been supplied by Java, as will be explain in the next section.
As we have seen, a constructor can invoke another constructor in the same class and, if it is a derived class, can utilize super(). If a constructor in a derived class does neither of these actions, Java itself supplies a no-arg super() as the first statement of the constructor.
As a result of this automatic insertion of super() when needed, if A is derived from B, which in turn is derived from C, any A construct will, as its first action, invoke a B constructor, which, as its first action, will invoke an C constructor.
Thus the real actions will be performed in the order C, B, A, i.e., from base to derived. This naturally applies as well when there are more than 3 classes.
For example, consider the class tree on the right, which represents the parent-child relations in our geometry example.
The process of applying constructors from base to derived is called constructor chaining.
The keyword super can be used to reference superclass methods as well as superclass constructors. Normally the superclass method would be available in the subclass without any decoration. However, if the superclass and subclass both have a method with the same name, prepending super. references the method in the superclass whereas the naked name references the method in the subclass. We see an example in the next section
public class Parent {
int f() { return 1; }
int g() { return 10; }
}
public class Child extends Parent {
int f() { return 100; }
int h() { return f()+2*super.f()+g(); }
}
public class Test {
public static void main(String[] args) {
Parent p = new Parent;
Child c = new Child;
System.out.println(c.h());
System.out.println(c.f()+c.g());
}
}
112
110
Consider the example on the right. The parent class defines two methods f() and g(). The child class defines two methods f() and h().
In the parent class (for example, inside f()), nothing about the child class is known. So f() means the f() in the parent, the same for g(), and there is no h().
In the child class the situation is more interesting since everything in the parent (that is not private) is known in the child. So g() means the g() in the parent and h() means the h() in the child, but what about f()?
The rule is that a naked f() means the f() in the child. However, the f() in the parent can be obtained as super.f(). That is why the first line printed, c.h(), is 100+2*1+10.
What about usage in the class Test, a client of the child class. In the client, super cannot be used so c.f() in the example invokes the f() in the child. Since g() occurs only in the parent c.g() refers to that g(), which explains why the second line printed is 100+10.
The example above used instance methods in both the parent and child. If a method f() in the child overrides f() in the parent you must have either both static or neither static.
If they are both static then
Start Lecture #21
public class Base {
public void f(double x) {
System.out.printf("Base says x=%f\n", x);
}
}
public class Derived {
public void f(double x) {
System.out.printf("Derived says x=%f\n", x);
}
}
public class Test {
public static void main(String[] Args) {
Derived d = new Derived();
d.f(5.0);
d.f(5);
}
}
Derived says x=5.000000
Derived says x=5.000000
public class Derived extends Base {
public void f(int x) {
System.out.printf("Derived says x=%d\n", x);
}
}
Base says x=5.000000
Derived says x=5
It is important to understand the distinction between overriding, which we just learned, and overloading, which have seen previously.
The first frame on the right demonstrates overriding. Both the base class and the derived class define an instance method f() that have the same signature (i.e, the same number and types of parameters) and the same return type. In such a case, an object in the derived class sees only the method defined in the derived class.
In the example, both d.f(5.0) and d.f(5) invoke the f() in the child class. In the second case the 5 is coerced from int to double.
The second example is almost the same, but with a key difference. Both Base and Test are unchanged. The f() in Derived is changed so that it's parameter is of type int (and the printf() now uses %d not %i).
This tiny change has a large effect.
The f() in the derived class no longer has the same signature as the f() defined in the base. Thus, both are available (i.e., f() is overloaded).
For this reason the invocation f(5) invokes the f() in the derived class; whereas, the f(5.0) invokes the f() in the base.
Let's look at a larger example.
I have filled in some of the details for the geometric methods
sketched above.
public class GeometricObject {
protected String color = "blue";
}
public class Point extends GeometricObject {
Double x, y;
public Point(Double x, Double y) {
this.x = x;
this.y = y;
}
Double distTo (Point p) {
return Math.sqrt(Math.pow(this.x-p.x,2)+Math.pow(this.y-p.y,2));
}
}
public class Quadrilateral extends GeometricObject {
protected Point p1, p2, p3, p4;
public Quadrilateral (Point p1, Point p2, Point p3, Point P4) {
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
}
double area() {
return 123.4; // A stub, need to use complicated formula
}
}
public class Rhombus extends Quadrilateral {
private double sideLength;
public Rhombus (Point p1, Point p2, Point p3, Point p4) {
super(p1, p2, p3, p4);
sideLength = p1.distTo(p2);
if (sideLength!=p2.distTo(p3) || sideLength!=p3.distTo(p4) ||
sideLength!=p4.distTo(p1)) {
System.out.println("Error: Rhombus with unequal sides");
System.exit(0); // an exception would be better
}
}
public double getSideLength() {
return sideLength;
}
}
public class Rectangle extends Quadrilateral {
private double width, height;
public Rectangle(Point p1, Point p2, Point p3, Point p4) {
super(p1, p2, p3, p4);
width = p1.distTo(p2);
height = p2.distTo(p3);
// should check that all angles are right angles via slopes neg recip
// or check both widths equal, both heights equal, both diags equal
}
public Rectangle(Point p1, Point p3) { // Sides parallel to the axes
super(p1, new Point(p3.x,p1.y), p3, new Point(p1.x,p3.y));
width = Math.abs(p1.x-p3.x);
height = Math.abs(p1.y-p3.y);
// Nothing to check
}
public double getWidth() {
return width;
}
public double getHeight() {
return height;
}
public double area() {
return width * height;
}
public void areaCheck() {
System.out.printf("Rectangle says %f, but quad says %f\n",
this.area(), super.area());
}
}
public class TestQuad {
public static void main (String[] args) {
Point origin = new Point(0.0,0.0);
Point p1 = new Point(0.0,0.0);
Point p2 = new Point(1.0,0.0);
Point p3 = new Point(1.0,1.0);
Point p4 = new Point(0.0,1.0);
Point p5 = new Point(5.0,5.0);
Quadrilateral quad = new Quadrilateral (p1,p2,p3,p4);
Rectangle rect1 = new Rectangle (p1,p2,p3,p4);
Rectangle rect2 = new Rectangle (p1,p3);
Rectangle rect3 = new Rectangle (origin, new Point(1.0,4.0));
System.out.printf("rect1 has width=%f, height=%f, and color=%s\n",
rect1.getWidth(), rect1.getHeight(), rect1.color);
System.out.printf("rect2 has width=%f, height=%f, and color=%s\n",
rect2.getWidth(), rect2.getHeight(), rect2.color);
System.out.printf("rect3 has width=%f, height=%f, and color=%s\n",
rect3.getWidth(), rect3.getHeight(), rect3.color);
rect1.areaCheck();
Rhombus rhom1 = new Rhombus(p1,p2,p3,p4);
System.out.printf("rhom1 has side length=%f\n", rhom1.getSideLength());
Rhombus rhomBad = new Rhombus(p1,p2,p3,p5);
}
}
rect1 has width=1.000000, height=1.000000, and color=blue
rect2 has width=1.000000, height=1.000000, and color=blue
rect3 has width=1.000000, height=4.000000, and color=blue
Rectangle says 1.000000, but quad says 123.400000
rhom1 has side length=1.000000
Where in the class tree should we put a new class Circle?
Where in the class tree should we put a new class Square?
Where in the class tree should we put a new class Ellipse?
You would think from looking at a class definition beginning
public class TopLevel {
with no extends clause that this class has no parent.
That, however, is wrong.
Any class without an extends clause, whether defined in the Java library or by you and me, actually extends the built in class java.lang.Object.
Hence, any method defined in Object is available to all classes, unless it is overloaded or overridden.
One interesting instance method defined in Object is
toString(), which when applied to an object, produces
a string describing the object.
The actual description given is the class name, followed by @
followed by the memory address of the object.
The class name is certainly useful, the memory address at least
enables us to distinguish one object from another.
One advantage of having a toString() method defined for all objects is that other methods can count on its existence. For example the various print methods (e.g., printf(), println(), etc) use this to coerce objects to strings. Thus if obj is any object at all,
printf("The object is %s\n", obj);
is guaranteed to work.
I use toString() in the 2nd version of the geometry classes.
We have already seen encapsulation/abstraction and inheritance, which are major constituents of object oriented programming. We now turn our attention to polymorphism (and dynamic binding/dispatch), the third major constituent).
public static void printColor(GeometricObject geoObj) {
System.out.printf("The color of %s is %s\n",
geoObj.toString(), geoObj.getColor());
}
}
Say we are given the geometry classes and want to print the color. We don't want to add this print to the geometry classes since it is useful only for us and not all geometry users. We do modify GeometricObject to add a get method for the color and then write ourselves the simple method on the right. Now if we call the method with any GeometricObject all is well.
But we actually don't have variables of type GeometricObject, but instead have variables of various subtypes such as Rhombus or Point. Thus the natural call PrintColor(rhom1) would be a type error, we are passing a Rhombus as the argument and the method has a GeometricObject as its parameter.
But no it is not an error!
A variable of a supertype
(the type defined by a superclass)
can refer to an object of any of its subtypes
).
This concept of polymorphism can also be stated
in terms of objects as
an object of a subclass can be used anywhere that an object of its
superclass could be used
.
In section 11.B we see an enhanced version of the geometry example that includes printColor() and a few polymorphic calls.
How should we implement printArea() in our geometry classes?
It would be a one-line method in Rectangle.java, namely
void printArea() { System.out.printf("The area of %s is %f\n", this.toString(), this.area()); }
(Recall that the Rectangle class already has the method
area() and inherits toString() from Object).
But the exact same (character for character) one-line method printArea() would be perfect in the class Rhombus since Rhombus inherits area() from Quadrilateral and toString() from Object.
Once we put a trivial area() method in Point (it always returns 0), the exact same printArea() method would work there as well.
So is that the solution, cut-and-paste the identical method in all the classes? It would work, but it sure seems ugly.
Since GeometricObject is at the top of our geometry class hierarchy, why not put printArea() there? Since all the geometric classes extend GeometricObject, this has the effect of placing printArea in all of them.
Hence when, for example, we write rect1.printArea(), we will invoke the printArea() written in GeometricObject. Since the object in question is rect1, when printArea() issues this.area(), the area() in Rectangle will be called as desired.
Success!
The code is in section 11.B.
Let's say that we don't want to add printArea() to any of the geometry classes since it is somewhat special purpose. So we write the following one-line method in our main class
static void myPrintArea(GeometricObject geoObj) {
System.out.printf("My area of %s is %f\n", geoObj.toString(), geoObj.area());
}
and in the main() method we write
myPrintArea(rhom1).
At first glance this looks unlikely to compile since we have a type mismatch. The argument to myPrintArea() is a Rhombus, but the parameter is a GeometricObject. However, we know that polymorphism will save us, the parameter of type GeometricObject can legally point to an object of type Rhombus.
At second glance, it looks like it will work, but poorly. When compiling myPrintArea(), Java will see geoObj.area() where geoObj is of type GeometricObject and will thus always invoke the area() method in the class GeometricObject no matter what class the actual argument is in. This is bad, we have different formulas for the area of points, general quadrilaterals, and rectangles.
Failure!
Wrong!
It actually works great, we now have to understand how.
As we know well, Java requires that, prior to using a variable, we must declare it to be of a specific type (int, Object, Point, etc).
Previously, we have called the type in the declaration, simply the type of the variable. But now, in the presence of objects and polymorphism, we need to make a finer distinction and refer to the type in the declaration as the declared type of the variable.
When the declared type is a primitive such as int or char, there is very little more to say. The variable will always contain a value of its (declared) type. Recall that a double x=3; converts the 3 to floating point, which is then stored in x. The variable always contains a value of its (declared) type.
When the declared type is class, (e.g., String, or Rectangle), the situation is more interesting. First, we remember that a variable of declared type Rectangle never contains a rectangle. It often does contain a reference to a rectangle, but never contains the object itself (reference vs. value semantics).
Even more interesting a variable of declared type rectangle can, due to polymorphism, at times contain a reference to a GeometricObject, at other times a reference to a Quadrilateral, and even sometimes a reference to an Object.
The type of the object to which a variable refers is called its actual type.
Recall the situation.
We have a method myPrintArea() defined in the main class
that has one parameter geoObj, whose declared type
is GeometricObject.
We call this method in several places with arguments of various
geometric types.
myPrintArea() contains a call of geoObject.area().
We previously concluded that, since the type
of geoObject
is GeometricObject, the call would
always be to the area() method in GeometricObject.
We are wiser now and can question this conclusion. If myPrintArea() was called with an argument that referenced a Rectangle, then geoObj will indeed have declared type GeometricObject, but it will have actual type Rectangle. Thus the question becomes, does the method invocation geoObj.area() select the area() method to call based on the declared type of geoObj or on its actual type. Another wording is does geoObj.area() use static dispatch (declared type) or dynamic dispatch (actual type).
The answer in Java is that is uses dynamic dispatch, and hence our second try does indeed work. This situation is illustrated in the code constituting section 11.B.
In C++ static dispatch is used by default but
dynamic dispatch can be chosen by declaring the method to be
virtual
.
Start Lecture #22
int i1=1, i2=2, i3=3; double d1=1., d2=2., d3=3.E50; d1 = i1; // or d1 = (double)i1; // i2 = d2; Compile-time error i2 = (int)d2; // Fine i3 = (int)d3; // Gives wrong answer
Recall the situation for primitive types. Java performs safe type conversions (called coercions) automatically, but will not perform unsafe conversions, unless told by an explicit cast. Referring to the code on the right we see an illustration that
We now want to understand the corresponding actions for objects in the class hierarchy rather than for primitive types. In this situation the terminology is upcasting and downcasting.
The familiar diagram on the right motivates the names.
Upcasting refers to a conversion from a class lower in the diagram to a class higher in the diagram (really there is the class Object above GeometricObject).
Downcasting refers to a conversion from a class higher in the diagram to one lower in the diagram.
Parent p1 = new Parent(); Parent p2 = new Child(); // NOT Parent() Parent p3 = new Parent(); Child c1 = new Child(); Child c2 = new Child(); Child c3 = new Child(); p1 = c1; p1 = (Parent) c1; // c2 = p2; compile-time error c2 = (Child)p2; // c3 = (Child)p3; run-time error
The code on the right is the rough analogue for objects of the code above for primitive types. Note that the variable p2 after initialization has declared type Parent, but actual type Child. This situation is not present with primitive types since the variable contains the value and hence both are of the same type; whereas, variables of any object type contain a reference (to an object) and the object itself has a type.
Referring to the code we see
The general rules are (compare with primitive types above):
We have just seen that downcasting with an explicit cast will compile but might fail at run-time depending on the actual type of the variable at that time.
What should we do to avoid this run-time error?
Parent p; Child c; // much code involving p and c c = (Child) p;
if (p instanceof Child) c = (Child) p;
The code on the right gives one technique. The omitted code could be complicated and, depending on various values that are known only at run time, might result in the actual type of p being either parent or child.
We wish to do the downcast only if legal, i.e., only if the actual type of p is Child (or a descendant of Child). The instanceof operator is defined for exactly this purpose it returns true if the object on the left is in the class on the right (or a descendant of that class).
Why would I want to upcast and why would I ever want to try to downcast to something not matching the actual type of the variable.
Consider some sort of container class, i.e., a class each of whose instance is some container of GeometricObject's. For some examples consider
Each of these three examples illustrates a container for Object's. Let's say in some geometry program you have the array geoObjArr onto which you have placed various geometric objects, some points, some rhombuses, etc.
If you try something like geoObjArr[i].sideLength, you will get a compile-time error since geoObjArr[i] has declared type GeometricObject, which has no sideLength field.
A naked assignment to a variable of declared type Rhombus will not compile, so you need an explicit cast to do the downconvertion. But this will give a run-time error if the actual type of geoObjArr[i] is not a Rhombus (or a descendant).
Thus you need an if statement with instanceof as shown above.
public class GeometricObject {
protected String color = "blue";
public void printArea() {
System.out.printf("The area of %s is %f\n", this.toString(), this.area());
}
public String getColor() {
return color;
}
public double area() {
System.out.printf("Error area not overridden in %s\n", this.toString());
return 0;
}
}
public class Point extends GeometricObject {
public double x, y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double distTo (Point p) {
return Math.sqrt(Math.pow(this.x-p.x,2)+Math.pow(this.y-p.y,2));
}
public double area() {
return 0;
}
}
public class Quadrilateral extends GeometricObject {
protected Point p1, p2, p3, p4;
public Quadrilateral (Point p1, Point p2, Point p3, Point p4) {
// should check these points for a convex quadrillateral in this order
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
}
public double area() { // diagonal gives 2 triangles; use semiperimeter formula
double diag = p1.distTo(p3);
double s12 = p1.distTo(p2);
double s23 = p2.distTo(p3);
double s34 = p3.distTo(p4);
double s41 = p4.distTo(p1);
double semi1 = (s12 + s23 + diag) / 2;
double semi2 = (diag + s34 + s41) / 2;
return (Math.sqrt(semi1 * (semi1-s12) * (semi1-s23) * (semi1-diag)) +
Math.sqrt(semi2 * (semi2-s34) * (semi2-s41) * (semi2-diag)));
}
}
public class Rhombus extends Quadrilateral {
private double sideLength;
public Rhombus (Point p1, Point p2, Point p3, Point p4) {
super(p1, p2, p3, p4);
sideLength = p1.distTo(p2);
if (sideLength!=p2.distTo(p3) || sideLength!=p3.distTo(p4) ||
sideLength!=p4.distTo(p1)) {
System.out.println("Error: Rhombus with unequal sides");
System.exit(0); // an exception would be better
}
}
public double getSideLength() {
return sideLength;
}
}
public class Rectangle extends Quadrilateral {
private double width, height;
public Rectangle(Point p1, Point p2, Point p3, Point p4) {
super(p1, p2, p3, p4);
width = p1.distTo(p2);
height = p2.distTo(p3);
// should check that all angles are right angles via slopes neg recip
// or check both widths equal, both heights equal, both diags equal
}
public Rectangle(Point p1, Point p3) { // Sides parallel to the axes
super(p1, new Point(p3.x,p1.y), p3, new Point(p1.x,p3.y));
width = Math.abs(p1.x-p3.x);
height = Math.abs(p1.y-p3.y);
// Nothing to check
}
public double getWidth() {
return width;
}
public double getHeight() {
return height;
}
public double area() {
return width * height;
}
}
public class TestQuad {
public static void main (String[] args) {
Point origin = new Point(0.0,0.0);
Point p1 = new Point(1.0,0.0);
Point p2 = new Point(1.0,1.0);
Point p3 = new Point(0.0,1.0);
Point p4 = new Point(5.0,5.0);
Quadrilateral quad1 = new Quadrilateral(origin, p3, new Point(5.,0.), new Point(5.,-8.));
Rectangle rect1 = new Rectangle (origin,p1,p2,p3);
Rectangle rect2 = new Rectangle (origin, new Point(1.0,4.0));
Rhombus rhom1 = new Rhombus(origin,p1,p2,p3);
p1.printArea();
printColor(rhom1); // Polymorphic call (section 11.7)
printColor(rect1); // Polymorphic call
quad1.printArea(); // Inherited method (section first try)
rect2.printArea(); // Inherited method
myPrintArea(rhom1); // Dynamic binding/dispatch (section second try)
myPrintArea(p4); // Dynamic binding/dispatch
quad1 = rect1; // implicit casting (section 11.9)
quad1.printArea(); // dynamic binding/dispatch
}
public static void printColor(GeometricObject geoObj) {
System.out.printf("The color of %s is %s\n", geoObj.toString(), geoObj.getColor());
}
public static void myPrintArea(GeometricObject geoObj) {
System.out.printf("My area of %s is %f\n", geoObj.toString(), geoObj.area());
}
}
The area of Point@4830c221 is 0.000000
The color of Rhombus@2ce83912 is blue
The color of Rectangle@41fae3c6 is blue
The area of Quadrilateral@3e7ffe01 is 22.500000
The area of Rectangle@44fd13b5 is 4.000000
My area of Rhombus@2ce83912 is 1.000000
My area of Point@4318f375 is 0.000000
The area of Rectangle@41fae3c6 is 1.000000
On the board let's develop a Circle class with data fields center and radius.
normalconstructor is given the center point and the radius.
Homework: 11.1. UML diagram not required. The area formula they references is the same one I used in the Quadrilateral class. The filled data field is in the book's GeometricObject but not in ours. You may ignore it.
Homework: Use cut and paste to extract our geometry classes from the notes. Add your triangle class from the homework above to these files and incorporate your tests of triangle into our TestQuad (which should be named TestGeom).
Start Lecture #23
Remark: Lab 4 Assigned.
public boolean equals (Object obj) {
return (this == obj);
}
String s1="xy", s2="xy";
if (s1.equals(s2))
System.out.println("yes");
public boolean equals(Object obj) {
if (obj instanceof Circle)
return radius == ((Circle)obj).radius;
return false;
}
In addition to toString(), which we learned earlier, the Object class has an instance method equals(), shown on the right.
Note carefully that obj1.equals(obj2), checks if
the variables are ==, which means that both variable refer to the
same object.
Often you want equals() to return true if the
two objects have the same contents.
For example the String class overrides equals() so
that the middle code on the right prints yes
.
If the bottom code is placed in the Circle class then, Circle c1,c2; with equal radii will result in ci.equals(c2) yielding true.
public boolean equals(Circle c) {
return radius==c.radius
The equals() code on the right, looks simpler that the one above and seems to do the same job: When two circles are compared, their radii are checked.
The difference is that the equals() in 11.10 overrides the equals() defined in Object since both have the same signature. In contrast the equals() on the right has a different signature and thus we have two overloaded implementation of equals().
In the overloaded case, the choice of which equals() to invoke depends on the declared type of the argument. In the overriding case the choice depends on the actual type of the argument.
Thus, if we have an object array Object[]obj and if a circle is placed on this array, then
It is straightforward to create an array of Object's; just do it. The fancy ArrayList permits all sorts of extra operations. If you look on http:java.sun.com, you will find that there are even more goodies than the book suggests, as well as some nifty performance guarantees.
Another example of the justly-deserved fame accorded the Java libraries.
Shows how to use the ArrayList class to design a stack class that holds arbitrary objects.
Since we will not be studying packages (and they are primarily useful for large projects and libraries, which we are not writing), for us the rules are simple.
For a class itself, the only legal modifiers are public and the default (no modifier)
For members of a class (i.e., for fields and method)
We have seen the final keyword use for constants.
It has other analogous uses as well.
We have seen several places where errors can occur that can be detected only at run time. For example, a PrintWriter might be trying to write a file for which the user doesn't have sufficient privileges. Another example, this one from our geometry methods occurs when the Rhombus constructor detects that the given points do not yield a quadrilateral with all sides equal.
In Java, situations like this are often handled with exceptions, which we now study.
double s12 = p1.distTo(p2);
if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1)) {
System.out.println("Error: Rhombus with unequal sides");
System.exit(0); // an exception would be better
}
sidelength = s12;
double s12 = p1.distTo(p2);
try {
if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1))
throw new Exception("Rhombus with unequal side");
sidelength = s12;
}
catch (Exception ex) {
System.out.println("Error: Rhombus with unequal sides");
System.exit(0);
}
The top frame on the right shows (a slight variant of) the body of the Rhombus constructor.
The frame below it shows one way to accomplish the same task using an exception. There are four Java terms introduced try, throw, catch, and Exception.
try and catch each introduce a block of code, which are related as follows.
matching(explained later) catch block is executed.
In the example code, if all the side lengths are equal, sidelength is set. If they are not all equal an exception in the class Exception is thrown, sidelength is not set, an error message is printed and the program exits.
This behavior nicely mimics that of the original, but is much more complicated. Why would anyone use it?
The answer to the above question is that using exceptions in the manner of the previous section to more-or-less exactly mirror the actions without an exception is not a good idea.
Remember the problem with the original solution. The author of the geometry package does not know what the author of the client wants to do when an error occurs (try to forget that I am the author of both). Without any such knowledge the package author terminated the run as there was no better way to let the client know that a problem occurred.
public Rhombus (Point p, double sideLength, double theta) { super (p, new Point(p.x+sideLength*Math.cos(theta), p.y+sideLength*Math.sin(theta)), new Point(p.x+sideLength*(Math.cos(theta)+1.), p.y+sideLength*Math.sin(theta)), new Point(p.x+sideLength, p.y)); this.sideLength = sideLength; }
double s12 = p1.distTo(p2); if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1)) throw new Exception ("Rhombus with unequal sides."); sideLength = s12;
try { rhom1 = new Rhombus(origin,origin,p2,p3); } catch (Exception ex) { System.out.printf("rhom1 error: %s Use unit square.\n", ex.getMessage()); rhom1 = new Rhombus (origin, 1.0, Math.PI/2.0); }
The first improvement is to add another rhombus constructor. This one takes a point, a side-length, and an angle and produces the rhombus shown in the diagram on the top right. The constructor itself is in the 2nd frame.
Note that if Θ=Π/2, the rhombus is a square.
This improvement has little to do with exceptions and
could have been there all along.
You will see below how this standard rhombus
is used when the
client mistakenly attempts to construct an invalid rhombus.
The next step, shown in the 3rd frame, is to have the regular rhombus constructor throw an exception, but not catch it.
The client code is in the 4th frame. We see the try and catch. What happens is that the client calls the constructor, which raises (throws in Java-speak) the exception. Since the constructor does not catch this exception, Java automatically raises it in the caller, namely the client code, where it is finally caught.
It is this automatic call-back that exceptions provide that the original code does not.
This code includes my implementation of the Circle class.
public class GeometricObject {
protected String color = "blue";
public void printArea() {
System.out.printf("The area of %s is %f\n", this.toString(), this.area());
}
public String getColor() {
return color;
}
public double area() {
System.out.printf("Error: area not overridden in %s\n", this.toString());
return 0;
}
}
public class Point extends GeometricObject {
protected double x, y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double distTo (Point p) {
return Math.sqrt(Math.pow(this.x-p.x,2)+Math.pow(this.y-p.y,2));
}
public double area() {
return 0;
}
public double getX() {
return this.x;
}
public double getY() {
return this.y;
}
}
public class Quadrilateral extends GeometricObject {
protected Point p1, p2, p3, p4;
public Quadrilateral (Point p1, Point p2, Point p3, Point p4) {
// should check these points for a convex quadrillateral in this order
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
}
public double area() { // diagonal gives 2 triangles; use semiperimeter formula
double diag = p1.distTo(p3);
double s12 = p1.distTo(p2);
double s23 = p2.distTo(p3);
double s34 = p3.distTo(p4);
double s41 = p4.distTo(p1);
double semi1 = (s12 + s23 + diag) / 2;
double semi2 = (diag + s34 + s41) / 2;
return (Math.sqrt(semi1 * (semi1-s12) * (semi1-s23) * (semi1-diag)) +
Math.sqrt(semi2 * (semi2-s34) * (semi2-s41) * (semi2-diag)));
}
}
public class Rhombus extends Quadrilateral {
private double sideLength;
public Rhombus (Point p1, Point p2, Point p3, Point p4) throws Exception {
super(p1, p2, p3, p4);
double s12 = p1.distTo(p2);
if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1))
throw new Exception ("Rhombus with unequal sides.");
sideLength = s12;
}
public Rhombus (Point p, double sideLength, double theta) {
super (p,
new Point(p.x+sideLength*Math.cos(theta), p.y+sideLength*Math.sin(theta)),
new Point(p.x+sideLength*(Math.cos(theta)+1.), p.y+sideLength*Math.sin(theta)),
new Point(p.x+sideLength, p.y));
this.sideLength = sideLength;
}
public double getSideLength() {
return sideLength;
}
}
public class Rectangle extends Quadrilateral {
private double width, height;
public Rectangle(Point p1, Point p2, Point p3, Point p4) {
super(p1, p2, p3, p4);
width = p1.distTo(p2);
height = p2.distTo(p3);
// should check that all angles are right angles via slopes neg recip
// or check both widths equal, both heights equal, both diags equal
}
public Rectangle(Point p1, Point p3) { // Sides parallel to the axes
super(p1, new Point(p3.x,p1.y), p3, new Point(p1.x,p3.y));
width = Math.abs(p1.x-p3.x);
height = Math.abs(p1.y-p3.y);
// Nothing to check
}
public double getWidth() {
return width;
}
public double getHeight() {
return height;
}
public double area() {
return width * height;
}
}
public class Circle extends GeometricObject {
public Point center;
public double radius;
private static double maxRadius = -1;
private static Circle maxCircle = null;
public Circle(Point center, double radius) {
this.center = center;
this.radius = radius;
this.color = "pink";
if (radius > maxRadius) {
maxRadius = radius;
maxCircle = this;
}
}
public Circle(double radius) {
this(new Point(0.,0.), radius);
}
public Circle(Point center) {
this(center, 1.0);
}
public Circle() {
this(1.0);
}
public double area () {
return Math.PI * radius * radius;
}
public static Circle largestCircle() {
if (maxRadius < 0)
System.out.println("No circles created, so maximum circle is null");
return maxCircle;
}
public boolean equals(Object obj) {
if (obj instanceof Circle)
return radius == ((Circle)obj).radius;
return false;
}
}
public class TestQuad {
public static void main (String[] args) {
Point origin = new Point(0.0,0.0);
Point p1 = new Point(1.0,0.0);
Point p2 = new Point(1.0,1.0);
Point p3 = new Point(0.0,1.0);
Point p4 = new Point(5.0,5.0);
Quadrilateral quad1 = new Quadrilateral(origin, p3, new Point(5.,0.), new Point(5.,-8.));
Rectangle rect1 = new Rectangle (origin,p1,p2,p3);
Rectangle rect2 = new Rectangle (origin, new Point(1.0,4.0));
Rhombus rhom1;
try {
rhom1 = new Rhombus(origin,origin,p2,p3);
}
catch (Exception ex) {
System.out.printf("rhom1 error: %s Use unit square.\n", ex.getMessage());
rhom1 = new Rhombus (origin, 1.0, Math.PI/2.0);
}
p1.printArea();
printColor(rhom1); // Polymorphic call (section 11.7)
printColor(rect1); // Polymorphic call
quad1.printArea(); // Inherited method (section first try)
rect2.printArea(); // Inherited method
myPrintArea(rhom1); // Dynamic binding/dispatch (section second try)
myPrintArea(p4); // Dynamic binding/dispatch
quad1 = rect1; // implicit casting (section 11.9)
quad1.printArea(); // dynamic binding/dispatch
Circle c1 = new Circle();
Circle c2 = new Circle(2.);
Circle c3 = new Circle();
System.out.println(c3.equals(c1));
Circle c = Circle.largestCircle();
c.printArea();
System.out.println(c.getColor());
}
public static void printColor(GeometricObject geoObj) {
System.out.printf("The color of %s is %s\n", geoObj.toString(), geoObj.getColor());
}
public static void myPrintArea(GeometricObject geoObj) {
System.out.printf("My area of %s is %f\n", geoObj.toString(), geoObj.area());
}
}
rhom1 error: Rhombus with unequal sides. Use unit square.
The area of Point@40a0dcd9 is 0.000000
The color of Rhombus@2ce83912 is blue
The color of Rectangle@41fae3c6 is blue
The area of Quadrilateral@3e7ffe01 is 22.500000
The area of Rectangle@44fd13b5 is 4.000000
My area of Rhombus@2ce83912 is 1.000000
My area of Point@4318f375 is 0.000000
The area of Rectangle@41fae3c6 is 1.000000
true
The area of Circle@2e471e30 is 12.566371
pink
Our use of exceptions so far has just been to define one of our own. Specifically, we threw a new Exception. Every exception is an object and thus is a member of some class. So our exception was a member of the class Exception.
Many of the Java library methods can throw exceptions as well. For example, the Scanner constructor we use to create a Scanner object will throw an exception in the FileNotFoundException class if the argument to the Scanner constructor names a file that does not exist.
The diagram on the right shows the class tree for exceptions.
As always, Object is the root of the tree and naturally has many children in addition to Throwable, which is shown. As the name suggests, the Throwable class includes objects that can be thrown, which are exceptions.
From our simplified point of view, there are three important classes of exceptions, namely Error, Exception, and Runtime Exception. They are highlighted in the diagram.
Java divides exceptions into two groups: checked exceptions and unchecked exceptions. Exceptions in (a descendant of) Error or RuntimeException are unchecked. Exceptions in (a descendant of) Exception are checked.
The difference for us between checked and unchecked exceptions are that the header of any method that can throw a checked exception must declare this fact in its header line. For example consider the following constructor from the Rhombus class
public Rhombus (Point p1, Point p2, Point p3, Point p4) throws Exception {
super(p1, p2, p3, p4);
double s12 = p1.distTo(p2);
if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1))
throw new Exception ("Rhombus with unequal sides.");
sideLength = s12;
}
Please note two important points.
The purpose of this declaration is to alert users (clients) of the method that the exception may be raised while executing the client code since the throw is not caught internally and thus would propagate to the caller.
public class Test {
public static void main(String[]Args) throws Exception {
throw new Exception;
throw new BufferOverflowException;
}
}
public class MyException extends Exception {}
public class Test {
static MyException myE = new MyException();
public static void main(String[]args) throws MyException {
throw myE;
}
}
Throwing an exception is easy; just throw it. But first you need to create an object in some subclass of throwable (i.e., a member of Error, Exception, or a descendant of one of these).
The first frame shows two examples of throwing predefined exceptions. Since BufferOverflowException is a subclass of RuntimeException (a red box), it does not appears in the throws clause.
The second frame shows an example of creating a custom exception class and throwing an instance of this class. If MyException extended a red box rather than the blue one, the throws in the method header would not be needed.
Catching an exception is a two step procedure involving try and catch blocks.
If an exception occurs in a statement not within a try block, the exception is not caught by this method. Instead, the current method ends and the same exception is raised in the statement that called the method. If the current method is the main method, the program is terminated.
The above paragraph is for red-box
(i.e., unchecked) exceptions.
Java will not compile a method in which a blue-box (checked)
exceptions might occur not within a try block.
try {
statements;
}
catch (Exception1 ex1) {
handler for exception1;
}
catch (Exception2 ex2) {
handler for exception2;
}
...
catch (ExceptionN exN) {
handler for exceptionN;
}
statements after the catches
Thus, to catch an exception you must first delimit a sequence of statements withing a try block, as shown on the right.
If no exception occurs within the try block, the corresponding catch blocks are ignored.
If an exception does occur within the try block, the corresponding catch blocks are searched to see if one catches this class of exception. If such a block is found, its handler is executed followed by the statements after the catches.
If no catch block matches, the exception is NOT caught and once again, the current method is ended and the exception is re-raised in the statement that called the method.
The order of the catch blocks is significant as they are checked for matching in the order they are written.
Note that if a catch block is declared to handle exceptions in a class C, it actually catches exceptions in any descendant class of C as we.
As a result, if a later catch block handles a subclass of a prior cache block, the later catch block can never be executed. Indeed, it is compile-time error to list cache blocks in this nonsensical order
Draw on the board a deeper example with f() calling g() calling h(), handlers in various places, and h() raising various exceptions.
So far, inside catch (Exception ex) we have not used the object ex at all. Moreover sometimes in a throw we have included a string, which again we have not used.
The key to using the exception object and the string included with the throw is to employ one of the methods supplied by the class throwable. Two useful instance methods are getMessage(), which is used in our geometry program and printStackTrace().
Our geometry program uses getMessage(), which returns the string argument passed to the throw clause. As its name suggests printStackTrace prints a trace of the call stack (main called joe, joe called sam, sam threw an exception).
You should read the book's example. Here is the relevant portion of geometry example.
public class Rhombus extends Quadrilateral {
private double sideLength;
public Rhombus (Point p1, Point p2, Point p3, Point p4) throws Exception {
super(p1, p2, p3, p4);
double s12 = p1.distTo(p2);
if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1))
throw new Exception ("Rhombus with unequal sides.");
sideLength = s12;
}
public Rhombus (Point p, double sideLength, double theta) {
super (p,
new Point(p.x+sideLength*Math.cos(theta), p.y+sideLength*Math.sin(theta)),
new Point(p.x+sideLength*(Math.cos(theta)+1.), p.y+sideLength*Math.sin(theta)),
new Point(p.x+sideLength, p.y));
this.sideLength = sideLength;
}
public double getSideLength() {
return sideLength;
}
}
public class TestQuad {
public static void main (String[] args) {
Point origin = new Point(0.0,0.0);
Point p1 = new Point(1.0,0.0);
Point p2 = new Point(1.0,1.0);
Point p3 = new Point(0.0,1.0);
Point p4 = new Point(5.0,5.0);
Rhombus rhom1;
try {
rhom1 = new Rhombus(origin,origin,p2,p3);
}
catch (Exception ex) {
System.out.printf("rhom1 error: %s Use unit square.\n", ex.getMessage());
rhom1 = new Rhombus (origin, 1.0, Math.PI/2.0);
}
}
}
rhom1 error: Rhombus with unequal sides. Use unit square.
The constructor call inside the try is clearly not a rhombus since one side has length zero and the other three are not zero. Hence the constructor throws (but does not catch) a new Exception.
The main method executes the constructor inside a try block so, if the exception is thrown, the catch block is checked ans sure enough the only catch there matches. Hence ex becomes the new Exception.
The handler first prints the message included in the throw (via ex.getMessage() and then announces that it will use a unit square instead. The unit square is obtained by invoking the other rhombus constructor that takes the side length and angle. This handler cannot raise an exception.
Start Lecture #24
Homework: 13.1.
Homework: Do 13.3 two ways.
Out of Bounds.
Remark: Lab 4 is accessible directly off the home page.
try {
try block
}
catch (something){
catch block
}
finally {
finally block
}
the rest
In addition to throw and catch blocks there is occasionally a finally block that gets executed in any case. Consider the example on the right (there can be many catch blocks).
As mentioned above, it is silly to use an exception as a complicated if statement. It is the automatic up-call from the called method back to the caller that exceptions provide and simple code does not.
try {
statements;
}
catch (SomeException ex) {
statements
throw ex
}
A catch block can re-throw the exception it has just caught so that the exception is also handled in the caller.
Typical syntax is shown on the right.
Another possibility is that a catch block for one exception can throw a different exception.
Most of the exceptions raised either have no argument or have a string as an argument. The exception in the Rhombus class has a string argument.
public class MyException extends Exception {
MyException(int code, String str) {
super(String.format("Exception raised: (code=%d) %s\n"),
code, str);
}
}
However, you can define your own subclass of the Exception class (say MyException) and have a MyException constructor take whatever arguments you want. The example on the right takes an integer code in addition to the usual string.
import java.io.*; // FileReader/Writer IO/FileNotFoundException
public class CopyFile {
public static void main(String[]Args) throws IOException {
FileReader getInput = null;
FileWriter putOutput = null;
try {
getInput = new FileReader(Args[0]);
}
catch (FileNotFoundException fileNotFoundEx) {
System.out.printf("Can not read %s\n", Args[0]);
System.exit(0);
}
try {
putOutput = new FileWriter(Args[1]);
}
catch (IOException IOEx) {
System.out.printf("Can not write %s\n", Args[1]);
System.exit(0);
}
// If an IOException occurs here, we can't help
int c;
while (getInput.ready()) { // false at EOF
c = getInput.read();
putOutput.write(c);
}
putOutput.flush();
}
}
The program on the right copies one file to another. Each file is specified as a command line argument. That is to run the program one would type.
java CopyFile inputFileName outputFileName
The program uses exceptions to detect improper input. Several points are worth noting.
We shall soon see that it is sometimes useful to define methods
without bodies
(called abstract methods) just to act as
placeholders
for real methods that will override this
abstract method.
public class GeometricObject {
protected String color = "blue";
public void printArea() {
System.out.printf("The area of %s is %f\n", this.toString(),
this.area());
}
public String getColor() {
return color;
}
public double area() {
System.out.printf("Error: area not overridden in %s\n",
this.toString());
return 0;
}
}
Consider the area() methods sprinkled throughout our geometry example. In particular, look at the area() method defined in the GeometricObject class, shown to the right.
The method certainly does not compute the area and the important point is that there is no way it can compute the area of a GeometricObject itself since the only field guaranteed to exist is the color.
The reason for including area() here was twofold.
The problem with the area() method in the GeometricObject class is that it only reminds us to override area() in each class derived from GeometricObject. We want more than a reminder, we want a guarantee.
Another advantage of abstract methods is that they permit us to have interfaces, which we will very briefly touch on soon.
public abstract class GeometricObject {
protected String color = "blue";
public void printArea() {
System.out.printf("The area of %s is %f\n", this.toString(),
this.area());
}
public String getColor() {
return color;
}
public abstract double area(); // must be overridden
}
On the right we see a reimplementation of GeometricObject as an abstract class. with area() an abstract method. Note that this method has no body and cannot be called.
The compiler insures that this abstract method is overridden in the subclasses of GeometricObject.
Since this class contains an abstract method, the class must itself be declared abstract, as we have done on the first line.
You can declare a variable of type GeometricObject, but you cannot construct an object of the class. Thus a variable of declared type GeometricObject can never have actual type GeometricObject. That is, the value of the variable must be an object of a subclass of GeometricObject. Specifically a GeometricObject variable can contain a reference to a Rectangle, a Point, a Circle, etc. In all these cases the abstract area() method in GeometricObject is overridden and becomes a real (i.e., non-abstract) method.
Start Lecture #25
If all methods in a class are abstract and all data fields are constants (static final in Java), the class is called an interface.
Imagine that you want to write a class MyClass that extends two base classes ClassA and ClassB. That is, a MyClass object has all the data fields of both ClassA and ClassB (plus any others you add to MyClass). Also MyClass starts with all the methods of the two base classes (minus any that are overridden in MyClass, plus any new methods added in MyClass).
public class MyClass extends ClassA, ClassB {
statements;
}
You would try to write the class as shown on the right.
This is called multiple inheritance
since MyClass
inherits from multiple base classes.
However, Java does not support multiple inheritance
(although some languages, notably C++, does support it).
One question with multiple inheritance is what to do if two base classes include methods with the same signature but different bodies.
public class MyClass implements InterfaceA,
InterfaceB {
statements;
}
Java does support a somewhat similar notation. If ClassA and ClassB are very simple, specifically if they each consist of just constants and abstract methods, then they are called interfaces, say InterfaceA and InterfaceB, and MyClass can be defined as shown on the right. Since all methods in an interface are abstract and hence body-free, the question mentioned just above for multiple inheritance cannot arise.
// Interface for comparing objects.
// Defined in java.lang
package java.lang;
public interface Comparable {
public abstract int compareTo(Object o);
}
This entire interface is shown on the right. We have not studied packages so ignore the package statement.
Many classes in the java library implement this interface, which means that they supply an integer valued compareTo() instance method having one parameter, an Object.
For all these classes: if the instance object is less than
the argument object, the value returned is negative; if the two are
equal, the value returned is 0; and if the instance object is
greater than
the argument object, the value return is
positive.
public class Student implements Comparable {
public int stuId;
public String name;
public Student(int stuId, String name) {
this.stuId = stuId;
this.name = name;
}
public int compareTo(Object obj) {
Student stu = (Student) obj;
return name.compareTo(stu.name);
}
}
import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;
public class TestStudent {
public static void main(String[]args)
throws FileNotFoundException {
Scanner getInput = new Scanner(new File("stu.db"));
int n = getInput.nextInt();
Student[] student = new Student[n];
for (int i=0; i<n; i++) {
int stuId = getInput.nextInt();
String name = getInput.next();
student[i] = new Student(stuId, name);
}
sort(n, student);
System.out.printf("Sorted by name\n");
for (int i=0; i<n; i++) {
System.out.printf("%s\t%3d\n", student[i].name,
student[i].stuId);
}
}
public static void sort(int n, Student[] student) {
for (int i=0; <n-1; i++)
for (int j=i+1; j<n; j++)
if (student[i].compareTo(student[j]) > 0) {
Student tmpStudent = student[i];
student[i] = student[j];
student[j] = tmpStudent;
}
}
}
10 Sorted by name
1 Robert Alice 3
2 John Alice 9
3 Alice Harry 10
4 Jessica Jessica 4
5 Sam John 2
6 Sarah Judy 8
7 Mary Mary 7
8 Judy Robert 1
9 Alice Sam 5
10 Harry Sarah 6
The example on the right illustrates a class extending Comparable as well as reviewing a number of concepts we have learned previously.
As an added benefit, it previews sorting arrays of objects, which we will study very soon.
The top frame shows a very simple Student class that extends the Comparable interface. The class contains
Note that, although compareTo() will generate a runtime error unless its argument can be cast to student, the parameter itself is of type Object. Indeed, in order to implement Comparable, the defined compareTo() must override the compareTo() in Comparable and thus must have an Object parameter.
The second frame shows a test program using the Student class. The first loop reads in student IDs and names from a database file stu.db (shown in the third frame) and calls the Student() constructor to create the entries in the student array.
After the student records are read into the student array, the sort routine is invoked.
Finally the records are printed, to verify that they are now in sorted order.
You should compare the sort() method, which appears right after the main() method in the second frame, to the alphabetizing routing (sorting strings) that we did in section 9.2.13.
To conserve vertical space, the third frame contains two items. On the left is the stu.db file. It begins with a count of the number of students followed by the records themselves, one per line.
On the right is the output of the TestStudent program.
As expected, the records are now sorted by the name field.
Since the name Alice
appeared in two input records, it also
appears twice in the output.
Since the sort used is stable
, the relative order of the two
Alice
records is preserved.
As mentioned previously, Java does not support multiple inheritance, but a class can implement multiple interfaces. This is not as hard since interfaces are extremely simple classes.
For performance reasons, the Java primitive types (int, char, etc) are not objects. Reference semantics requires an extra level of indirection.
However, the full power of object orientation, does require objects
so, for each primitive type, there is a corresponding, so called,
wrapper class
with a very similar name.
We have already seen Character, the wrapper class for
char.
Also present are Byte, Short, Integer,
Long, Boolean, Float,
and Double.
Double d = new Double(4.3);
Character c = new Character('c');
To create a Double object, we naturally use a Double() constructor. The argument is a double (lower case, i.e., a primitive type). Examples for Double() and Character() are shown on the right. The Float(), Long(), etc. constructors are just the same.
public static void sort(int n, Student[] student) {
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (student[i].compareTo(student[j]) > 0) {
Student tmpStudent = student[i];
student[i] = student[j];
student[j] = tmpStudent;
}
}
public static void sort(int n, Comparable[] obj) {
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (obj[i].compareTo(obj[j]) > 0) {
Comparable tmpObj = obj[i];
obj[i] = obj[j];
obj[j] = tmpObj;
}
}
Recall the sort routine in Section 14.A. which has been reproduced on the right.
There is something curious about this routine: It sorts items in the Student class, but uses nothing abut the Student class except for the compareTo method, which is present in any class implementing Comparable.
This raises the question of what would need to be changed for this sort to work for any class implementing Comparable.
The answer is that essentially nothing has to be changed. Specifically, the two occurrences of Student, need be changed to Comparable. Although not necessary, the code on the right changes other names as well. In particular, the variable name student would be misleading so has been changed to obj.
When this new version is dropped into TestStudent, the
results are the same (ignoring the unchecked
warning, see
below).
The input is sorted alphabetically on the name field.
import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;
public class TestStudent {
public static void main(String[]args)
throws FileNotFoundException {
Scanner getInput = new Scanner(new File("stu.db"));
int n = getInput.nextInt();
Student[] student = new Student[n];
for (int i=0; i<n; i++) {
int stuId = getInput.nextInt();
String name = getInput.next();
student[i] = new Student(stuId, name);
}
Float[] f={new Float(3.),new Float (0.),new Float (-5.)};
Long[] l={new Long(333),new Long (0), new Long (-555)};
// Sort and print
sort(3, student);
sort(3, f);
sort(3, l);
System.out.printf("Sorted by name\n");
for (int i=0; i<3; i++) {
System.out.printf("%s\t%3d %6.1f %5d\n",
student[i].name, student[i].stuId, f[i], l[i]);
}
}
public static void sort(int n, Comparable[] obj) {
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (obj[i].compareTo(obj[j]) > 0) {
Comparable tmpObj = obj[i];
obj[i] = obj[j];
obj[j] = tmpObj;
}
}
}
The great news is that the identical sorting routine can be used to sort objects of any class that implements Comparable.
On the right is an expanded version of TestStudent. Note the following points.
The above program, if run on a modern Java system, will give a somewhat cryptic warning and then work fine. If the same program is run on an older (version 1.4) Java, and the printf() methods replaced by println(), there would not be any warnings and again it would work.
This difficulty has to do with the addition of
Java generics
in version 1.5, and the resulting addition
of Comparable<T>
The previous section illustrated both an advantage and slight
annoyance with the wrapper classes
Double,
Character, etc. when compared to the corresponding
primitive data types.
The advantage is that, since the wrappers are classes, they can make use of many object oriented features. The minor annoyance is the relative wordiness of
Short s[] = {new short[5], new short[7]};
when compared to
short s[] = {5, 7};
In most cases the annoyance can be avoided because Java will automatically convert between the primitive type and the corresponding wrapper class. Conversion to the wrapper class is called boxing and the reverse conversion is called unboxing.
As an illustration here is yet one more version of the TestStudent class, this time using the autoboxing and also sorting many more types. For completeness we repeat the Student class and the student database.
public class Student implements Comparable {
public int stuId;
public String name;
public Student(int stuId, String name) {
this.stuId = stuId;
this.name = name;
}
public int compareTo(Object obj) {
Student stu = (Student) obj;
return name.compareTo(stu.name);
}
}
import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;
public class TestStudent {
public static void main(String[]args) throws FileNotFoundException {
Scanner getInput = new Scanner(new File("stu.db"));
int n = getInput.nextInt();
Student[] student = new Student[n];
for (int i=0; i<n; i++) {
int stuId = getInput.nextInt();
String name = getInput.next();
student[i] = new Student(stuId, name);
}
Float[] f = {3.F, 0.F, -5.F, 2.5F, -8.F, 8.2F, 7.8F, 0.F, -5.F, -8.F};
Double[] d = {3., 0., -5., 2.5, -8., 8.2, 7.8, 0., -5., -8.};
Byte[] b = {33, 0, -55, 2, -8, 8, 7, 0, -5, -8};
Short[] s = {333, 0, -555, 2, -8, 8, 7, 0, -5, -8};
Integer[] g = {333, 0, -555, 2, -8, 8, 7, 0, -5, -8};
Long[] l = {333L, 0L, -555L, 2L, -8L, 8L, 7L, 0L, -5L, -8L};
Character[] c = {'q', '8', 'A', 'a', 'Z', 'q', 'z', 'Q', '8', '8'};
String[] t = {"q", "8", "A", "a", "Z", "q", "z", "Q", "88", "78"};
// Sort and print
sort(10, student);
sort(10, f);
sort(10, d);
sort(10, b);
sort(10, s);
sort(10, g);
sort(10, l);
sort(10, c);
sort(10, t);
System.out.printf("Sorted by name\n");
for (int i=0; i<10; i++) {
System.out.printf("%s\t%3d %6.1f %6.1f %5d %5d %5d %5d %5c %5s\n",
student[i].name, student[i].stuId, f[i], d[i], b[i], g[i], s[i], l[i], c[i], t[i]);
}
}
public static void sort(int n, Comparable[] obj) {
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (obj[i].compareTo(obj[j]) > 0) {
Comparable tmpObj = obj[i];
obj[i] = obj[j];
obj[j] = tmpObj;
}
}
}
Sorted by name Alice 3 -8.0 -8.0 -55 -555 -555 -555 8 78 Alice 9 -8.0 -8.0 -8 -8 -8 -8 8 8 Harry 10 -5.0 -5.0 -8 -8 -8 -8 8 88 Jessica 4 -5.0 -5.0 -5 -5 -5 -5 A A John 2 0.0 0.0 0 0 0 0 Q Q Judy 8 0.0 0.0 0 0 0 0 Z Z Mary 7 2.5 2.5 2 2 2 2 a a Robert 1 3.0 3.0 7 7 7 7 q q Sam 5 7.8 7.8 8 8 8 8 q q Sarah 6 8.2 8.2 33 333 333 333 z z
10 | 1 Robert | 2 John | 3 Alice | 4 Jessica | 5 Sam | 6 Sarah | 7 Mary | 8 Judy | 9 Alice | 10 Harry |
Homework: 14.5 (omit UML diagram).
A method is recursive if it directly or indirectly calls itself. So if the method f() invokes f(), we call f() recursive. Also if f() invokes g() and g() invokes f(), we call both f() and (g) recursive.
For an example consider two mathematical functions f() and g() defined on the integers by these three rules.
For example let's compute f(3)
f(3) = f(2) + g(2)
= f(1) + g(1) + f(2) + 1
= f(0) + g(0) + f(1) + 1 + f(1) + g(1) + 1
= 0 + f(0) + 1 + f(0) + g(0) + 1 + f(0) + g(0) + f(1) + 1 + 1
= 0 + 0 + 1 + 0 + f(0) + 1 + 1 + 0 + f(0) + 1 + f(0) + g(0) + 1 + 1
= 0 + 0 + 1 + 0 + 0 + 1 + 1 + 0 + 0 + 1 + 0 + g(0) + 1 + 1
= 0 + 0 + 1 + 0 + 0 + 1 + 1 + 0 + 0 + 1 + 0 + f(0) + 1 + 1 + 1
= 0 + 0 + 1 + 0 + 0 + 1 + 1 + 0 + 0 + 1 + 0 + 0 + 1 + 1 + 1
= 7
public class FG { 0 0
public static void main(String[]arg) { 1 1
for (int i=0; i<10; i++) 2 3
System.out.printf("%2d %4d\n", i, f(i)); 3 7
} 4 15
public static int f(int n) { 5 31
if (n <= 0) 6 63
return 0; 7 127
return f(n-1) + g(n-1); 8 255
} 9 511
public static int g(int n) {
return f(n) + 1;
}
}
The program is quite simple and is shown on the right together with the output produced.
What is surprising is that it works! After all when we invoke f(3), this sets n=3 and invokes f(2), which sets n=2. So now in the same method, namely f(), the same variable, namely n, has two different values at the same time, namely 3 and 2.
How can this be?
Naturally, the situation gets even worse when we consider the call of f(9), and worse still when we remember that f() calls g(), which in turn calls f(). There will be very many values for n in f() at the same time.
public class Factorial {
public static void main(String[]arg) {
System.out.printf(" n Recursive Iterative\n");
for (int i=-1; i<10; i++)
if (i<0)
System.out.printf("\t\t\t\t(%d)! is not defined!!\n", i);
else
System.out.printf("%2d %8d %8d\n", i, recFac(i), iterFac(i));
}
public static int recFac(int n) {
if (n <= 1)
return 1;
else
return n * recFac(n-1);
}
public static int iterFac(int n) {
int fact=1;
if (n>1)
for (int i=2; i<=n; i++)
fact = fact * i;
return fact;
}
}
n Recursive Iterative
(-1)! is not defined!!
0 1 1
1 1 1
2 2 2
3 6 6
4 24 24
5 120 120
6 720 720
7 5040 5040
8 40320 40320
9 362880 362880
Factorial is a very easy function to compute either with or without recursion. It is normally written using ! rather than the usual parenthesized notation. That is, instead of factorial(7), we usually write 7!
For a positive integer n, n! is defined to be
1 * 2 * 3 * ... * n
For example 5! = 1 * 2 * 3 * 4 * 5 = 120
If instead of defining n! to be multiplying from 1 up to n, we define n! (equivalently) to be multiplying from n down to 1, we see that the definition is the same as defining (recursively)
n! = n * (n-1)!
It is conventional to define 0! = 1.
Sometimes factorial is defined to be 1 for negative numbers as well, but I believe it is more common to consider factorial undefined for negative numbers.
The program on the right computes factorial twice, once with each definition. The factorial methods would return 1 if given a negative argument, but the main program declares this to be an error.
As in the previous section, perhaps the most interesting question is "How can the Java program possible work with n having so many different values at the same time?".
On the board show the stack growing and shrinking when computing recFact(4).
Start Lecture #25
Homework: 14.5 (omit UML diagram).
public class Fibon {
public static void main(String[]arg) {
System.out.printf(" n Recursive Iterative\n");
for (int i=-1; i<10; i++)
if (i<0)
System.out.printf("\t\t\t\tFibonacci is not defined for %d\n", i);
else
System.out.printf("%2d %8d %8d\n", i, recFibon(i), iterFibon(i));
}
public static int recFibon(int n) {
if (n <= 1)
return 1;
else
return recFibon(n-1) + recFibon(n-2);
}
public static int iterFibon(int n) {
int a=1, b=1, c=1;
if (n>1)
for (int i=2; i<=n; i++) {
c = a + b;
a = b;
b = c;
}
return c;
}
}
n Recursive Iterative
Fibonacci is not defined for -1
0 1 1
1 1 1
2 2 2
3 3 3
4 5 5
5 8 8
6 13 13
7 21 21
8 34 34
9 55 55
The Fibonacci sequence is normally defined recursively by the following two rules.
From the formulas above, we see that the sequence begins
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
The limiting ratio f(n)/f(n-1)
as n approaches infinity is called the
golden mean
and comes up in a number of biological settings.
The code for both recursive and iterative solutions is on the right.
Again the methods liberally define Fibonacci values for negative n, but the main() method flags it as an error.
Draw on the board the diagram showing all the recursive calls that
occur when you invoke recFib(4).
It is important when designing a recursive solution, that you avoid
infinite recursion where the method f()
always calls itself.
There must be a so called base case
that can be solved
directly.
For example, in the factorial problem, we specified that 0!=1.
Another requirement is that when you are not in the base case, the
recursive calls bring you closer
to the base case.
For example, in the factorial problem (excluding negative values),
if n>0, then we define n! = n*(n-1)!,
which means that when trying to compute factorial for n, we
need to compute factorial for n-1.
Since the base case is n=0, n-1 is closer to the
base case than is n.
Often the base case occurs for a small value of an integer parameter, (e.g., n for factorial or Fibonacci, the length for many string problems, array bounds for some array problems, etc). Then the recursive call has a smaller value of the parameter than the original and is thus closer to the base case.
Thus, many times the high-level structure of a recursive solution is
if (the parameters fit the base case)
return the solution directly
else
call the method recursively with a smaller parameter value
return the answer using the answer from the recursive call
Here is an (inefficient, overly complex) method of adding non-negative integers that uses the above pattern.
public static int sum(int x, int y) {
if (y == 0) then
return x
int z = sum(x,y-1);
return z+1;
}
Sometimes we have more than one base case. For example consider the isPalindrome() procedure on the right. Recall that a string is a palindrome if it reads the same from left to right as from right to left.
public static boolean isPalindrome(String s) {
if (s.length() <= 1) // base case 1
return true;
if (s.charAt(0) == x.charAt(s.length()-1)) // base case 2
return false;
return isPalindrome(s.substring(1,s.length()-1));
}
One base case is that an empty string or a string of length one is a palindrome.
Another base case is that if the first and last characters are not equal than it is not a palindrome.
If neither base case applies than the original string is a palindrome if and only if the substring omitting the first and last characters is a palindrome.
The above code is from the book. I might prefer to view the solution with only one base case as follows.
public static boolean isPalindrome(String s) {
if (s.length() <= 1) // base case
return true;
return (s.charAt(0)==x.charAt(s.length()-1)) &&
isPalindrome(s.substring(1,s.length()-1));
}
The base case is that empty and length 1 strings are palindromes.
If we are not in the base case, the original string is a palindrome if and only if (1) the first and last characters are the same and (2) the substring omitting these two characters is a palindrome. This interpretation gives rise to the code on the right.
Sometimes it is easier or more efficient to solve a more general problem. For example, an inefficiency in the above palindrome program is that at each recursive call it builds a new string when in fact all that we need to do is to restrict our attention to a contiguous portion of the original string.
public static boolean isPalindrome(String s, int lo, int hi) {
if (hi < lo)
return true; // base case
return (s.charAt(lo)==s.charAt(hi)) &&
isPalindrome(s, lo+1, hi-1);
}
So instead of asking if a string is a palindrome, we as the more general question is the portion of the string from position low to position high a palindrome and then recursively restrict the range low...high, while keeping the same string. This program is shown in the top frame on the right.
One objection to the program is that it is more awkward for the user who would typically invoke the program as isPalindrome(s,0,s.length()-1). In other words, the helper program may have helped the implementer (in this case to make their program more efficient), but is sure didn't help the user who much preferred writing isPalindrome(s).
public static boolean isPalindrome(String s) {
return isPalindrome(s, 0, s.length()-1));
}
To answer this objection, we write a second isPalindrome() method that meets the user's expectation and properly invokes the first isPalindrome() method. The code is shown on the right. Note that the method name isPalindrome() is overloaded: If invoked with just a string argument, the second version is called; if invoked, with a string and two integers, the first version is called.
On the right is an preliminary look at an important data structure in 102: a binary tree.
These trees have two kinds of nodes: interior nodes drawn as squares, and leaves drawn as circles. Each node has two children; each leaf has no child. A node also contains data, in this case a character.
This data structure is called a binary tree.
public class Tree {
char data;
Tree left;
Tree right;
Tree(char data, Tree left, Tree right) {
this.data = data;
this.left = left;
this.right = right;
}
Tree (char data) { // constructs a leaf
this(data, null, null);
}
}
The code on the right is a class for this data structure. Note that we use the name Tree when the object is in fact the single node of a tree.
We see that a Tree has three components, two Tree's and a char, which seems crazy! How can a Tree contain 2 Tree's?
The answer is an old friend, reference semantics. The variables left and right do not contain trees, but instead contain references to trees. Thus a Tree object contains two references to Tree's and a char.
Informally, you can think of a tree (i.e., a tree node) as it is shown in the diagram. That is, you can view a node as containing two arrows and a character.
public class Tree {
char data;
Tree left;
Tree right;
Tree(char data, Tree left, Tree right) {
this.data = data;
this.left = left;
this.right = right;
}
Tree (char data) { // constructs a leaf
this(data, null, null);
}
public void preOrderTraverse () {
System.out.printf("%c ", this.data);
if (this.left != null) { // leaf?
this.left.preOrderTraverse();
this.right.preOrderTraverse();
}
}
public void postOrderTraverse () {
if (this.left != null) { // leaf?
this.left.postOrderTraverse();
this.right.postOrderTraverse();
}
System.out.printf("%c ", this.data);
}
public void inOrderTraverse () {
if (this.left != null) { // leaf?
this.left.inOrderTraverse();
}
System.out.printf("%c ", this.data);
if (this.right != null) { // leaf?
this.right.inOrderTraverse();
}
}
public static void main(String[]arg) {
Tree t1 = new Tree('A');
Tree t2 = new Tree('l');
t1 = new Tree('C',t1,t2);
t2 = new Tree('l');
Tree t3 = new Tree('S',t1,t2);
t1 = new Tree('a');
t2 = new Tree('n');
t1 = new Tree('1',t1,t2);
t2 = new Tree('G');
t1 = new Tree('0',t1,t2);
t1 = new Tree('1',t3,t1);
System.out.println("Preorder Traversal");
t1.preOrderTraverse();
System.out.printf("\n\nPostorder Traversal\n");
t1.postOrderTraverse();
System.out.printf("\n\nInorder Traversal\n");
t1.inOrderTraverse();
}
}
Preorder Traversal
1 S C A l l 0 1 a n G
Postorder Traversal
A l C l S a n 1 G 0 1
Inorder Traversal
A C l S l 1 a 1 n 0 G
The program on the right constructs the tree in the diagram and then traverses the tree in three different orders.
First let's ignore the three traverse methods and concentrate on how the beginning of the main() method constructs the desired tree, which I have redrawn here for convenience.
To construct a leaf we use the second constructor and thus supply only the data item, which in this small example is simply a character. The left and right fields are set to null by the constructor. In main() I deliberately reused some Tree variables as I believe it is instructive.
To construct an interior node, we use the first construct and thus need to supply two child trees in addition to the data. This means we must construct the children before constructing the interior node. The tree is constructed from the bottom up.
On the board execute each line of main() showing the variable name, the reference, and the referred to Tree. As execution proceeds, you will see why we called the objects trees not nodes.
In a tree traversal all the tree nodes are visited. In the three traversals we study, each node is visited exactly once. In general, what to do during a visit is specified by the user. In our example, visiting a node consists simply of printing the character data item.
How do we ensure we visit each node (exactly once) and in what order should we visit them?
Three orderings are common: pre/post/in-order. In all three left children are visited before right children. The pre/post/in refers to when a node is visited in relation to its children.
On the board, without looking at the code, manually perform all three traversals.
Now that we understand trees and how to recursively walk through them, we can solve a number of problems. We will just look at a familiar structure, the file system tree.
In this tree the interior nodes are the (sub-)directories and the leaves are the simple files (in 202 you will learn that file system trees are more complicated than this and actually are not trees, but we ignore that complication).
import java.io.File;
import java.util.Scanner;
public class DirOrFileSize {
public static void main(String[] args) {
System.out.print("Enter a directory or a file: ");
Scanner input = new Scanner(System.in);
String directory = input.nextLine();
System.out.printf("There are %d bytes.\n",
getSize(new File(directory)));
}
public static long getSize(File file) {
long size = 0; // Size of this file or directory
if (! file.isDirectory()) // Base case, 1 file
size += file.length();
else { // All files and subdirectories
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++)
size += getSize(files[i]);
}
return size;
}
}
Note that a directory can have any number of files and sub-directories so not all interior nodes have exactly 2 children. Thus we do not have a binary tree and cannot use inorder traversal.
The program on the right reads in a file or directory name and prints the total size of all the files there. Specifically, if given a file it gives the size of the file; whereas, if given a directory, it prints the size of all the files under that directory (which includes files under subdirectories of the directory).
The base case is a simple file and then the size is obtained by calling the File.length() library routine.
When encountering a directory getSize() sums the sizes of all the files and subdirectories in the given directory. Note that this involves many recursive calls, one for each file and subdirectory.
Consider the file system tree just below, where boxes are directories and circles are ordinary files.
import java.io.File;
import java.util.Scanner;
public class ListFiles {
public static void main(String[] args) {
System.out.print("Enter a directory or a file: ");
Scanner getInput = new Scanner(System.in);
String dirOrFile = getInput.next();
listFiles(new File(dirOrFile), "");
}
public static void listFiles(File dirOrFile, String indent) {
System.out.println(indent + dirOrFile.getName());
if (! dirOrFile.isDirectory())
return; // base case -- simple file
File[] dirOrFiles = dirOrFile.listFiles();
for (int i = 0; i < dirOrFiles.length; i++)
listFiles(dirOrFiles[i], indent + " ");
return;
}
}
The program on the top right produces the output on the bottom right, when the program is run on this file system.
T
E
F
b
y
A
a
x
y
D
Note that the items within the a directory appear below it and are indented. All the work is done by listFiles(). Its first parameter is the file or directory to list and the second argument is the indentation to use.
The base case is when the first argument is a file, which is simply listed using the File.getName() library routine.
When given a directory, listFiles() finds all the files and subdirectories and then calls itself recursively on each one giving an indentation 2 greater than its own indentation.
We already discussed this a little.
Show demo on emacs.
The End: Good luck on the final