package cc.openhome;
public class Calculator {
    public int plus(int op1, int op2) {
        return op1 + op2;
    }
}

package test.cc.openhome;
import cc.openhome.Calculator;
public class CalculatorTest {
    public static void testPlus() {
        Calculator calculator = new Calculator();
        int expected = 3;
        int result = calculator.plus(1, 2);
        if(expected == result) {
            System.out.println("成功！");
        }
        else {
            System.out.printf(
               "失敗，預期為 %d，但是傳回 %d！%n", expected, result);
        }
    }
}

package test.cc.openhome;

public class TestRunner {
    public static void main(String[] args) {
        CalculatorTest.testPlus();
    }
}

package cc.openhome;
public class Calculator {
    public int plus(int op1, int op2) {
        return op1 + op2;
    }
    
    public int minus(int op1, int op2) {
        return op1 - op2;
    }
}

package test.cc.openhome;
import cc.openhome.Calculator;
public class CalculatorTest {
    ...

    public static void testMinus() {
        Calculator calculator = new Calculator();
        int expected = 1;
        int result = calculator.minus(3, 2);
        if(expected == result) {
            System.out.println("正確！");
        }
        else {
            System.out.printf(
               "錯誤，傳回 %d，但應該是 %d！%n", result, expected);
        }
    }
}

package test.cc.openhome;

public class TestRunner {
    public static void main(String[] args) {
        CalculatorTest.testPlus();
        CalculatorTest.testMinus();
    }
}

package test.cc.openhome;
public class Assert {
    public static void assertEquals(int expected, int result) {
        if(expected == result) {
            System.out.println("正確！");
        }
        else {
            System.out.printf(
               "失敗，預期為 %d，但是傳回 %d！%n", expected, result);
        }
    }
}

package test.cc.openhome;
import cc.openhome.Calculator;
public class CalculatorTest {
    public static void testPlus() {
        Calculator calculator = new Calculator();
        int expected = 3;
        int result = calculator.plus(1, 2);
        Assert.assertEquals(expected, result);
    }
    public static void testMinus() {
        Calculator calculator = new Calculator();
        int expected = 1;
        int result = calculator.minus(3, 2);
        Assert.assertEquals(expected, result);
    }
}

package test.cc.openhome;
public interface Test {
    void run();
}

package test.cc.openhome;
import java.util.*;
public class TestRunner {
    private List<Test> tests;
    public TestRunner() {
        tests = new ArrayList<Test>();
    }
    public void add(Test test) {
        tests.add(test);
    }
    public void run() {
        for(Test test : tests) {
            test.run();
        }
    }
}

package test.cc.openhome;
import cc.openhome.Calculator;
public class CalculatorPlusTest implements Test {
    @Override
    public void run() {
        Calculator calculator = new Calculator();
        int expected = 3;
        int result = calculator.plus(1, 2);
        Assert.assertEquals(expected, result);
    }
}

package test.cc.openhome;
import cc.openhome.Calculator;
public class CalculatorMinusTest implements Test {
    @Override
    public void run() {
        Calculator calculator = new Calculator();
        int expected = 1;
        int result = calculator.minus(3, 2);
        Assert.assertEquals(expected, result);
    }
}

package test.cc.openhome;
public class CalculatorTest {
    public static void main(String[] args) {
        TestRunner runner = new TestRunner();
        runner.add(new CalculatorPlusTest());
        runner.add(new CalculatorMinusTest());
        runner.run();
    }
}

package test.cc.openhome;
import java.util.*;
public class TestSuite implements Test {
    private List<Test> tests;
    public TestSuite() {
        tests = new ArrayList<Test>();
    }
    @Override
    public void run() {
        for (Test test : tests) {
            test.run();
        }
    }
    public void add(Test test) {
        tests.add(test);
    }
}

package test.cc.openhome;
import java.lang.reflect.*;
public class TestCase extends Assert implements Test {
    private String fName;

    public TestCase() {}
    public TestCase(String name) {
        fName = name;
    }
    
    protected void setUp() {}
    protected void tearDown() {}

    @Override
    public void run() {
        setUp();
        runTest();
        tearDown();
    }
    
