Class Constructors, Java Method Overloading, Exceptions

CIS-260 Home http://www.c-jump.com/bcc/

Class Constructors, Java Method Overloading, Exceptions

Class Constructors, Java Method Overloading, Exceptions
Object Constructors
When is constructor called ?
The new keyword in Java
Inside a Constructor
Default constructor
Multiple Constructors
Method overloading (Java)
Using UML to Model classes
How the super class is constructed
Error handling: Java Exceptions
What is an exception?
Exception Object
try and catch
Exception Demo
Exception UML diagrams

1. Class Constructors, Java Method Overloading, Exceptions

Constructors
Overloading
Exceptions

2. Object Constructors

Constructors are special operations that help to create and initialize objects.
Constructors are similar to
- methods in Java
- member functions in C++.
Compilers recognize that an operation is a constructor by looking at the name:
- If name is the same as the class name, then this is a constructor.
- A significant difference between constructors and other operations is that constructors don't have a return value.

3. When is constructor called ?

Any time when the object is created. For example,


    Planet saturn = new Planet(); // Java code

Memory is allocated before constructor is invoked.
Programmer is responsible for initialization of the object instance.

4. The new keyword in Java

In Java keyword new creates a new instance of an object:


    Planet saturn = new Planet(); // Java code

Empty parentheses in the above code specify that constructor of the Planet class does not take any arguments.
Constructor with no parameters is called default constructor.
Alternatively, constructors could have a list of parameters required to properly initialize the object.

5. Inside a Constructor

One of the most common and rudimentary activities inside a constructor is initialization of the object memory.
That is, initialization of the data member attributes.

When data attributes are added to object implementation, each constructor needs to be updated.


    public class Planet
    {
        int distance;
        int satellites;
        double mass;

        public Planet( int distance, int satellites, double mass )
        {
            this.distance = distance;
            this.satellites = satellites;
            this.mass = mass;
        }
    }

6. Default constructor

The classes get a default constructor provided by Java.
The default constructor initializes
- all primitive numeric attributes to 0
- all object attributes to null.
Often there is no reason to code default constructor because it would have the same functionality as the compiler-provided constructor.
On the other hand, many programmers prefer to code it for documentation purposes anyway.

7. Multiple Constructors

Our objects can be constructed in many different ways.

For example, constructor of the class Planet could take a set of initial parameters, such as

number of satellites,
distance from the Sun,
planet mass.


    int distance = 50000;
    int satellites = 14;
    double mass = 12345.67;
    Planet saturn = new Planet ( satellites, distance, mass );

8. Method overloading (Java)

Method overloading means that the same method name is used over and over again,
but method signature is different every time.
Method signature consists method name and a parameter list.
Method signature does not include the return type.

Java method signature components are as follows:

9. Using UML to Model classes

DataBaseReader class diagram lists two constructors.

Without the parameter list, there is no way to know which constructor is which:


public class DataBaseReader {
    String dbName;
    int startPosition;
    // initialize just the name
    public DataBaseReader (String name){
        dbName = name;
        startPosition = 0;
    }
    // initialize the name and the position
    public DataBaseReader (String name, int pos){
        dbName = name;
        startPosition = pos;
    }
    .. // rest of class
}

Class diagram for the DataBaseReader class:

10. How the super class is constructed

The constructor of super class (a base, a parent class) is invoked when object inherits from the parent class.
When instance of an object is allocated by new keyword, the following steps occur:
1. Constructor of the Parent is invoked.
2. If no explicit call to a parent constructor of the super class is provided by the programmer, the default constructor of the super class is invoked automatically.
```
    public class GasGiant extends Planet
    {
        public GasGiant()
        {
            // Explicit call to a parent constructor:
            super();
        }
    }
```
3. Each attribute of the object is initialized.
4. The rest of the constructor code is executed.

11. Error handling: Java Exceptions

Many things can go wrong at run-time.
It would be nice to have a universal mechanism to handle various kinds of errors without degenerative modifications to the public interface.
Most OO programming languages support a feature called exception mechanism.

12. What is an exception?

An indication of an unusual situation, such as a failure during execution:
- division by zero
- memory access violation
- array out of bounds
- etc.
Exception aborts the normal flow of control and causes a search for an exception handler.

13. Exception Object

Exception is an object encapsulating information about exception.
Flow of events goes like this:
1. Exception (error) occurs.
2. Execution of the current operation is abandoned.
3. Exception object is constructed and initialized with parameters describing the error.
4. A search for exception handler is performed.
5. Each exception handler designates an exception type that it handles.
6. Exception handler is executed.
7. Upon completion of exception handler, normal execution is restored.

14. try and catch

If exception propagates to the root of the application, the system architect has probably done a poor job of design and the program will probably crash.

To use exceptions, programmers need to write special blocks of code designated by the keywords try and catch:


    try {
        // possible nasty code
    } catch(Exception e) {
        // code to handle the exception
    }

See also: C++ Exceptions

15. Exception Demo

Create folder
```
    C:\CIS123
```
Download file Banking.zip into that folder.
Unzip downloaded file.
The resulting folder structure should be:
```
    C:\CIS123\Banking
```

Execute commands found in file commands.txt:

"C:\Program Files\Java\jdk1.6.0_06\bin\javac.exe" C:\CIS123\Banking\*.java
"C:\Program Files\Java\jdk1.6.0_06\bin\java.exe" -classpath "C:\CIS123\Banking" BankingMain

Note: you may need to adjust the path

    C:\Program Files\Java\jdk1.6.0_06

to point to the correct version of Java utilities installed on your system.

16. Exception UML diagrams

Exception raised by activity:	Exception handler on activity:
Exception handlers on computation example: