ISM 3232 - Intermediate Business Programming. 

Chapter 3 Student Learning Objectives.

You should be able to:

• Explain the purpose of public access methods and their relationship to private instance variables.
• Define and compare "parameter" and "argument."
• Specify formal parameters in a method definition.
• Define "scope" and distinguish between local scope and class scope.
• Explain the role(s) of a constructor method.
• List the components of a method signature.
• Describe the role of the signature in overloading.
• Distinguish between primitive and reference parameters.
• Define and implement stub methods in stepwise refinement.
• Design, implement, and trace simple and multiway selection statements.
• Draw flowcharts to demonstrate selection flow of control.
• Define and demonstrate your understanding of object interfaces, method abstraction, and class inheritance. 

Access Methods

A private variable cannot be accessed by other objects.

• To allow other objects to access CyberPet’s name, we will provide public access methods (sometimes called "set" and "get" methods).

How do we set the values of private variables within an object?

• Provide a method that passes in and sets the value.

How do we get information from an object?

• Invoke a method that retrieves the information.

By convention, many classes define access methods to assign and retrieve the values of selected private variables. This is how the object interacts with other objects. The "set_variable" access method will take a parameter which contains the value of the variable.

A parameter is the formal definition of the how information is passed into a method. A method may have none, one, or more parameters. The parameter list follows the name of the method and is enclosed within parentheses:

MethodModifiers ResultType MethodName (FormalParameterList) MethodBody

Example: public void setName(String str)

Parameter Scope

Scope defines where a variable can be used in a program

• Local Scope: a parameter’s scope is limited to the method in which it is declared
• Class Scope: an instance variable can be accessed anywhere within the class instance.

Drawing boxes around program modules is a good way to visualize scoping rules.

Arguments and Parameters

• Arguments refer to the values that are passed to a method.
• The arguments passed to a method must match the formal parameters of that method.
• Invoking a method involves a method call
• Defining a method involves designing a method definition.
• Qualified names (dot notation), are used to refer to methods within other classes.

Although "parameter" and "argument" are often used interchangeably, we will use parameter to refer to the formal definition, and argument to refer to the actual value that is passed when the method is invoked.

Example of defining vs. invoking:

Parameters and the Generality Principle

• Parameters make methods more general.
• We can use setName(String) to create two CyberPets with different names:

Exercise: Modify the CyberPet and the TestCyberPet classes to add a name variable, and then to set and then retrieve the value. (See pp. 119 and 125 for the solution.)

Constructor Methods

• Are used to create an instance object of a class
• Are used to initialize instance variables to values
• Are defined like other methods, except:
  • have the same name as their class
  • have no return type
• Are defined as public or private
• Do not return a value (thus no return type is declared)
• Are not inherited by subclasses

Examples:

Note:

• no return type (such as "void")
• a class may have more than one constructor method
• the first has no parameters, the second has one
• Java knows which it is based on what parameters are used (if any)

Default Constructors

• If no constructor is coded, Java provides a default constructor.
• In the default constructor, nothing happens except the object is created.
• If a class is public, the default constructor will also be public.

Example:

Constructor Overloading

• As mentioned above, more than one constructor method can be defined for a class. This is called method overloading.
• The difference between them is based on the signature. The signature of a method consists of the name, the return type (for non-constructor methods), and the formal parameters.

Invoking a Constructor Method

A method call (invocation) must exactly match the parameter names, types, and order of the parameters in a method definition. If the compiler can't find a match, it will complain.

Retrieving Information from an Object

• Methods with non-void return types can be used to extract information from an object.
• A method which returns a value may or may not have a formal parameter list.

Now that we know how to create an object and initialize its instance variables, we need to be able to retrieve those values, by defining more methods for the class.

In the case of CyberPet, we need a get_name() method, which will return the current value of the pet's name variable.

In this example, first getName() is defined. Then, 2 pet objects are created. Then we invoke the getName() method and output the value of pet1's name variable.

Click here to view the version of the CyberPet (2) class definition that includes these constructor methods and access methods.

Value vs. Reference

The effect of passing an argument (value) differs, depending on whether the argument is a reference value or a primitive value

• Values of type int, boolean, float, and double are examples of primitive types.
  • A primitive argument cannot be changed by a method call.
• All objects (String, CyberPet) are reference types.
  • Reference arguments can be changed by a method call.

For primitive type parameters, a copy of the argument’s value is passed to the method.

For reference parameters, a reference to an object is passed to the method.

Selection Control in Java: If ...

Review: a selection control structure changes the result based on the evaluation of some condition(s) as TRUE or FALSE. The flow of control in selection looks like the following flowcharts. The flow of control can be one-way, two-way, or multi-way.

This is an example of one-way selection. If the boolean expression evaluates to true, the statement will be executed. Otherwise, it will be skipped.
Two-way selection incorporates "else" - the flow of control goes one of 2 ways depending upon the evaluation of the condition.
Multi-way selection: multiple conditions are checked to determine the flow of control.

Examples:

Note that the compiler ignores indenting. The compiler uses the keywords, the semi-colons, and the brackets to determine the beginning and end of statements and blocks. However, indenting is extremely important for readability.

Boolean Expressions

• Also remember that boolean expressions are expressions that evaluate to either true or false.
• == is the equality operator in Java

Now suppose we want to define a method that returns the current state of the pet, i.e., whether it is eating or sleeping.

Click here to review the version of the CyberPet (3) that includes the getState() method (an example of using If ... Else).

The Dangling Else Problem

• The programmer must be careful to match each else with its corresponding if.
• Rule: An else clause matches with the closest previous unmatched if clause.

• Use brackets to enclose a block of statements, and for readability if needed.

Object Inheritance

See ToString() example, pp. 149-152.

For Review: #1, 3, 5, 7, 10.