Introduction To Java - Revision history

Wtd: /* A Goal and Some Math */

2010-04-18T22:52:00Z

A Goal and Some Math

← Older revision		Revision as of 22:52, 18 April 2010
Line 1,076:		Line 1,076:
	The numbers aren't lined up. To get them lined up, I'd need to insert spaces in front of the numbers as necessary. Of course, to know how many spaces are necessary, I have to first know how many spaces wide the largest number will be.		The numbers aren't lined up. To get them lined up, I'd need to insert spaces in front of the numbers as necessary. Of course, to know how many spaces are necessary, I have to first know how many spaces wide the largest number will be.

-	We can get that number with the getPreviousNamesCount method if any given MutableName object.	+	We can get that number with the getPreviousNamesCount method of any given MutableName object.

	Let's write a general purpose static method in our Test class which finds the length of an integer when it's converted to a string.		Let's write a general purpose static method in our Test class which finds the length of an integer when it's converted to a string.

Wtd: /* Conditionals Part Two: Alternatives, or "The Elsening" */

2010-04-18T22:50:47Z

Conditionals Part Two: Alternatives, or "The Elsening"

← Older revision		Revision as of 22:50, 18 April 2010
Line 953:		Line 953:
	</pre>		</pre>

-	That was easy enough, but something's still lacking. If there's only one name, it makes little sense to print "Previous name~~[b]~~s~~[/b]~~:". Fortunately we can create a conditional to deal with this.	+	That was easy enough, but something's still lacking. If there's only one name, it makes little sense to print "Previous name'''s''':". Fortunately we can create a conditional to deal with this.

	<pre>		<pre>

Wtd at 19:16, 10 October 2008

2008-10-10T19:16:20Z

← Older revision		Revision as of 19:16, 10 October 2008
Line 2,352:		Line 2,352:

	Creating the anonymous Comparator gave us a convenient way to have a custom behavior without having to actually write code to manage the sorting of the array.		Creating the anonymous Comparator gave us a convenient way to have a custom behavior without having to actually write code to manage the sorting of the array.
		+
		+	== Credits ==
		+
		+	Author: [[Wtd]]

Wtd at 03:56, 10 October 2008

2008-10-10T03:56:33Z

← Older revision		Revision as of 03:56, 10 October 2008
Line 1:		Line 1:
-	~~= Introduction to Java: Wiki Edition =~~
-
	== What is Java? ==		== What is Java? ==

Wtd: /* One More Thing... */

2008-10-10T03:55:15Z

One More Thing...

← Older revision		Revision as of 03:55, 10 October 2008
Line 2,128:		Line 2,128:
	<pre>		<pre>
	String inputLine = keyboardInput.readLine();		String inputLine = keyboardInput.readLine();
-	<pre>	+	</pre>

	This string can then be used as we would use any other string.		This string can then be used as we would use any other string.
Line 2,291:		Line 2,291:
	}		}
	</pre>		</pre>
-		+
	== Anonymous Inner Classes ==		== Anonymous Inner Classes ==

Wtd: /* Handling Exceptions */

2008-10-10T03:53:27Z

Handling Exceptions

← Older revision		Revision as of 03:53, 10 October 2008
Line 1,798:		Line 1,798:
	</pre>		</pre>

-	This is, in fact, probably a lot nicer to look at. The problem is that it now catches ~~[i]~~any~~[/i]~~ exception, including those I might not have foreseen. It's better to be specific about which class of exception we're actually handling.	+	This is, in fact, probably a lot nicer to look at. The problem is that it now catches ''any'' exception, including those I might not have foreseen. It's better to be specific about which class of exception we're actually handling.

	Now, I'd mentioned that "e" was the exception object the restorePreviousName method threw. What if we wanted to print an error message, but still throw the exception so that some other level of exception handling could deal with it?		Now, I'd mentioned that "e" was the exception object the restorePreviousName method threw. What if we wanted to print an error message, but still throw the exception so that some other level of exception handling could deal with it?

Wtd: /* Interfaces */

2008-10-10T03:52:25Z

Interfaces

← Older revision		Revision as of 03:52, 10 October 2008
Line 1,608:		Line 1,608:
	</pre>		</pre>

