Java程序辅导

117-214
Principles of Software Construction: 
Objects, Design, and Concurrency
Introduction to Java
Josh Bloch                                               Charlie Garrod
217-214
Administrivia
• Homework 1 due next Thursday 11:59 p.m.
– Everyone must read and sign our collaboration policy
• First reading assignment due Tuesday
– Effective Java Items 15 and 16
317-214
Outline
I. "Hello World!" explained
II. The type system
III. Quick ‘n’ dirty I/O
IV. A brief introduction to collections
417-214
The “simplest” Java Program
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
517-214
Complication 1: you must use a class even if 
you aren’t doing OO programming
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
617-214
Complication 2: main must be public
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
717-214
Complication 3: main must be static
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
817-214
Complication 4: main must return void
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
917-214
Complication 5: main must declare command 
line arguments even if it doesn’t use them
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
1017-214
Complication 6: println uses the static
field System.out
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}
1117-214
Execution is a bit complicated, too
• First you compile the source file
– javac HelloWorld.java
– Produces class file HelloWorld.class
• Then you launch the program
– java HelloWorld
– Java Virtual Machine (JVM) executes main method
1217-214
On the bright side…
• Has many good points to balance shortcomings
• Some verbosity is not a bad thing
– Can reduce errors and increase readability
• Modern IDEs eliminate much of the pain
– Type psvm instead of public static void main
• Managed runtime (JVM) has many advantages
– Safe, flexible, enables garbage collection
• It may not  be best language for Hello World…
– But Java is very good for large-scale programming!
1317-214
Outline
I. “Hello World!” explained
II. The type system
III. Quick ‘n’ dirty I/O
IV. A brief introduction to collections
1417-214
Java has a bipartite (2-part) type system
Primitives Object Reference Types
int, long, byte, short, 
char, float, double, boolean
Classes, interfaces, arrays, 
enums, annotations
No identity except their value Have identity distinct from value
Immutable Some mutable, some immutable
On stack, exist only when in use On heap, garbage collected
Can’t achieve unity of 
expression
Unity of expression with generics
Dirt cheap More costly
1517-214
Programming with primitives
A lot like C!
public class TrailingZeros {
public static void main(String[] args) {
int i = Integer.parseInt(args[0]);
System.out.println(trailingZerosInFactorial(i));
}
static int trailingZerosInFactorial(int i) {
int result = 0; // Conventional name for return value
while (i >= 5) {
i /= 5; // Same as i = i / 5; Remainder discarded
result += i;
}
return result;
}
}
1617-214
Primitive type summary
• int 32-bit signed integer
• long 64-bit signed integer
• byte 8-bit signed integer
• short 16-bit signed integer
• char 16-bit unsigned integer/character
• float 32-bit IEEE 754 floating point number
• double 64-bit IEEE 754 floating point number
• boolean Boolean value: true or false
1717-214
“Deficient” primitive types
• byte, short – typically use int instead!
– byte is broken – should have been unsigned
• float – typically use double instead!
– Provides too little precision
– Few compelling use cases, e.g., large arrays in 
resource-constrained environments
1817-214
Pop Quiz!
1917-214
What does this fragment print?
int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int i;
int sum1 = 0;
for (i = 0; i < a.length; i++) {
sum1 += a[i];
}
int j;
int sum2 = 0;
for (j = 0; i < a.length; j++) {
sum2 += a[j];
}
System.out.println(sum1 - sum2);
2017-214
Maybe not what you expect!
int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int i;
int sum1 = 0;
for (i = 0; i < a.length; i++) {
sum1 += a[i];
}
int j;
int sum2 = 0;
for (j = 0; i < a.length; j++) { //  Copy/paste error!!!
sum2 += a[j];
}
System.out.println(sum1 - sum2);
You might expect it to print 0, but it prints 55
2117-214
You could fix it like this…
int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int i;
int sum1 = 0;
for (i = 0; i < a.length; i++) {
sum1 += a[i];
}
int j;
int sum2 = 0;
for (j = 0; j < a.length; j++) {
sum2 += a[j];
}
System.out.println(sum1 - sum2);  // Now prints 0, as expected
2217-214
But this fix is far better…
idiomatic Java for loop
int sum1 = 0;
for (int i = 0; i < a.length; i++) {
sum1 += a[i];
}
int sum2 = 0;
for (int i = 0; i < a.length; i++) {
sum2 += a[i];
}
System.out.println(sum1 - sum2); // Prints 0, as expected
• Reduces scope of index variable to the loop
• Shorter and less error prone
2317-214
This fix is better still!
for-each loop
int sum1 = 0;
for (int x : a) {
sum1 += x;
}
int sum2 = 0;
for (int x : a) {
sum2 += x;
}
System.out.println(sum1 - sum2); // Prints 0, as expected
• Eliminates scope of index variable entirely!
• Even shorter and less error prone
2417-214
Lessons from the quiz
• Minimize scope of local variables [EJ Item 57]
– Declare variables at point of use
• Initialize variables in declaration
• Prefer for-each loops to regular for-loops
• Use common idioms
• Watch out for bad smells in code
– Such as index variable declared outside loop
2517-214
Objects
• All non-primitives are represented by objects.
• An object is a bundle of state and behavior
• State – the data contained in the object
– In Java, these are called its instance fields
• Behavior – the actions supported by the object
– In Java, these are called its methods
– Method is just OO-speak for function
– “Invoke a method”  is OO-speak for “call a function”
2617-214
Classes
• Every object has a class
– A class defines methods and fields
– Methods and fields collectively known as members
• Class defines both type and implementation
– Type ≈ what object does (hence where it can be used)
– Implementation ≈ how the object does things 
• Loosely speaking, the methods of a class are its 
Application Programming Interface (API)
– Defines how users interact with its instances
2717-214
The Java class hierarchy
• The root is Object (all non-primitives are objects)
• All classes except Object have one parent class
– Specified with an extends clause
class Guitar extends Instrument { ... }
– If extends clause omitted, defaults to Object
• A class is an instance of all its superclasses
Object
ToyInstrument
YoyoGuitar
2817-214
Implementation inheritance
• A class:
– Inherits visible fields and methods from its superclasses
– Can override methods to change their behavior
• Overriding method implementation must obey the 
contract(s) of its superclass(es)
– Ensures subclass can be used anywhere superclass can
– Liskov Substitution Principle (LSP)
– We will talk more about this in a later class
2917-214
Interface types
• Defines a type without an implementation
• Much more flexible than class types
– An interface can extend one or more others
– A class can implement multiple interfaces
Instrument
Stringed
Instrument
Electric
Instrument
Acoustic
Guitar
Electric
Guitar
Synthesizer
3017-214
Enum types
• Java has object-oriented enums
• In simple form, they look just like C enums:
enum Planet { MERCURY, VENUS, EARTH, MARS,
JUPITER, SATURN, URANUS, NEPTUNE }
• But they have many advantages!
– Compile-time type safety
– Multiple enum types can share value names
– Can add or reorder without breaking existing uses
– High-quality Object methods are provided
– Screaming fast collections (EnumSet, EnumMap)
– Can iterate over all constants of an enum
3117-214
Boxed primitives
• Immutable containers for primitive types
• Boolean, Integer, Short, Long, Character, 
Float, Double
• Let you “use” primitives in contexts requiring objects
• Canonical use case is collections
• Don’t use boxed primitives unless you have to!
• Language does autoboxing and auto-unboxing
– Blurs but does not eliminate distinction
– There be dragons!
3217-214
Comparing values
x == y compares x and y “directly”:
primitive values: returns true if x and y have the same value
objects refs: returns true if x and y refer to same object
x.equals(y) compares the values of the objects 
referred to by x and y*
* Asuming it makes sense to do so for the objects in question
3317-214
True or false?
int i = 5;
int j = 5;
System.out.println(i == j);
---------------------------
3417-214
True or false?
int i = 5;
int j = 5;
System.out.println(i == j);
---------------------------
true
5j
i 5
3517-214
True or false?
int i = 5;
int j = 5;
System.out.println(i == j);
---------------------------
true
String s = "foo";
String t = s;
System.out.println(s == t);
---------------------------
5j
i 5
3617-214
True or false?
int i = 5;
int j = 5;
System.out.println(i == j);
---------------------------
true
String s = "foo";
String t = s;
System.out.println(s == t);
---------------------------
true
5j
i 5
"foo"
t
s
3717-214
True or false?
int i = 5;
int j = 5;
System.out.println(i == j);
---------------------------
true
String s = "foo";
String t = s;
System.out.println(s == t);
---------------------------
true
String u = "iPhone";
String v = u.toLowerCase();
String w = "iphone";
System.out.println(v == w);
---------------------------
5j
i 5
"foo"
t
s
3817-214
True or false?
int i = 5;
int j = 5;
System.out.println(i == j);
---------------------------
true
String s = "foo";
String t = s;
System.out.println(s == t);
---------------------------
true
String u = "iPhone";
String v = u.toLowerCase();
String w = "iphone";
System.out.println(v == w);
---------------------------
Undefined! (false in practice)
5j
"foo"
t v
u
w
"iPhone"si 5
"iphone"
"iphone"
?
3917-214
The moral
• Always use .equals to compare object refs!
– (Except for enums, which are special)
– The == operator can fail  silently and unpredictably 
when applied to object references
– Same goes for !=
4017-214
Outline
I. “Hello World!” explained
II. The Java type system
III. Quick ‘n’ dirty I/O
IV. A brief introduction to collections
4117-214
Output
• Unformatted
System.out.println("Hello World");
System.out.println("Radius: " + r);
System.out.println(r * Math.cos(theta));
System.out.println();
System.out.print("*");
• Formatted – very similar to C
System.out.printf("%d * %d = %d%n", a, b, a * b); // Varargs
4217-214
Command line input example
Echos all its command line arguments
class Echo {
public static void main(String[] args) {
for (String arg : args) {
System.out.print(arg + " ");
}
}
}
$ java Echo Woke up this morning, had them weary blues
Woke up this morning, had them weary blues
4317-214
Command line input with parsing
Prints the GCD of its two command line arguments
class Gcd {
public static void main(String[] args) {
int i = Integer.parseInt(args[0]);
int j = Integer.parseInt(args[1]);
System.out.println(gcd(i, j));
}
static int gcd(int i, int j) {
return i == 0 ? j : gcd(j % i, i);
}
}
$ java Gcd 11322 35298
666
4417-214
Scanner input
Counts the words on standard input
class Wc {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long result = 0;
while (sc.hasNext()) {
sc.next(); // Swallow token
result++;
}
System.out.println(result);
}
}
$ java Wc < Wc.java
32
4517-214
Outline
I. “Hello World!” explained
II. The type system
III. Quick ‘n’ dirty I/O
IV. A brief introduction to collections
4617-214
Primary collection interfaces
Collection
QueueSet List
Deque
Map
4717-214
“Primary” collection implementations
Interface Implementation
Set HashSet
List ArrayList
Queue ArrayDeque
Deque ArrayDeque
(stack) ArrayDeque
Map HashMap
4817-214
Other noteworthy collection implementations
Interface Implementation(s)
Set LinkedHashSet
TreeSet
EnumSet
Queue PriorityQueue
Map LinkedHashMap
TreeMap
EnumMap
4917-214
Collections usage example 1
Squeezes duplicate words out of command line
public class Squeeze {
public static void main(String[] args) {
Set s = new LinkedHashSet<>();
for (String word : args)
s.add(word);
System.out.println(s);
}
}
$ java Squeeze I came I saw I conquered
[I, came, saw, conquered]
5017-214
Collections usage example 2
Prints unique words in alphabetical order
public class Lexicon {
public static void main(String[] args) {
Set s = new TreeSet<>();
for (String word : args)
s.add(word);
System.out.println(s);
}
}
$ java Lexicon I came I saw I conquered
[I, came, conquered, saw]
5117-214
Collections usage example 3
Prints the index of the first occurrence of each word
class Index {
public static void main(String[] args) {
Map index = new TreeMap<>();
// Iterate backwards so first occurrence wins
for (int i = args.length - 1; i >= 0; i--) {
index.put(args[i], i);
}
System.out.println(index);
}
}
$ java Index if it is to be it is up to me to do it
{be=4, do=11, if=0, is=2, it=1, me=9, to=3, up=7}
5217-214
More information on collections
• For much more information on collections,
see the annotated outline:
https://docs.oracle.com/javase/11/docs/technotes
/guides/collections/reference.html
• For more info on any library class, see javadoc
– Search web for  11
– e.g., java.util.scanner 11
5317-214
What about arrays?
• Arrays aren’t a part of the collections framework
• But there is an adapter: Arrays.asList
• Arrays and collections don’t mix well
• If you try to mix them and get compiler 
warnings, take them seriously
• Generally speaking, prefer collections to arrays
– But arrays of primitives (e.g., int[]) are preferable 
to lists of boxed primitives (e.g., List)
• See Effective Java Item 28 for details
5417-214
To learn Java quickly
5517-214
Summary
• Java is well suited to large programs; small ones 
may seem a bit verbose
• Bipartite type system – primitives & object refs
• Single implementation inheritance
• Multiple interface inheritance
• A few simple I/O techniques will go a long way
• Collections framework is powerful & easy to use