Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book

Calling Methods

Calling a method in an object is similar to referring to its instance variables: Dot notation is used. The object whose method you're calling is on the left side of the dot, and the name of the method and its arguments are on the right side of the dot:

myCustomer.addToOrder(itemNumber, price, quantity);

Note that all methods must have parentheses after them, even if the method takes no arguments:

myCustomer.cancelAllOrders();

Listing 3.3 shows an example of calling some methods defined in the String class. Strings include methods for string tests and modification, similar to what you would expect in a string library in other languages.

LISTING 3.3 The Full Text of CheckString.java

 1: class CheckString {
 2:
 3:     public static void main(String[] arguments) {
 4:         String str = "Nobody ever went broke by buying IBM";
 5:         System.out.println("The string is: " + str);
 6:         System.out.println("Length of this string: "
 7:             + str.length());
 8:         System.out.println("The character at position 5: "
 9:             + str.charAt(5));
10:         System.out.println("The substring from 26 to 32: "
11:             + str.substring(26, 32));
12:         System.out.println("The index of the character v: "
13:             + str.indexOf('v'));
14:         System.out.println("The index of the beginning of the "
15:             + "substring \"IBM\": " + str.indexOf("IBM"));
16:         System.out.println("The string in upper case: "
17:             + str.toUpperCase());
18:     }
19: }

The following is displayed on your system's standard output device when you run the program:

The string is: Nobody ever went broke by buying IBM
Length of this string: 36
The character at position 5: y
The substring from 26 to 32: buying
The index of the character v: 8
The index of the beginning of the substring "IBM": 33
The string in upper case: NOBODY EVER WENT BROKE BY BUYING IBM

In line 4, you create a new instance of String by using a string literal. The remainder of the program simply calls different string methods to do different operations on that string:

  • Line 5 prints the value of the string you created in line 4: "Nobody ever went broke by buying IBM".

  • Line 7 calls the length() method in the new String object. This string has 36 characters.

  • Line 9 calls the charAt() method, which returns the character at the given position in the string. Note that string positions start at position 0 rather than 1, so the character at position 5 is y.

  • Line 11 calls the substring() method, which takes two integers indicating a range and returns the substring with those starting and ending points. The substring() method can also be called with only one argument, which returns the substring from that position to the end of the string.

  • Line 13 calls the indexOf() method, which returns the position of the first instance of the given character (here, 'v'). Character literals are surrounded by single quotation marks; if double quotation marks had surrounded the v in line 13, the literal would be considered a String.

  • Line 15 shows a different use of the indexOf() method, which takes a string argument and returns the index of the beginning of that string.

  • Line 17 uses the toUpperCase() method to return a copy of the string in all uppercase.

Nesting Method Calls

A method can return a reference to an object, a primitive data type, or no value at all. In the CheckString program, all the methods called on the String object str returned values that were displayed; for example, the charAt() method returned a character at a specified position in the string.

The value returned by a method also can be stored in a variable:

String label = "From";
String upper = label.toUpperCase();

In the preceding example, the String object upper contains the value returned by calling label.toUpperCase()—the text "FROM", an uppercase version of "From".

If the method returns an object, you can call the methods of that object in the same statement. This makes it possible for you to nest methods as you would variables.

Earlier today, you saw an example of a method called with no arguments:

myCustomer.cancelAllOrders();

If the cancelAllOrders() method returns an object, you can call methods of that object in the same statement:

myCustomer.cancelAllOrders().talkToManager();

This statement calls the talkToManager() method, which is defined in the object returned by the cancelAllOrders() method of the myCustomer object.

You can combine nested method calls and instance variable references, as well. In the next example, the putOnLayaway() method is defined in the object stored by the orderTotal instance variable, which itself is part of the myCustomer object:

myCustomer.orderTotal.putOnLayaway(itemNumber, price, quantity);

System.out.println(), the method you've been using in all program examples to display information, is an example of nesting variables and methods.

The System class, part of the java.lang package, describes behavior specific to the system on which Java is running. System.out is a class variable that contains an instance of the class PrintStream. This PrintStream object represents the standard output of the system, which is normally the screen but can be redirected to a printer or file. PrintStream objects have a println() method that sends a string to that output stream.

Class Methods

Class methods, like class variables, apply to the class as a whole and not to its instances. Class methods are commonly used for general utility methods that might not operate directly on an instance of that class but do fit with that class conceptually. For example, the String class contains a class method called valueOf(), which can take one of many different types of arguments (integers, Booleans, other objects, and so on). The valueOf() method then returns a new instance of String containing the string value of the argument. This method doesn't operate directly on an existing instance of String, but getting a string from another object or data type is definitely a String-like operation, and it makes sense to define it in the String class.

Class methods can also be useful for gathering general methods together in one place (the class). For example, the Math class, defined in the java.lang package, contains a large set of mathematical operations as class methods; there are no instances of the class Math, but you still can use its methods with numeric or Boolean arguments. For example, the class method Math.max() takes two arguments and returns the larger of the two. You don't need to create a new instance of Math; it can be called anywhere you need it, as in the following:

int maximumPrice = Math.max(firstPrice, secondPrice);

Dot notation is used to call a class method. As with class variables, you can use either an instance of the class or the class itself on the left side of the dot. For the same reasons noted in the discussion on class variables, however, using the name of the class makes your code easier to read. The last two lines in this example produce the same result—the string 5:

String s, s2;
s = "item";
s2 = s.valueOf(5);
s2 = String.valueOf(5);
  • + Share This
  • 🔖 Save To Your Account