-	And of course we can do the same for MutableFormalName, but there's a complication. The MutableName interface specifies that we're dealing with BasicName objects. We can use FormalName objects because a FormalName ~~[i]~~is a~~[/i]~~ BasicName.	+	And of course we can do the same for MutableFormalName, but there's a complication. The MutableName interface specifies that we're dealing with BasicName objects. We can use FormalName objects because a FormalName ''is a'' BasicName.

	Wherever a method expects a BasicName, we can give it a FormalName. However, when we do that, the FormalName will now be treated as a BasicName, without the added capabilities of a FormalName, such as the ability to access the title.		Wherever a method expects a BasicName, we can give it a FormalName. However, when we do that, the FormalName will now be treated as a BasicName, without the added capabilities of a FormalName, such as the ability to access the title.

Wtd at 03:48, 10 October 2008

2008-10-10T03:48:52Z

Show changes

Wtd at 21:15, 9 October 2008

2008-10-09T21:15:41Z

Show changes

Wtd at 20:50, 9 October 2008

2008-10-09T20:50:13Z

← Older revision		Revision as of 20:50, 9 October 2008
Line 172:		Line 172:
	}		}
	}		}
		+	}
		+	</pre>
		+
		+	== Methods that return useful values ==
		+
		+	So far, all of the methods we've seen have simply taken an action. As such, they've had a return type of "void". Of course, it's very possible to have methods that return values, which the program can then use in whatever way it wishes.
		+
		+	<pre>
		+	public class HelloWorld {
		+	public static void main(String[] args) {
		+	System.out.println(niceGreeting("Bob"));
		+	System.out.println(niceGreeting("Bob", false));
		+	}
		+
		+	public static String niceGreeting(String nameToGreet) {
		+	return niceGreeting(nameToGreet, true);
		+	}
		+
		+	public static String niceGreeting(String nameToGreet, boolean greetNicely) {
		+	if (greetNicely) {
		+	return "Hello " + nameToGreet + "!";
		+	}
		+	else {
		+	return "Hey " + nameToGreet + "... STFU!";
		+	}
		+	}
		+	}
		+	</pre>
		+
		+	== On naming ==
		+
		+	A few quick notes between example-heavy sections.
		+
		+	You'll note that I use a capital letter at the beginning of class names, including "String", when I use that. This is a convention used by Java programmers. Learn to love it, because trying to be different will just make things harder. There are lots of other places to be creative.
		+
		+	Perhaps more importantly you'll notice that aside from "main", which is standard, all of my method names follow a specific convention. Methods that "do" something have verb names. Methods that return new values have noun names.
		+
		+	Also, method names begin with a lowercase letter.
		+
		+	== Qualifying names ==
		+
		+	Thus far when I've defined a new method, I've called it from another by simply writing the name of the method, with parentheses and any required arguments. This is fine, since it's all been within a single class. Java can assume that you qualified the method with the name of the class for static methods. We can be more explicit, though. The previous example can be changed to incorporate this more explicit notation.
		+
		+	<pre>
		+	public class HelloWorld {
		+	public static void main(String[] args) {
		+	System.out.println(HelloWorld.niceGreeting("Bob"));
		+	System.out.println(HelloWorld.niceGreeting("Bob", false));
		+	}
		+
		+	public static String niceGreeting(String nameToGreet) {
		+	return HelloWorld.niceGreeting(nameToGreet, true);
		+	}
		+
		+	public static String niceGreeting(String nameToGreet, boolean greetNicely) {
		+	if (greetNicely) {
		+	return "Hello " + nameToGreet + "!";
		+	}
		+	else {
		+	return "Hey " + nameToGreet + "... STFU!";
		+	}
		+	}
		+	}
		+	</pre>
		+
		+	Of course this is unnecessary in this case and thus silly. It is necessary, though, if we have another class. We can have multiple classes in a Java source file so long as only one is public.
		+
		+	<pre>
		+	class Greeter {
		+	public static String niceGreeting(String nameToGreet) {
		+	return niceGreeting(nameToGreet, true);
		+	}
		+
		+	public static String niceGreeting(String nameToGreet, boolean greetNicely) {
		+	if (greetNicely) {
		+	return "Hello " + nameToGreet + "!";
		+	}
		+	else {
		+	return "Hey " + nameToGreet + "... STFU!";
		+	}
		+	}
		+	}
		+
		+	public class HelloWorld {
		+	public static void main(String[] args) {
		+	System.out.println(Greeter.niceGreeting("Bob"));
		+	System.out.println(Greeter.niceGreeting("Bob", false));
		+	}
	}		}
	</pre>		</pre>