Contents

  1. ./BigramFixed.java
  2. ./Bigram.java
  3. ./Dice.java
  4. ./Fruit.java
  5. ./OverloadPlay.java
  6. ./OverridePlay.java
  7. ./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.