Version 3.3¹

Handouts: none

(First Day)

In Chapter 2, we began by studying basic features of the Java language and ended by studying some of the Java libraries, such as applet and graphics libraries, which are not part of the language as such.

In Chapter 3, we are still looking at libraries, but mostly libraries which are considered part of the Java language itself because they belong to the package java.lang which is always accessible (without an import statement).

In particular, the String and Math classes are in this core java.lang package. Enumerated types and wrapper classes (sec. 3.7– 3.8) are also language features. The chapter ends, again, by looking at more peripheral classes in the graphics packages.

There are a lot of library classes in Java. Exams will emphasize the core language features and classes (java.lang), and a little of java.util. Don't try to memorize details of things that are outside of the core.

Installing DrJava

• DrJava

(3.1) Creating Objects

The new operator creates an object, initializes it by calling its constructor, and returns a reference to the object.

References are pointers and we may represent them as arrows.

• Actually, they are memory addresses.
• We call the non-primitive types in Java "reference types" because they are pointers to objects. The variable does not directly store the object, but a pointer to it.
• null is a special reference-type value that does not refer to an object.

Dot operator (.) accesses methods of an object.

The length method.

What happens if the variable is null?

Aliases: more than one variable referencing the same object. Assigning the value of one reference variable to another: only the pointer is copied, not the object it points at. This creates an alias. If we now mutate the object pointed at by one of the variables, we are also mutating the object pointed at by the other, since they are the same object. (The example on p. 117 is bad because Strings are not mutable.)

Solutions:

• Ban aliasing?
• Ban mutation?
• Just live with it and beware?

Garbage collection

(3.2) String methods

Some important methods of the String class: see Figure 3.1 p. 119.

Some important methods (p. 119)

Examples—evaluate:

String s = "Mississippi";
s.charAt(0)
s.charAt(2)
s.compareTo("Alabama")
"cat".concat("dog")
"cat".equals("dog")
"cat".equalsIgnoreCase("Cat")
s.length()
s.replace('s', 't')
s.replace('s', 't').replace('p', 'q').replace('i', 'j').replace('M', 'N')
s // unchanged
s.substring(0, 4)
s.substring(4, 8)
s.toLowerCase()
s.toUpperCase()

Discussion: compare with string operations in Python.

Listing 3.1 StringMutation (but it does not really mutate the string!)

• Modify this program to print phrase again, to show that it really is unchanged.

(3.3) Packages

A class library consists of a group of related classes.

• Usually these are grouped into (named) packages.
• Fig. 3.2 p. 123 lists some important standard Java packages.
• Reasons for packages:
  • Better organization.
  • Avoid name conflicts.

There is also an unnamed package. When you're writing your program, and you don't make a package declaration, by default you're writing for the unnamed package.

The import statement allows us to omit the package name subsequently when we refer to a class, or to any of the classes, in a package. Because java.lang is so fundamental, it does not need to be imported.

An Application Programming Interface (API) also is a collection of related classes, which may belong to one or more packages. E.g., the Java graphics API includes at least the packages java.awt and javax.swing.

When using a library or an API, we usually need to have a reference manual or at least some notes handy. There is just too much to keep in the brain!

→→Visit the Sun Java API documentation web site and navigate.

(3.4) Random and its methods

Random = java.util.Random. Fig. 3.4 lists some of its methods.

• Note overloading of nextInt

Examples:

import java.util.Random;
Random r = new Random();
r.nextFloat()
r.nextInt()
r.nextInt(100)  // overloaded

Listing 3.2: RandomNumber

(3.5) Math and its methods

Math = java.lang.Math

The Math class provides essentially mathematical functions, defined as static methods (class methods). "Static" means we don't need an instance. To use the static methods, we just write class name, dot, method name, e.g., Math.sqrt(16.2).

Fig. 3.5 lists some important Math methods.

Examples:

Math.abs(-7)
Math.floor(7.9)
Math.floor(-7.9)
Math.ceil(7.1)
Math.ceil(-7.1)
Math.pow(2, 8)
Math.exp(8)  // e to the 8th power
Math.sqrt(2.0)
Math.cos(0);

