Module 4: Methods: Parameters and Return Values

4.1 Exercise: Download, compile and execute VowelDensity.java to see these fractions being computed for each of English and Klingon. You will also need WordTool.java, words.txt, and klingonwords.txt. Try to read the code to see if you can make sense of parts of it.

We'll now list the whole program in its entirety:

public class VowelDensity {

    public static void main (String[] argv)
    {
	char[] vowels = {'a', 'e', 'i', 'o', 'u'};

	// First, English.
	String[] englishWords = WordTool.getUnixWords ();
	// Set up counters:
	int numVowels = 0;
	int numConsonants = 0;

	// Loop through all English words.
	for (int i=0; i<englishWords.length; i++) {
            // For each word, we'll count the number of vowels:
	    int v = 0;
	    for (int j=0; j<englishWords[i].length(); j++) {
		// Compare the j-th letter with all vowels
		for (int k=0; k<vowels.length; k++) {
		    if ( vowels[k] == englishWords[i].charAt(j) ) {
			v++;
		    }
		}
	    }
	    numVowels = numVowels + v;
	    numConsonants = numConsonants + (englishWords[i].length() - v);
	    // Note: if the word length is N, there are N-v consonants.
	}
	
	double englishFraction  = (double) numVowels / (double) (numConsonants + numVowels);
	System.out.println ("Fraction for English: " + englishFraction);

	// Next, Klingon (without comments embedded)
	String[] klingonWords = WordTool.getKlingonWords ();
	numVowels = 0;
	numConsonants = 0;
	for (int i=0; i<klingonWords.length; i++) {
	    int v = 0;
	    for (int j=0; j<klingonWords[i].length(); j++) {
		for (int k=0; k<vowels.length; k++) {
		    if ( vowels[k] == klingonWords[i].charAt(j) ) {
			v++;
		    }
		}		    
	    }
	    numVowels = numVowels + v;
	    numConsonants = numConsonants + (klingonWords[i].length() - v);
	}

	double klingonFraction  = (double) numVowels / (double) (numConsonants + numVowels);
	System.out.println ("Fraction for Klingon: " + klingonFraction);

	// A 3rd language?
        // ...
    }

}
     

So, yes, it's long. But let's point out a few things:

• Does it not seem wasteful to write more or less exactly the same code for both languages?

• The triply-nested for-loop seems a bit hard to understand, even though we already have done vowel-counting before (Module 3).

4.2 Exercise: How many more lines would need to be added to the above code to add a 3rd language?

Now let's look at the same application written with methods:

public class VowelDensity2 {

    public static void main (String[] argv)
    {
	// First, English.
	String[] englishWords = WordTool.getUnixWords ();
	double englishFraction = processWords (englishWords);
	System.out.println ("Fraction for English: " + englishFraction);

	// Next, Klingon
	String[] klingonWords = WordTool.getKlingonWords ();
	double klingonFraction = processWords (klingonWords);
	System.out.println ("Fraction for Klingon: " + klingonFraction);

        // A 3rd language?
        // ...
    }

    static double processWords (String[] words)
    {
	// This method will go through the array of words and update
	// the vowel/consonant counts.
	int numVowels = 0;
	int numConsonants = 0;
	for (int i=0; i<words.length; i++) {
	    int v = vowelCount (words[i]);      // This method does the work.
	    numVowels = numVowels + v;
	    numConsonants = numConsonants + (words[i].length() - v);
	}
	
	double fraction  = (double) numVowels / (double) (numConsonants + numVowels);
	return fraction;
    }

    static int vowelCount (String w)
    {
	int numV = 0;
	char[] letters = w.toCharArray ();
	for (int j=0; j<letters.length; j++) {
	    if ( isVowel(letters[j]) ) {
		// if the j-th letter is a vowel, update the count.
		numV++;
	    }
	}
	return numV;
    }

    static boolean isVowel (char c)
    {
        // See if c is a vowel.
	char[] vowels = {'a', 'e', 'i', 'o', 'u'};
	for (int k=0; k<vowels.length; k++) {
	    if (c == vowels[k]) {
		return true;
	    }
	}
	return false;
    }

}
     

Before continuing, it is essential to review methods as described in Module 3 of Unit-0.

What to review:

• The notion of how execution starts in one method, goes to another, and comes back to the originating method.

• Important: When we come back to the originating method, we continue execution from where we left off.

4.4 Exercise: Review that module. Now.

4.2    Method parameters

  *****
  ***
  *
  

public class FindLargestInArray {

    public static void main (String[] argv)
    {
	double[] someNumbers = {2.718, 3.141, 1.414, 1.618};
	double largest = findLargest (someNumbers);
	System.out.println (largest);
    }

    // Write your method here:

}
     

public class NegativeElement {

    public static void main (String[] argv)
    {
	double[] data = {4.0, 5.0, -2.0, 1.0, 3.0};
	boolean hasNegative = hasNegativeElement (data);
	if (hasNegative) {
	    System.out.println ("Yeah");
	}
	else {
	    System.out.println ("Nah");
	}
    }

    static boolean hasNegativeElement (double[] A)
    {
	for (int i=0; i<A.length; i++) {
	    if (A[i] < 0) {
		return true;
	    }
	}
	return false;
    }

}
     

     static int analyze (String s)
     {
	char[] letters = s.toCharArray ();
        int numSpaces = 0;
	boolean hasApostrophe = false;
	for (int i=0; i<letters.length; i++) {
	    if (letters[i] == ' ') {
		numSpaces++;
	    }
	    if (letters[i] == '\'') {
		hasApostrophe = true;
	    }
	}
        // return numSpaces or hasApostrophe?
     
     }
     

     public static void main (String[] argv)
     {
         String testString = "hey, aren't globals cool?";
         analyze (testString);
         System.out.println ("# spaces=" + numSpaces + " hasApostrophe=" + hasApostrophe);
     }
     

public class NullExample {

    static int[] A;


    public static void main (String[] argv)
    {
	print (A);
    }

    static void print (int[] B)
    {
	for (int i=0; i<B.length; i++) {
	    System.out.println (B[i]);
	}
    }

}
     

public class WellDone {

    public static void main (String[] argv) 
    {
        System.out.println ("CONGRATULATIONS!");
    }   

}