    public void runTest() {
        Method runMethod= null;
        try {
            runMethod= getClass().getMethod(fName, null);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        if (!Modifier.isPublic(runMethod.getModifiers())) {
            throw new RuntimeException("方法 \"" + fName + "\" 必須是 public");
        }
        try {
            runMethod.invoke(this, new Class[0]);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public String getName() {
        return fName;
    }
    
    public void setName(String name) {
        fName = name;
    }
}

package test.cc.openhome;
import java.lang.reflect.*;
import java.util.*;
public class TestSuite implements Test {
    private List<Test> tests = new ArrayList<Test>();

    public TestSuite() {}
    public TestSuite(Class clz) {
        // 找出每個test開頭的方法
        Method[] methods = clz.getDeclaredMethods();
        for (Method method : methods) {
            if (Modifier.isPublic(method.getModifiers())
                    && method.getName().startsWith("test")) {
                Constructor constructor = null;
                try {
                    constructor = clz.getConstructor();
                    // 建立TestCase實例
                    TestCase testCase = (TestCase) constructor.newInstance();
                    // 設定要呼叫的testXXX()方法
                    testCase.setName(method.getName());
                    // 加入測試
                    add(testCase);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    @Override
    public void run() {
        for (Test test : tests) {
            test.run();
        }
    }

    public void add(Test test) {
        tests.add(test);
    }
    public void add(Class clz) {
        tests.add(new TestSuite(clz));
    }
}

package test.cc.openhome;
public class TestRunner {
    public static void run(Test test) {
        test.run();
    }
    public static void run(Class clz) {
        run(new TestSuite(clz)); 
    }
}

package test.cc.openhome;
import cc.openhome.Calculator;
public class CalculatorTest extends TestCase {
    private Calculator calculator;

    public CalculatorTest() {}   
    public CalculatorTest(String name) {
        super(name);
    }
    
    @Override
    protected void setUp() {
        calculator = new Calculator();
    }
    @Override
    protected void tearDown() {
        calculator = null;
    }

    public void testPlus() {
        int expected = 5;
        int result = calculator.plus(3, 2);
        assertEquals(expected, result);
    }
    
    public void testMinus() {
        int expected = 1;
        int result = calculator.minus(3, 2);
        assertEquals(expected, result);
    }
    
    public static void main(String[] args) {
        TestRunner.run(CalculatorTest.class);
    }
}

package test.cc.openhome;
public class CalculatorAll {
    public static Test suite() {
        TestSuite suite = new TestSuite();
        suite.add(CalculatorPlusMinusTest.suite());
        suite.add(CalculatorTest.class);
        suite.add(new CalculatorTest("testPlus"));
        return suite;
    }
    public static void main(String[] args) {
        TestRunner.run(suite());
    }
}

new int[] {0, 1, 2, 3};

new String[][] {
	{"a", "b"},
	{"c", "d"}
};

return new MyClass() {
  @Override public void method() {
    if (condition()) {
      try {
        something();
      } catch (ProblemException e) {
        recover();
      }
    }
  }
};

@Override
	public String playShiritori(Set<String> candidates, String lastResponse) {
		Set<String> choices = getNextChoices(candidates, lastResponse);
		if (choices.isEmpty()) {
			return null;
		} else {
			...
		}
	}

/*
 * This is          // And so           /* Or you can
 * okay.            // is this.          * even do this. */
 */

一个文档注释由两部分组成：

/**
* 描述部分(description) 
*
* 标记部分(block tags)
*/

/** An especially short bit of Javadoc. */

/**
* This is a simulation of Prof. Knuth's MIX computer.
*/

/**
 * Returns an Image object that can then be painted on the screen. 
 * The url argument must specify an absolute {@link URL}. The name
 * argument is a specifier that is relative to the url argument. 
 * <p>
 * This method always returns immediately, whether or not the 
 * image exists. When this applet attempts to draw the image on
 * the screen, the data will be loaded. The graphics primitives 
 * that draw the image will incrementally paint on the screen. 
 *
 * @param url an absolute URL giving the base location of the image
 * @param name the location of the image, relative to the url argument
 * @return the image at the specified URL
 * @see Image
 */
public Image getImage(URL url, String name) {
    try {
        return getImage(new URL(url, name));
    } catch (MalformedURLException e) {
        return null;
    }
}

/**
 * Graphics is the abstract base class for all graphics contexts
 * which allow an application to draw onto components realized on
 * various devices or onto off-screen images.
 * A Graphics object encapsulates the state information needed
 * for the various rendering operations that Java supports. This
 * state information includes:
 * <ul>
 * <li>The Component to draw on
 * <li>A translation origin for rendering and clipping coordinates
 * <li>The current clip
 * <li>The current color
 * <li>The current font
 * <li>The current logical pixel operation function (XOR or Paint)
 * <li>The current XOR alternation color
 * (see <a href="#setXORMode">setXORMode</a>)
 * </ul>
 * <p>
 * Coordinates are infinitely thin and lie between the pixels of the
 * output device.
 * Operations which draw the outline of a figure operate by traversing
 * along the infinitely thin path with a pixel-sized pen that hangs
 * down and to the right of the anchor point on the path.
 * Operations which fill a figure operate by filling the interior
 * of the infinitely thin path.
 * Operations which render horizontal text render the ascending
 * portion of the characters entirely above the baseline coordinate.
 * <p>
 * Some important points to consider are that drawing a figure that
 * covers a given rectangle will occupy one extra row of pixels on
 * the right and bottom edges compared to filling a figure that is
 * bounded by that same rectangle.
 * Also, drawing a horizontal line along the same y coordinate as
 * the baseline of a line of text will draw the line entirely below
 * the text except for any descenders.
 * Both of these properties are due to the pen hanging down and to
 * the right from the path that it traverses.
 * <p>
 * All coordinates which appear as arguments to the methods of this
 * Graphics object are considered relative to the translation origin
 * of this Graphics object prior to the invocation of the method.
 * All rendering operations modify only pixels which lie within the
 * area bounded by both the current clip of the graphics context
 * and the extents of the Component used to create the Graphics object.
 * 
 * @author Sami Shaio
 * @author Arthur van Hoff
 * @version %I%, %G%
 * @since 1.0
 */
public abstract class Graphics {

    /** 
     * Draws as much of the specified image as is currently available
     * with its northwest corner at the specified coordinate (x, y).
     * This method will return immediately in all cases, even if the
     * entire image has not yet been scaled, dithered and converted
     * for the current output device.
     * <p>
     * If the current output representation is not yet complete then
     * the method will return false and the indicated 
     * {@link ImageObserver} object will be notified as the
     * conversion process progresses.
     *
     * @param img the image to be drawn
     * @param x the x-coordinate of the northwest corner
     * of the destination rectangle in pixels
     * @param y the y-coordinate of the northwest corner
     * of the destination rectangle in pixels
     * @param observer the image observer to be notified as more
     * of the image is converted. May be 
     * <code>null</code>
     * @return <code>true</code> if the image is completely 
     * loaded and was painted successfully; 
     * <code>false</code> otherwise.
     * @see Image
     * @see ImageObserver
     * @since 1.0
     */
    public abstract boolean drawImage(Image img, int x, int y, 
                                      ImageObserver observer);


    /**
     * Dispose of the system resources used by this graphics context.
     * The Graphics context cannot be used after being disposed of.
     * While the finalization process of the garbage collector will
     * also dispose of the same system resources, due to the number
     * of Graphics objects that can be created in short time frames
     * it is preferable to manually free the associated resources
     * using this method rather than to rely on a finalization
     * process which may not happen for a long period of time.
     * <p>
     * Graphics objects which are provided as arguments to the paint
     * and update methods of Components are automatically disposed
     * by the system when those methods return. Programmers should,
     * for efficiency, call the dispose method when finished using
     * a Graphics object only if it was created directly from a
     * Component or another Graphics object.
     *
     * @see #create(int, int, int, int)
     * @see #finalize()
     * @see Component#getGraphics()
     * @see Component#paint(Graphics)
     * @see Component#update(Graphics)
     * @since 1.0
     */
    public abstract void dispose();

    /**
     * Disposes of this graphics context once it is no longer 
     * referenced.
     *
     * @see #dispose()
     * @since 1.0
     */
    public void finalize() {
        dispose();
    }
}