Lecture Notes 08: Methods, encapsulation, and scope

Objectives

By the end of this module, for simple HelloWorld-like programs, you will be able to:

• Understand why methods exist and know how to write one yourself
• Understand return statements
• Understand method arguments

Why are functions useful in computation?

• Sharing complex libraries, such as SSL, deep learning, etc.
• Allowing groups of people to work on the same codebase in parallel, to make large systems
• Other examples?

Writing and using Methods that use Input and/or return Output

In the previous module with Strings, we practiced using methods that resolve (or return) something and that might need input parameters to run.
In this segment we'll practice writing and invoking such methods.

First, two definitions:

• Parameters are those specified in the Method Declaration as being required as input for the method to function
.
• Arguments are the actual explicit values or variables whose values we want to pass to the method by putting the inside the parenthesis when doing the method Invocation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

  public class IOMethods1
  {
    public static void main(String args[])
    {
      int num1 = 5;
      int num2 = 13;
      // Invoke the myOperation method and save result in the num3 variable
      int num3 = myOperation(num1, num2);  // myOperation(num1, num2) resolves into the resulting value
      System.out.println ("myOperation on " + num1 + " and " + num2 +  " is: " + num3);
    }

    public static int myOperation(int localNum1, int localNum2)
    {
      int localNum3 = (localNum1 * localNum2) - (localNum1 - localNum2);
      // this causes the method invocation to resolve into localNum3
      return localNum3;
    }
  }
  

Note the following:

• Since the method does not know how it will be invoked, it has default names for the input parameters. For example, it could be called like this:
  • int z = myOperation (8,2);
  
  And it has to place the arguments 8 and 2 somewhere!
• The parameters that the method myOperation takes are two ints that will be locally called localNum1 and localNum2 (but that you could rename to whatever you want as long as you use them properly inside the method).
• When we invoke the method, the argument values are copied from the invocation arguments to the method's input parameters.
  That is, from num1 to localNum1, and from num2 to localNum2.
• The local method variables are only "alive" during the execution of the method. Once the method returns, those variables are no longer in existence.

localNum1 = localNum1 + 99;
localNum2 = localNum2 + 99;

then, inside the main, add the following statement:

System.out.println ("num1 after modifying localNum1 is: " + num1 );
System.out.println ("num2 after modifying localNum2 is: " + num2 );

What do you print? why?

Now look at this program:

 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
29
30

  public class IOMethods2
  {
    public static void main(String args[])
    {
      String base = "Pizza should not have pineapple";
      String part = "pine";

      // Invoke the extract method and save result in out variable
      String out = extract(base, part);  // extract(base, part) resolves into the resulting string
      System.out.println ("The new String is: " + out);
    }

    public static String extract(String localBase, String localPart)
    {
      // The return variable
      String localOut = "";

      // Get the index of localPart inside localBase
      int idx = localBase.indexOf ( localPart );
      // Get the size of localPart
      int partSize = localPart.length();

      // copy localBase up to the start of localPart
      localOut = localBase.substring (0, idx);
      // copy localBase after localPart until the end of localBase
      localOut = localOut + localBase.substring (idx + partSize);

      return localOut;
    }
  }
  

Activity 3: In IOMethods2.java write the above program and see what gets printed.
Now, let us run it inside the Java Visualizer to understand the way these parameters are passed around.

Note the following:

• Since the method does not know how it will be invoked, it has default names for the input parameters. For example, it could be called like this:
  • String out = extract ("catastrophe", "cat");
• The parameters that the method extract takes are two Strings that will be locally called localBase and localPart.
• When we invoke the method, the values inside the calling arguments are copied into the input parameters.
• However, since base and part are Strings, which are Reference types the contents of those variables are references to where the object is located!! so we actually end up copying the references, NOT the values.
  This is called "passing By reference"

localBase = "New Base";
localPart = "New Part";

then, inside the main, add the following statement:

System.out.println ("base after modifying localBase is: " + base );
System.out.println ("part after modifying localPart is: " + part );

What do you print? why?

Activity 5: In IOMethods3.java Write a method that takes no parameters but returns a value. Then invoke that method from main and print the return value.

Activity 6: In IOMethods4.java Write a method that takes one character array parameter (called arr), one integer parameter (called idx), and one char parameter (called ch).
The method should modify the array with the character at index idx replaced with the character ch. Then invoke that method from main and print the return value.

Variables declared outside of methods

You may have seen variables that were declared outside methods in our homework (for example, turning a test case on or off) -- these were used to control whether or not a problem gets tested. You may have observed that our main method was able to see these variables, even though they were declared outside of the method. Let's formally explore what's going on now.

Consider the following program:

Activity 1: Execute the above program in the Java Visualizer. What does it print?

Let us point out a few things:

• The variable x is declared outside any of the methods, including main:

  

• It is accessible in any method defined in the class:

  

• Such a variable is called a field of the class.
         => It's accessible to all the methods in the class.

public class VisibilityTest {
    public static int a = 3;
    static int b = 4;
    private static int c = 5;

    private static int helper() {
        return 1;
    }

    public static int helper2() {
        return helper() + 1;
    }
}

public class VisibilityMain {
    public static void main(String[] args) {
        System.out.println(VisibilityTest.helper());
        System.out.println(VisibilityTest.helper2());
        System.out.println(VisibilityTest.a);
        System.out.println(VisibilityTest.b);
        System.out.println(VisibilityTest.c);
    }
}