Boolean-valued method

Question

In the textbook, it says that boolean-methods are:
public Boolean equals(DemoSpecies otherObject)
return ((name.equalsIgnoreCase(otherObject.name))
&&(population==otherObject.population);
&&(growthRate==otherObject.growthRate);
}But it also says that these are also boolean-method:
Species s1 = new Species(), s2 = new Species();
<Some code to set the values of s1 and s2.>
boolean areEqual;
areEqual = s1.equals(s2);
<Some more code.>
if (areEqual)
System.out.println("They are equal.")
else
System.out.println("They are not equal.")Which one is a boolean valued method? Are they both the same thing? If I want to test an inequality between class variable name and a variable (such as numberOfStudents), which one would I use?
Thanks in advance.

Answer 1

I'm still not sure what the question is... I guess autoboxing might be confusing you... autoboxing automagically transmutes a parameter from it's fundamental type to it's wrapper-class equivalent... which allows you to write code which treats Boolean and boolean as equivalent, except for those nasty nulls.
For example, the code:
package forums;
class AutoBoxTesterator
  public static void main(String[] args) {
    int i = 1;
    System.out.println("i="+method1(i));
    Integer jj = 2;
    System.out.println("jj="+method2(jj));
    Integer kk = null;
    System.out.println("kk="+method1(kk));
    try {
      System.out.println("kk="+method2(kk));
    } catch (NullPointerException e) {
      System.out.print("method1(null) caused: ");
      e.printStackTrace();
    boolean b = method3();
    System.out.println("b="+b);
  private static String method1(Integer ii) {
    return ""+ii;
  private static String method2(int j) {
    return ""+j;
  private static Boolean method3() {
    return true;
}produces:
i=1
jj=2
kk=null
method2(null) caused: java.lang.NullPointerException
        at forums.AutoBoxTesterator.main(AutoBoxTesterator.java:16)
b=trueThe above code behaves this way because:
1. int i is "auto-boxed" into Integer ii as it's passed to method1.
2. Integer jj is "auto-unboxed" into int j as it's passed to method2.
3. Integer kk remains unmodified as it's passed to method1.
4. Integer kk throws a runtime NullPointerException when we attempt to unbox null to pass it to method2.
5. In method3() "true" is auto-boxed to a Boolean (ie method3's declared return type), which is them immediately unboxed back to a raw boolean to be stored in b; Again this will cause a NPE if method3 happens to return null.
So what does that mean?... Well it means that as of 1.6 you can be pretty fast and loose with "wrapper vs fundamendal types", so long as you're mindful of null's.