Contents
- ./BigramFixed.java
- ./Bigram.java
- ./Dice.java
- ./Fruit.java
- ./OverloadPlay.java
- ./OverridePlay.java
- ./PlanetTest.java
./BigramFixed.java 1/7
[top][prev][next]
package examples;
import java.util.Set;
import java.util.HashSet;
/**
* From <em>Effective Java</em> "Can you spot the bug?"
*
* Fixed example of Bigram.java
*
* @author Joshua Bloch
*/
public class BigramFixed {
private final char first;
private final char second;
public BigramFixed(char first, char second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o) {
if (! (o instanceof BigramFixed))
return false;
BigramFixed b = (BigramFixed) o;
return b.first == first && b.second == second;
}
public int hashCode() {
return 31 * first + second;
}
public static void main(String[] args) {
Set<BigramFixed> s = new HashSet<BigramFixed>();
for (int i = 0; i < 10; i++)
for (char ch = 'a'; ch <= 'z'; ch++)
s.add(new BigramFixed(ch, ch));
System.out.println(s.size());
}
}
./Bigram.java 2/7
[top][prev][next]
package examples;
import java.util.Set;
import java.util.HashSet;
/**
* From <em>Effective Java</em>
* "Can you spot the bug?"
* @author Joshua Bloch
*/
public class Bigram {
private final char first;
private final char second;
public Bigram(char first, char second) {
this.first = first;
this.second = second;
}
public boolean equals(Bigram b) {
return b.first == first && b.second == second;
}
public int hashCode() {
return 31 * first + second;
}
public static void main(String[] args) {
Set<Bigram> s = new HashSet<Bigram>();
for (int i = 0; i < 10; i++)
for (char ch = 'a'; ch <= 'z'; ch++)
s.add(new Bigram(ch, ch));
System.out.println(s.size());
}
}
./Dice.java 3/7
[top][prev][next]
package examples;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/**
* Example of a common programmer bug when using an iterator.
*
*/
public class Dice {
enum Face {
ONE, TWO, THREE, FOUR, FIVE, SIX
};
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("Goal: Show all combinations from rolling two dice");
// This loop doesn't produce the expected results
Collection<Face> faces = Arrays.asList(Face.values());
System.out.println("Unexpected results: ");
for (Iterator<Face> i = faces.iterator(); i.hasNext();) {
for (Iterator<Face> j = faces.iterator(); j.hasNext();) {
System.out.println(i.next() + " " + j.next());
}
}
System.out.println("Expected results: ");
// This loop does.
for (Face one : Face.values()) {
for (Face two : Face.values()) {
System.out.println(one + " " + two);
}
}
}
}
./Fruit.java 4/7
[top][prev][next]
package examples;
/**
* Example of using Enums.
*
* @author sprenkle
*
*/
public class Fruit {
public enum Apple {
FUJI, EMPIRE, GRANNY_SMITH
};
public enum Orange {
NAVEL, TEMPLE, BLOOD
};
/**
* @param args
*/
public static void main(String[] args) {
for (Apple a : Apple.values()) {
System.out.println(a);
}
}
}
./OverloadPlay.java 5/7
[top][prev][next]
package examples;
/**
* What is the output from the main method of OverloadPlay ?
*
* @author sprenkle
*
*/
class Parent {
public void method() {
System.out.println("Parent");
}
}
class Child extends Parent {
@Override
public void method() {
System.out.println("Child");
}
}
public class OverloadPlay {
public static void print(Parent parent) {
System.out.println("Static Parent");
}
public static void print(Child child) {
System.out.println("Static Child");
}
public void instancePrint(Parent parent) {
System.out.println("Parent");
}
public void instancePrint(Child child) {
System.out.println("Child");
}
public static void main(String[] args) {
Child child = new Child();
Parent p = child;
print(p);
new OverloadPlay().instancePrint(p);
}
}
./OverridePlay.java 6/7
[top][prev][next]
package examples;
/**
* Another example of dynamic dispatch. Note that Parent and Child are defined
* in OverloadPlay
*
* @author sprenkle
*
*/
public class OverridePlay {
public static void main(String[] args) {
Child child = new Child();
Parent p = child;
p.method();
}
}
./PlanetTest.java 7/7
[top][prev][next]
package examples;
/**
* Example demonstrates a more sophisticated enumerated type.
*
*/
public class PlanetTest {
public enum Planet {
MERCURY(3.302e+23, 2.439e6), VENUS(4.869e+24, 6.0518e6), EARTH(
5.976e+24, 6.37814e6), MARS(6.421e+23, 3.3972e6), JUPITER(
1.9e+27, 7.1492e7), SATURN(5.688e+26, 6.0268e7), URANUS(
8.686e+25, 2.5559e7), NEPTUNE(1.024e+26, 2.4746e7);
private final double mass;
private final double radius;
private final double surfaceGravity;
private static final double G = 6.67300E-11;
// Note: Package-private; Can't be more visible than package-private
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
surfaceGravity = G * mass / (radius * radius);
}
public double mass() {
return mass;
}
public double radius() {
return radius;
}
public double surfaceGravity() {
return surfaceGravity;
}
public double surfaceWeight(double mass) {
return mass * surfaceGravity; // F = ma
}
}
/**
* @param args
*/
public static void main(String[] args) {
double earthWeight = 150;
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values())
System.out.printf("Your weight on %s is %10.4f%n", p,
p.surfaceWeight(mass));
}
}
Generated by GNU enscript 1.6.4.