Listing 3.3: Quadratic

Review: to solve quadratic equations, ax² + bx + c = 0, we use the quadratic formula:

x = [−b ± sqrt(b² − 4 ac)] / (2 a)

which has two solutions.

(3.6) Formatting Output

The class java.text.NumberFormat

• We do not use new to create instances of this class; request an instance using one of the class's static methods. Then use the instance's format method.

Examples:

import java.text.NumberFormat;
NumberFormat nf;
nf = NumberFormat.getCurrencyInstance();
nf.format(12345.6789)
nf = NumberFormat.getPercentInstance();
nf.format(12345.6789)
nf = NumberFormat.getNumberInstance();
  // or getInstance()
nf.format(12345.6789)

Why using static methods? It's an abstract class, so new isn't going to work. The getInstance method will try to return an object that is appropriate for our locale, i.e., language and other local characteristics. To run gedit in French, for example, try

$ env LANG=fr_FR gedit

Also:

$ export LANG=fr_FR
$ gedit

The first way sets the shell variable LANG for the duration of a single command. The second way sets it for all subsequent commands (unless you change it again later).

Similarly fr_CA for Canadian French, es_ES for Spanish, en_UK for British English. (Some programs respond better to this than others.)

To see all available locale codes:

$ locale -a

Fig 3.6 lists some of its methods but omits:

static NumberFormat getInstance()
static NumberFormat getNumberInstance()

both of which return a general-purpose format object (i.e., not for percentages or currency, just plain numbers; see Java API documentation for java.lang.NumberFormat). (These two methods, getInstance and getNumberInstance, are equivalent.)

Listing 3.4 Purchase

The class java.text.DecimalFormat

• non-abstract class; use new
• Fig. 3.7 lists some of its methods.

• Usage:

  1. Use new to create an instance, passing the constructor a pattern string such as "0.###"
  2. Use the instance's format method applied to a (double) number.

Example:

import java.text.DecimalFormat;
DecimalFormat df = new DecimalFormat("0.###");
df.format(123.4)
df.format(123.456789)

Listing 3.5 CircleStats

• For details of the pattern language, see the online API documentation (cf. below).

The printf method (System.out.printf)

