Kotlinlearncs.online LogoJava

    ← Prev

    Index

    Next →

    Kotlin
    Java

    • Practice with Functions : 12

    • More About Functions : 11

    • Errors and Debugging : 10

    • Functions : 9

    • Practice with Loops and Algorithms : 8

    • Algorithms I : 7

    • Loops : 6

    • Arrays : 5

    • Compound Conditionals : 4

    • Conditional Expressions and Statements : 3

    • Operations on Variables : 2

    • Variables and Types : 1

    • Hello, world! : 0

    More About Functions

    void printIt(int count) {
    System.out.println(count);
    }
    void printIt(int first, int second) {
    System.out.println(first + second);
    }
    printIt(10);
    printIt(40, 50);

    This lesson continues our exploration of functions. We’ll reinforce material covered in our last lesson, and go through some example of exactly what happens during function execution. We’ll also learn about overloading, when two methods share the same name. Let’s get started!

    Tracing Function Execution
    Tracing Function Execution

    While we’ve started to use and even write functions, we may be still a bit fuzzy about exactly what happens when a function runs. So let’s go through that slowly and carefully using a few examples.

    boolean completelyEven(int[] values) {
    for (int i = 0; i < values.length; i++) {
    if (values[i] % 2 != 0) {
    return false;
    }
    }
    return true;
    }
    System.out.println(completelyEven(new int[] {1, 2, 5}));
    System.out.println(completelyEven(new int[] {0, 2, 4}));

    Next, let’s think about what happens when one of our functions itself calls another function!

    boolean isEven(int value) {
    // Finish me
    }
    boolean completelyEven(int[] values) {
    for (int i = 0; i < values.length; i++) {
    // TODO: Use isEven function
    if (values[i] % 2 != 0) {
    return false;
    }
    }
    return true;
    }
    System.out.println(completelyEven(new int[] {1, 2, 5}));
    System.out.println(completelyEven(new int[] {0, 2, 4}));

    Common Algorithm Patterns
    Common Algorithm Patterns

    Computer scientists and programmers love patterns. Particularly in code. Frequently, once you’ve learned how to do one thing with code, you can modify that skeleton to solve other similar problems.

    Let’s take a concrete example. The following code determines the count of the number of elements in an array. Note that this is not a good way to do this—it’s better to just use array.length. But we can modify this basic template to solve other problems. Let’s see how.

    int arrayLength(int[] values) {
    int len = 0;
    for (int i = 0; i < values.length; i++) {
    len++;
    }
    return len;
    }
    System.out.println(arrayLength({1, 2, 5}));

    Searching arrays produces another common pattern. It’s different from the example above, because we don’t necessarily need to complete the loop. Again, let’s walk through the basic template and then consider how to expand it.

    boolean arrayFindFour(int[] values) {
    for (int i = 0; i < values.length; i++) {
    if (values[i] == 4) {
    return true;
    }
    }
    return false;
    }

    Through the rest of our lessons we’ll continue to point out patterns that emerge in our programming. And ways to modify the basic pattern to produce more interesting designs!

    Method Overloading
    Method Overloading

    Perhaps you noticed something unsettling about the example that starts this lesson:

    void printIt(int count) {
    System.out.println(count);
    }
    void printIt(int first, int second) {
    System.out.println(first + second);
    }
    printIt(10);
    printIt(40, 50);

    Note only do we have two functions with the same name—printIt—but they both work! Distinguish this from variables, where we can never use the same name twice in the same scope:

    // This (still) doesn't work
    int first;
    char first;

    Having multiple methods with the same name is known as method overloading. We don’t use this feature often, but you may see it in other Java code that you work with.

    When two methods have the same name Java must be able to distinguish them from each other when they are used. So, if two methods have the same name, something must be different about them. The walkthrough below describes how Java can tell them apart.

    void printIt(int count) {
    System.out.println(count);
    }
    void printIt(int first, int second) {
    System.out.println(first + second);
    }
    printIt(10);
    printIt(40, 50);

    Solve: Overloaded Multiply (Practice)

    Created By: Geoffrey Challen
    / Version: 2020.9.0

    Write two versions of a function called multiply. The first should take two double arguments and return their product (as a double). The second should take three double arguments and return their product (as a double).

    void Return
    void Return

    If you have been watching carefully, you’ve already seen something new in this lesson: void. When a function doesn’t return a value, you declare it with the void return type. Like this:

    void printCount(int count) {
    System.out.println("The count is " + count);
    }
    printCount(5);
    printCount(8);

    void functions can still use return, but can’t return a value. The result of calling a void function can also not be used in an assignment or statement:

    void printCount(int count) {
    System.out.println("The count is " + count);
    }
    printCount(5);
    printCount(8);

    Solve: Array Is Doubled

    Created By: Geoffrey Challen
    / Version: 2021.8.0

    Write a method called arrayIsDoubled that takes two non-empty int arrays and returns true if they are the same length and if every element of the second array is equal to the element of the first array in the same position, doubled.

    So given {1, 2, 4} and {2, 4, 8}, you would return true, but given {1, 2, 4} and {2, 4} or {1, 2, 4} and {2, 4, 8, 10} you would return false.

    We suggest you approach this problem by looking for a counterexample. First, examine the lengths of the two arrays. If they are different, you can return immediately! Otherwise, loop through each element of the array looking for one that is incorrect. As soon as you find one, you can return. And, once the loop concludes, you can also draw a conclusion.

    More Practice

    Need more practice? Head over to the practice page.