Programming 1, fall 2007 -- Demonstration 4

Where I want everybody to be after demonstration 3:

• You know that a variable is a storage place in which the computer can keep a numerical value. A variable has a name ("Identifier", "symbol"), and in Java it also has a fixed type. How a variable can be used is determined by the semantics (meaning) of the type.
• You are able to declare local variables inside a method body (for example, the main -method of a Java application)
• You are able to write the main method in such a way that it allocates memory for different kinds of variables, and stores the results of mathematical expressions into those by using the assignment operator =.
• You have seen and used two of the common control structures in programming, namely the if structure and the for structure.

So far, all our programs have been of the simplest kind; they have had only one method which is defined as public static void main(String[] args){ /* statements here */ }. The structure of the compilation unit has been the following:

public class TheNameOfYourProgram {
    public static void main(String[] args){

        /* All that we do at first is written here. */

    }
}

Agenda for the next step:

• We must learn the concept of subroutine, which is called method in Java and object-oriented terminology. (Other names for the same thing are at least subprogram and function).

• Some ideas behind the use of subroutines are:

  • Programs need to perform some things on a regular basis, and differences between each occasion are small. Let us not produce new code for every time, but rather re-use one piece of code that does almost the same thing.

• Kinds of subroutines:

  1. the simplest kind of thing to perform in a subroutine is something that is always exactly the same, like printing a user's guide or the program's version number on the console.
  2. subroutine becomes more useful via parameterization: You give some input to the subroutine, and it works differently according to its parameters. For example, you might want to print only one paragraph of a user's manual, depending on a parameter called paragraphToBePrinted
  3. even more useful is a subroutine that computes a new value based on parameters. This kind of a subroutine works much like a mathematical function. Consider the mathematical function "Compute distance of a 2-dimensional coordinate (x,y) from the center of the coordinate system". It gets "x" and "y" as parameters, and it yields "distance" which is computed as "square root of (x^2 + y^2)" every time, regardless of what values the parameters "x" and "y" are given on each time. Terminology: We could say that the subroutine "distance" is called or invoked or activated with specific values to its parameters, "x" and "y", and after computation the subroutine returns what is mathematically defined to be "distance of (x,y) from (0,0)". Parameters and the promise of what is returned is called the interface of the subroutine. In order to use a subroutine/function/method/call-it-whatever, you don't have to know how it is programmed. You just need to know the interface.
  4. It is often wanted that a subroutine has "side effects" that alter the overall state of the program. For these subroutines, you give object references as parameters, and the subroutine may alter the objects.
  5. In object oriented design, we use subroutines that are called methods; their purpose can be any of the above, and usually they also alter the internal, hidden, state of an object, on which they operate. The publically available methods of an object determine the interface of the object. An object belongs to a class of objects; each class has a different interface, but it is the same for all objects of the same class.

In this demonstration, we shall be making programs that have more than one static method. This is how programming is, from now on! The structure could be like this, for example:

public class TheNameOfYourProgram {


    public static void someVerySimpleMethod(){
        /* No parameters, no returns (denoted by 'void') */
    }

    public static int someMethodReturningInt(int param1){
        /* One integer parameter, one integer return.
         * Some computation will be written here.
         * At some point, a return-statement with an expression
         * yielding an integer value is required
         */
    }

    public static double yetAnotherMethod(double p1, int p2){

        /* Computing "a double value as a function of one double and
         * an integer".
         *
         * At some point, a return-statement with an expression
         * yielding a double value is required
         */
    }

    public static void main(String[] args){

        /* We call our methods from here. Here are only
         * some "test cases" to know whether or not our
         * methods are working at the moment.
         */

    }
}

In addition to the concept of subroutine, we take a look at all of the primitive types of Java. We still use only local variables and parameters. We use only two of the control structures: if and for. Later this set must be extended with many others, but we must keep one step as small as possible.

MethodDeclaration =
   {Modifier} ReturnType MethodName "(" FormalParameters ")"
     BodyBlock;

ReturnType = "void" | Type;

FormalParameters =
   Type Identifier {"," Type Identifier};

MethodName = Identifier;

BodyBlock = Block;

calcFahrFromCels(2.0);