1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Noise {

	
	/**
	* Default constructor.
	*/
	protected AnnualDateRule() {
	}
	No, really? Or how about this:
	/** The day of the month. */
	private int dayOfMonth;
	And then there’s this paragon of redundancy:
	/**
	* Returns the day of the month.
	*
	* @return the day of the month.
	*/
	public int getDayOfMonth() {
	return dayOfMonth;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Mumbling {


	public void loadProperties() {
		try {
			String propertiesPath = propertiesLocation + "/" + PROPERTIES_FILE;
			FileInputStream propertiesStream = new FileInputStream(propertiesPath);
			loadedProperties.load(propertiesStream);
		} catch (IOException e) {
			// No properties files means all defaults are loaded
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Journal {
	
	* Changes (from 11-Oct-2001)
	* --------------------------
	* 11-Oct-2001 : Re-organised the class and moved it to new package
	* com.jrefinery.date (DG);
	* 05-Nov-2001 : Added a getDescription() method, and eliminated NotableDate
	* class (DG);
	* 12-Nov-2001 : IBD requires setDescription() method, now that NotableDate
	* class is gone (DG); Changed getPreviousDayOfWeek(),
	* getFollowingDayOfWeek() and getNearestDayOfWeek() to correct
	* bugs (DG);
	* 05-Dec-2001 : Fixed bug in SpreadsheetDate class (DG);
	* 29-May-2002 : Moved the month constants into a separate interface
	* (MonthConstants) (DG);
	* 27-Aug-2002 : Fixed bug in addMonths() method, thanks to N???levka Petr (DG);
	* 03-Oct-2002 : Fixed errors reported by Checkstyle (DG);
	* 13-Mar-2003 : Implemented Serializable (DG);
	* 29-May-2003 : Fixed bug in addMonths method (DG);
	* 04-Sep-2003 : Implemented Comparable. Updated the isInRange javadocs (DG);
	* 05-Jan-2005 : Fixed bug in addYears() method (1096282) (DG);
	
	/*Long ago there was a good reason to create and maintain these log entries at the start
	of every module. We didn’t have source code control systems that did it for us. Nowadays,
	however, these long journals are just more clutter to obfuscate the module. They should be
	completely removed.*/

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Journal {
	
public class CommentOutCode {

	/*There was a time, back in the sixties, when commenting-out code might have been
	useful. But we’ve had good source code control systems for a very long time now. Those
	systems will remember the code for us. We don’t have to comment it out any more. Just
	delete the code. We won’t lose it. Promise*/
	
	
	InputStreamResponse response = new InputStreamResponse();
	response.setBody(formatter.getResultStream(), formatter.getByteCount());
	// InputStream resultsStream = formatter.getResultStream();
	// StreamReader reader = new StreamReader(resultsStream);
	// response.setContent(reader.read(formatter.getByteCount()));
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class ClosingBrace {

	public static void main(String[] args) {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		String line;
		int lineCount = 0;
		int charCount = 0;
		int wordCount = 0;
		try {
			while ((line = in.readLine()) != null) {
				lineCount++;
				charCount += line.length();
				String words[] = line.split("\\W");
				wordCount += words.length;
			} // while
			System.out.println("wordCount = " + wordCount);
			System.out.println("lineCount = " + lineCount);
			System.out.println("charCount = " + charCount);
		} // try
		catch (IOException e) {
			System.err.println("Error:" + e.getMessage());
		} // catch
	} // main

}

1
2
3
4
5
6
7
8
9
10
11
12
public class Amplification {

	//A comment may be used to amplify(phong dai   ) the importance of something that may otherwise seem inconsequential
	
	
	
	String listItemContent = match.group(3).trim();
	// the trim is real important. It removes the starting // spaces that could cause the item to be recognized
	// as another list.
	new ListItemWidget(this, listItemContent, this.level + 1); return buildList(text.substring(match.end()));

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Clarification {

	//Sometimes it is just helpful to translate the meaning of some obscure argument 
	//or return value into something that’s readable
	
	public void testCompareTo() throws Exception {
		WikiPagePath a = PathParser.parse("PageA"); 
		WikiPagePath ab = PathParser.parse("PageA.PageB"); 
		WikiPagePath b = PathParser.parse("PageB"); 
		WikiPagePath aa = PathParser.parse("PageA.PageA"); 
		WikiPagePath bb = PathParser.parse("PageB.PageB"); 
		WikiPagePath ba = PathParser.parse("PageB.PageA");
		}
		assertTrue(a.compareTo(a) == 0);  // a == a
		assertTrue(a.compareTo(b) != 0);   // a != b 
		assertTrue(ab.compareTo(ab) == 0); // ab == ab
		assertTrue(a.compareTo(b) == -1);  // a < b 
		assertTrue(aa.compareTo(ab) == -1); // aa < ab 
		assertTrue(ba.compareTo(bb) == -1); // ba < bb
		assertTrue(b.compareTo(a) == 1);  // b > a
		assertTrue(ab.compareTo(aa) == 1); // ab > aa
		assertTrue(bb.compareTo(ba) == 1);  // bb > ba
		
		
			
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ExplanationOfIntent {
	
	//Here’s an even better example. You might not agree with the programmer’s solution to the problem, 
	//but at least you know what he was trying to do.

	public void testConcurrentAddWidgets() throws Exception { 
		WidgetBuilder widgetBuilder = new WidgetBuilder(new Class[]{BoldWidget.class});
		String text = "'''bold text'''"; ParentWidget parent =
				new BoldWidget(new MockWidgetRoot(), "'''bold text'''"); AtomicBoolean failFlag = new AtomicBoolean(); failFlag.set(false);
				//This is our best attempt to get a race condition 
				//by creating large number of threads.
				for (int i = 0; i < 25000; i++) {
					WidgetBuilderThread widgetBuilderThread =
					new WidgetBuilderThread(widgetBuilder, text, parent, failFlag);
					Thread thread = new Thread(widgetBuilderThread);
					thread.start(); 
				}
				assertEquals(false, failFlag.get());
	}
	
}

1
2
3
4
5
6
7
8
9
10
//It is sometimes useful to provide basic information with a comment. 
	//For example, con- sider this comment that explains the return value of an abstract method:
	
	// Returns an instance of the Responder being tested.
	protected abstract Responder responderInstance();
	
	// format matched kk:mm:ss EEE, MMM dd, yyyy 
	Pattern timeMatcher = Pattern.compile("\\d*:\\d*:\\d* \\w*, \\w* \\d*, \\d*");
	
}

1
2
3
4
5
6
7
8
9
public class Legal {
	
	//Sometimes our corporate coding standards force us to write certain comments for legal reasons. 
	//For example, copyright and authorship statements are necessary and reasonable things 
	//to put into a comment at the start of each source file.

	/ Copyright (C) 2003,2004,2005 by Object Mentor, Inc. All rights reserved.
	// Released under the terms of the GNU General Public License version 2 or later.
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class WarningOfConsequences {

	//Sometimes it is useful to warn other pro- grammers about certain consequences. 
	//For example, here is a comment that explains why a particular test case is turned off:
	// Don't run unless you
	// have some time to kill.
	public void _testWithReallyBigFile() {
		writeLinesToFile(10000000);
		response.setBody(testFile);
		response.readyToSend(this);
		String responseString = output.toString(); assertSubString("Content-Length: 1000000000", responseString); assertTrue(bytesSent > 1000000000);
	}

}