• Provided to make easier migration to Java from "legacy" programs (i.e., C language programs, but it's also sort of like Python formatting).
• Will not use in this course.

Example:

System.out.printf("%s says %d + %3.1f = %4.8f\n",
                  "John", 1, 2.51111, 3.51111);

Discussion (if time)

(Second Day)

(3.7) Enumerated Types

• New Java language feature in 1.5 ("Java 5")

• Example:

  enum Size {Small, Medium, Large};
  

• Usage:

  [public] enum TYPENAME {VALUE1, ..., VALUEN};
  

• Is actually a special kind of class definition.
• May be declared "in the open" (and public) or local to (nested within) another class.
• Type-safe: you cannot store out of range values in a variable declared as an enum type.

• Internally, each symbolic value is associated with an integer 0, 1, 2, ..., its ordinal value

Methods include:

• name () → String
• ordinal () → int
• toString () → String

Examples:

> enum Size {Small, Medium, Large};
> Small.name()
Static Error: Undefined name 'Small'
> Size.Small.name()
"Small"
> Size.Small.ordinal()
0
> Size.Small.toString()
"Small"

The Enum class documentation says toString is normally preferred to name, and "most programmers will have no use for" the ordinal method.

• Listing 3.6 IceCream
  • Note that the enum is declared within the IceCream class, so it's a class within a class—called an inner class.
  • Modify: change name to toString; note that toString is automatically called (where?); delete uses of ordinal.

(3.8) Wrapper Classes

Recall that Java types are divided into primitive and reference types, and the primitive types include boolean and various kinds of numbers. This is efficient, but sometimes annoying, because some contexts require an object (a reference type of value) and cannot use a primitive type value; for example, an array (a "list") of objects cannot store an int (directly).

Wrapper classes bridge the gap: each one stores a primitive type value and encloses it in an object. Like putting a letter into an envelope—there is some machinery (at the Post Office?) that handles only envelopes.

There is one wrapper class for each primitive type (Fig. 3.8). Mostly, wrapper classes have the same names as the primitive types, except they are capitalized (e.g., Boolean is the wrapper class for the primitive type boolean). Two exceptions:

• Integer wraps int
• Character wraps char

It is not clear what the Void class is for. The Java API documentation states that "The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the Java keyword void." Since the keyword void does not signify a primitive type, but rather the absence of a return value, why would anyone want or need a Void class?

Example:

Integer w = new Integer(67);
int i = w.intValue(); // 67

Wrapper Utilities

In addition, the wrapper classes provide a number of useful methods ("utilities"). Some of these convert between strings and other types, for example, for the int type:

> Integer.parseInt("35")
35
> Integer.toString(35)
"35"

Students in Information Representation (I308) may be interested in converting to and from bases other than 10:

> Integer.parseInt("111", 2)
7
> Integer.parseInt("777", 8)
511
> Integer.parseInt("ffff", 16)
65535
> Integer.toBinaryString(-35)
"11111111111111111111111111011101"
> Integer.toOctalString(-35)
"37777777735"
> Integer.toHexString(-35)
"ffffffdd"
> Integer.toString(35, 2)
"100011"
> Integer.toString(35, 8)
"43"
> Integer.toString(35, 16)
"23"
> Integer.toString(35, 12)
"2b"

(Note in 7th edition page 142: tohexString should be toHexString)

Autoboxing and Unboxing

Java 1.5 ("Java 5") introduced autoboxing and (auto-) unboxing, making the compiler do the boring part, so we can write just

Integer w = 67;
int i = w;

and it does the same thing.

Another role of the wrapper classes is to provide conversion between the primitive types and their String representations. Examples:

w.toString(); // "26"
int i = Integer.parseInt("26"); // 26
Integer.toString(37) // "37"

(3.9) Graphics: Components and Containers

While the Turtle graphics system that we used in Python last semester has little use, outside of educating beginner programmers, the Java graphics that we are about to learn are "real world" graphics; it and other similar APIs are widely used by experienced programmers for developing "real world" applications.

Components [also called widgets, outside of Java] are elements of a GUI such as buttons and labels.

Containers are components that may contain other components.

Two container classes: JFrame, JPanel.

JFrame is a "heavyweight" component with multiple panes. Its content pane contains all of its visible components.

Another component class: JLabel. Represents a label which can contain text and/or an image.

A container's layout manager controls the arrangement of its components, and may rearrange them when the window is resized.

An important advantage of layout managers is that the programmer does not have to specify numerical coordinates for most components. Specifying such coordinates would make the program very inflexible: the coordinates assume a fixed-size window.

Listing 3.7 Authority

(3.10) Nested Panels

We may use panels within a panel for better control of grouping.

Listing 3.8 NestedPanels

(3.11) Images

Images can be drawn by the Graphics method drawImage. They can also be used, with or without text, in a JLabel.

Usage (javax.swing.ImageIcon):

ImageIcon icon = new ImageIcon("IMAGEFILE"); // gif, jpeg, png

new JLabel(TEXT, ICON, POSITION)

where

• TEXT is a String,
• ICON is an ImageIcon (or more generally an Icon—an ImageIcon is an Icon loaded from a file, URL, or byte array), and
• POSITION describes the label's position in its container; possible values include SwingConstants.LEFT|CENTER|BOTTOM.

All the arguments are optional, but a POSITION argument can be given only if there is at least one of the other arguments. See API documentation, which shows 6 variants of the construction.

To control the position of text vis-a-vis image in the label, use

label.setHorizontalTextPosition(POSITION);

where POSITION allows the same values as above.

Listing 3.9 LabelDemo

Discussion

Programming Projects for discussion in class (time permitting)—Use incremental development, starting with comments:

• # 3.3 Random telephone number
• # 3.9 Frame with two name labels
  • A solution: TwoLabels.java (restricted access; see Oncourse Forums for login)
• # 3.10 Four images in two panels.
  • A solution: FloatingPictures.java (restricted access; see Oncourse Forums for login; provide your own image files)

Lab assignment: …