Intermediate Programming (download pdf)

Students will be able to:

Object-oriented programming languages, such as Java are organized around objects, instead of actions. An object represents an entity in the real world, such as a car, a home, a person, etc. Each object has state, represented by its data fields or attributes and behavior represented by methods. Objects of the same type are defined using a class. A class is considered to be a blueprint for the objects that it represents. Each class can have many objects, also referred to as instances.

For example, consider a Person class. Each person can have data: name, age, eyeColor. Each person can also perform the following actions or behaviors: walk, talk. Class Person defines the state and behavior that is common to all objects that belong to it. Examples of objects or instances of class Person include, specific persons, such as person1, person2, person3, etc. Each of these persons will have a value for name, height and eyeColor. The values can be different for each object. Each of these persons also have the ability to perform actions walk and talk. See the figure.

More details about classes are available here.

Below you can see sample code for creating a class to model a square:

The above code creates a blueprint for all Squares. All objects of class Square will have attribute length. And they all have the ability to perform actions defined by each of the methods. Below is an example of a tester class, used to test the Square class. The tester class will have a main() method and can be used to create objects of class Square. These objects can then perform actions by invoking the methods defined in the business class, Square.

In the statement: Square square1 = new Square(); an object of class Square is being created. A class is basically a data type defined by a programmer. Instead of a primitive data type (e.g. int, double, boolean, and char), a class is a reference type. It is going to hold a reference to an object. We can think of a reference to an object as the “address” of the object. Through the reference, the Java runtime system - Java Virtual Machine (JVM) – can locate where the object is located in memory.

In the example, square1 is a variable of this reference type and is referred to as a reference variable. The new operator creates a Square object. The address of the object is assigned to the reference variable square1.

A variable represents a named memory location that stores a value. When we declare a variable, we specify what type of variable it is. Whether a variable is primitive or reference type decides how that variable is stored in the memory. For example, if we write the following statement: int age = 5; then 4 bytes of memory is allocated for age and the value of 5 is stored in it. This memory is referred to as age. Whereas, if we write the following statement:

Square square1 = new Square();

square1 does not directly store the value of a square, as age does. Instead, memory is allocated for object of reference type Square and square1 (reference variable) then references that object. Instead of holding the object itself, square1 holds the information necessary (reference or memory location) to find the object in memory. See image below.

This difference in how memory is allocated for primitive and reference variables impacts assignment statements. For example, if we consider the following statements:

then we know that after those three statements execute, age1 loses the original value of 40 and gets the value of 18. The memory allocation before and after looks as shown below.

In this scenario, both variables are at the same memory location as before. Value of age1 has changed. Now consider a similar scenario with objects.

Here, square1 and square2 are reference variables that hold a reference to the actual Square objects. So, when we assign one reference variable to another, the references get assigned, not the values. See the image below.

Notice that the length values for each square object remain at their original memory locations. They do not get copied over. The reference of square2 however, gets assigned to reference varaible square1. This means square1 no longer references the object with length 10.5. It now references the object of length 5.2.

Java Virtual Machine (JVM) divides the memory into two types, the stack and the heap. The stack memory is used to store local variables of primitive type and reference variables. On the other hand, heap stores the actual objects. Stack memory is used for static memory allocation and is accessed in a First In Last Out manner. Every time a method is called, stack memory is allocated to store the primitive and reference variables. When the method finishes execution, its memory is released, control goes back to the calling method and stack memory is now available for other methods. This video demonstrates this idea. Heap memory on the other hand is dynamically allocated at runtime. It stores the objects themselves. So, in the above example, reference variables square1 and square2 would be stored in the stack, whereas the objects that they refer to would be stored on the heap. This video demonstrates how heap memory works.

The memory illustration that includes the stack and heap for the previous example are as follows before and after the assignment statement is executed.

Objects can be passed as arguments to methods, similar to primitive type variables. When objects are passed to methods, the references of the objects are passed as shown in this video. Because of the difference between primitive and reference type variables, passing objects/primitive types to methods results in different behavior. Compare the example in the above linked video to the example shown in this video. Notice how when a primitive type variable is passed to a method, the value of variable x in the main() method does not change. Whereas, when an object is passed as an argument to a method, the value of both attributes of object person1 are changed.

Returning objects from methods, also involves returning the reference of the object. To see an example of this, let’s add a new method to our Square class created above. This method looks as shown below:

This method creates a new object of class Square with length value of 100 and returns this newly created object. Here, it does not actually return a copy of the newly created object, rather it returns the reference of the newly created object. To test this new method, in the tester method, we will invoke the getSquare() method as shown below:

The statement Square square2 = square1.getSquare(); invokes method getSquare() on reference variable square1. This creates a new object with length 100, as defined in the getSquare() method and a reference to that new object is returned. This is depicted in the image below:

This returned object, or rather reference is then assigned to square2. The result of that is shown below.

So, when square2 is printed, the results should be calculated accoridng to 100 as the length of the square. These results of both square1 and square2 are shown below.

Behavior: actions of an object; represented by the methods of an object.

Class: a blueprint that defines an object.

Heap memory: dynamically allocated memory used to store objects.

Object/Instance: represents an entity in the real world and has state and behavior.

Object-oriented programming: a way of organizing code around objects, instead of actions.

Reference: memory address of where the object is located.

Reference type: a class; variable of this type can reference an object of a class.

Reference variable: variable of a class type, which contains a reference to the object of that class.

Stack memory: stores local variables of primitive type and reference variables; memory is accessed in First In Last Out order.

State: represented by data fields or attributes of the object.

Students will be able to:

From previous chapters and open source textbook, you learned how to define classes for objects. First, the body of a class declares members (fields and methods), instance and static initializers, and constructors. Regarding the scope of a member, it is the entire body of the declaration of the class to which the member belongs. Field, method, member class, member interface (you will learn soon) and constructor declarations may include the access modifiers such as public, protected, private or default.

In this chapter, we will explore object-oriented program design, class relationship and inheritance. You will learn how member of a class includes both declared and inherited members in terms of encapsulation and inheritance. It means that you will learn how the newly declared fields can hide fields declared in a superclass, newly declared class member can hide class or interface members declared in a superclass, and newly declared methods can hide, implement, or override methods declared in a superclass. (source: The Java Language Specification by James Gosling, Bill Joy, Guy Steele, Gilad Brach, Alex Bucklely)

Object oriented programming is associated with the concepts of class, object, inheritance, encapsulation, abstraction, polymorphism. In previous chapter, you learned about classes, and objects. The focus of this chapter is to explore object-oriented programming.

To design classes, Association, Aggregation, Composition, and Inheritance are four points we use to discuss the relationships among classes.

Inheritance is a powerful mechanism that allows you to define new classes from an existing class. The existing class is a more general class, called a superclass. A superclass is also referred to as a parent class or a base class. The Java inheritance allows a Java class to inherit from a single superclass. Only singular inheritance is allowed.

The new classes are specialized cases of the superclass. They are called subclasses of that super class. A subclass automatically inherits all the instance variables methods from its superclass. It may define its own new variables and methods. It may also override any inherited methods. It means that the method has the same method signature in both the superclass and subclass. It means to provide a new implementation for that method in the subclass.

The subclass and its superclass form a is-a relationship. See the diagram of a superclass called Vehicle and two subclasses called Car and Truck, Car is a Vehicle and Truck is a Vehicle. In other words, Car class inherits all accessible data fields and methods from the Vehicle class and the Truck class inherits all accessible data fields and methods from the Vehicle class. In UML, an arrow points from a subclass to its superclass.

According to David A. Taylor in his book Object-Oriented Technology, he mentioned that the object-oriented approach is more natual. For example,"the basic building block out of which all living things are composed is the cell. Cells are organic package that, like objects, combine related information and behavior. Most of the information is contained in protein molecules within the nucleus of the cell. The behavior, which may range from energy conversion to movement, is carried out by structure outside the nucleus.” He also explained about the hierarchy of cell types as you see the inheriting cell diagram. "The cell is truly universal building block. All cells share a common structure and operate according to the same basic principles. Within this basic structure, plant cells have a hard outer wall to make them ridgid, blood cells are mobile and specialized to transport gases, muscle cells are able to distort their shape to perform mechanical work."

Access specifiers: private, default, protected, and public.

Association: a general binary relation between two separate classes. For example, a student taking a course is an association between the Student class and the Course class.

Aggregation: an association when one object uses another object.

Composition: an association when one object owns other class and other class cannot meaningfully exist. Composition is stronger than aggregation.

Default access specifier (no modifier): accessible within the same package.

Inheritance: a mechanism to define new classes from existing classes. In java, classes can inherit the properties and methods of superclass.

private access specifier: acceessible within the class where defined.

protected access specifier: accessible to class

public access specifier: accessible from subclasses and members of the same package.

Overriding method:When a method in a subclass has the same name, same parameters or signature, and same return types(or sub-type) as a method in its superclass.

Overloading method: a class is allowed to have more than one method having the same name as long as their parameter lists are different.

Superclass (a parent class or a base class): a general class which a method(s) to a subclass. Or the class being inherited from.

Subclass (child): The derived class that is derived from superclass.

Liang, D. (2018). Introduction to Java: Programming and Data Structures (11th ed.). Pearson Taylor, D.A. (1981). Object-Oriented Technology: A Manager’s Guide.Servio

Students will be able to:

From the previous chapter, you have learned that inheritance is a very powerful tool that a programmer can use to create a child class from a parent class. Instead of defining a class from scratch, the child class will inherit all the attributes and methods from the parent class. The child class can declare its own additional attributes and methods and override the definition for an inherited method. Through inheritance, we can build a hierarchy of related classes.

In this chapter, we will learn several concepts, mainly through examples. Before we start our journey in this chapter, here is a brief overview of these concepts.

Because of inheritance, a reference variable could refer to objects that belong to any of its subclasses. This is called polymorphism. Polymorphism can be utilized to make programming more convenient. For example, you are programming a computer game that contains various characters. The characters belong to several different classes and these classes have a common super class. Instead of using different arrays, each for characters belonging to a specific class, polymorphism will allow you to store all the characters in one array. You can also use a loop to process all these characters (such as moving each character to its next location) instead of using separate loops for each type of characters. In addition, one method can be used to process characters belonging to different classes. This helps avoid defining multiple methods that do the same things with the only difference being the data type of one or more parameters (method overloading).

Abstract class is a way to define a super class that leaves some methods undefined. These methods are called abstract methods. These methods contain just method headers and have no method bodies. They will need to be overridden in a concrete (non-abstract) subclass. For example, if we write a game program which contains a super class Character and subclasses Dog, Cat, and Bird, we may decide that Dog, Cat and Bird objects should be able to execute a walk method, which calculates how to animate a character when it walks. It is possible to implement the method in all the subclasses using the knowledge we have regarding how dogs, cats and birds walk. However, for the super class Character, there is really no meaningful implementation for the walk method. We could make Character an abstract class and mark the walk method abstract. This eliminates unnecessary code in the super class and at the same time guarantee that all the non-abstract subclasses implement the method.

Interface is another mechanism to enable polymorphism. It is parallel to the class inheritance mechanism. Instead of containing attributes and methods, an interface contains only abstract methods. A class can implement an interface by providing definitions for the abstract methods contained in the interface. A variable of an interface type can be used to hold references to objects of any classes that implement the interface. This allows even more flexible polymorphism than that is enabled by the inheritance relationships.

In this section, we will first learn what is dynamic binding and polymorphism and then understand why polymorphism is a powerful tool to make it easy to manage objects belonging to different classes.

We will introduce abstract class with a concrete example. We will write a computer game and the game includes different shapes, such as circles, rectangles, etc. In order to prevent the game space from getting too crowded, the program needs to know the total area occupied by the shapes. As just stated from the previous section, in order to manage all these different shapes in a systematic manner, it is good to connect all these shapes with a common superclass. The following is the UML for this application.

The following is the superclass Shape. The class might contain other attributes, such as x and y coordinates and speeds along x and y directions, but we will skip them to make the example just adequate to introduce the new concept.

You will notice a couple of new things in the above class definition. On the class header, there is a new key word abstract. This key word also shows up in the method area, which has no method body. Remember that Shape is the super class for different concrete shapes. Since the class Shape does not represent a concrete shape, there is really no way to calculate the area. We use the key word abstract to represent that the method is not implemented on purpose. As long as there is one abstract method, the class header must include the keyword abstract to mark the class as abstract. If a class is abstract, you cannot instantiate the class, that is, you cannot create an object (an instance) of this class.

You might be wondering that if the method area cannot be implemented in the Shape class, why do we include the method at all? Without it, the Shape class could be just normal non-abstract class. To understand the purpose of an abstract class, let us look at the following definition for the subclass Circle. Note that we do not want Circle to be an abstract class, since we will need to create Circle objects in the game. That is why we do not include the keyword abstract on the class header.

You will notice that there is no method definition for area in the Circle class. In an IDE such as Eclipse or IntelliJ, you will see a compile error at the class header. See the following image:

As shown above, the compiler reports an error if an abstract method is not overridden with an actual implementation by a non-abstract class. This is the reason for including the abstract method area in the super class Shape. It "forces" all non-abstract subclasses to provide an actual definition for the method.

If you click on the first quick fix, you will get a method stub for overriding the method area as shown by the last method in the following code:

We will replace the auto-generated stub for method area with the following actual implementation.

The following is the class definition for another subclass Rectangle. We will skip other shapes (e.g. triangle) to prevent the example taking up too much space but still adequate for introducing the concept.

The syntax for defining an interface is very similar to that for defining a class. Interface contains only public abstract method(s). It does not contain any attributes and therefore does not contain any constructors (nothing to initialize). The following is the interface definition for Comparable (included in the standard Java library https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Comparable.html). We can see that instead of class, the keyword on the header is interface. For method(s), the keywords public and abstract are skipped, since all methods are public and abstract.

Comparing Abstract Classes and Interfaces: You may say that Interface is really a special abstract class that only contains abstract methods. In fact, this is not correct. The interface mechanism is really "in parallel" with the class inheritance mechanism. It is meant for a class to "implement" the methods. A class can extend a super class or implement an interface. It can also extend a super class and implements an interface at the same time. An abstract class is still a class. That is, it is with the class inheritance mechanism that is "in parallel" with the interface implementation mechanism.

For example, the following class implements Comparable. To implement an interface, (1) the class should be marked on the header as "implements the interface" and (2) the abstract methods in the interface will need to be overridden, otherwise they are "inherited" as is as abstract methods.

You can see that this is the same Circle class as the last section, but with two things added:

We could do the same for the Rectangle class by making it implement the Comparable interface:

Both the Circle and Rectangle classes have no compilation errors. You can see that a class can extend a super class and implement an interface at the same time. A class can only extend one super-class, however, a class can implement more than one interface, which we will talk about later.

Now let’s look at the following program, which intends to use the compareTo methods in Circle and Rectangle to determine the shape with the maximum area. Unfortunately, it contains a compile error.

There is an error for p.compareTo(maxShape), since the variable p's type is Shape and there is no compareTo method defined in the Shape class. This is a similar error as the one we see in the experiment for abstract class. The super class Shape needs to contain the method in order for the above code to be compiled.

To fix this problem, we will implement the compareTo method in the Shape class, instead of in the Circle class and the Rectangle class. This way, we only need to implement the method once and it will be inherited by all the subclasses (Circle and Rectangle). We will keep the Circle and Rectangle classes the same as the previous section (without the compareTo method). See below for the new Shape class.

The following is the UML that captures the relationship among the classes and the interface in Example 5. The dotted line arrow represents the implementation relationship.

When you run MaxShape, the program will display the following:

Let us look at the Shape class more carefully. You will see that the method area is abstract. You might wonder whether it is OK for the compareTo method to invoke the area method. It is OK because an abstract class cannot be instantiated. The abstract method area will be overridden by the subclasses Circle and Rectangle and the compareTo method will be inherited by the subclasses Circle and Rectangle. In the loop (line 11-16) in the main method, variables p and maxShape are bound to either a Circle or Rectangle object at any point during execution. The inherited method compareTo will invoke the proper area method defined in either Circle or Rectangle.

This really shows another advantage of using abstract classes. It holds concrete methods that can be implemented so that the sub-classes do not have to implement them and can inherit them as they are. It can also hold abstract methods that it cannot implement but will "force" all the non-abstract subclasses to implement their own version.

Polymorphism can be used to connect different classes through a common super class or a common interface they implement, allowing objects belonging to different classes to be stored and processed systematically.

Dynamic Binding: In dynamic binding, the method call is bonded to the method body at runtime. This is also known as late binding.

Polymorphism: Polymorphism means that a reference variable can hold references to different types of objects. For example, a reference variable could refer to objects that belong to any of its subclasses. A reference variable can also hold references to objects belonging to different classes that implement the same interface.

Abstract Method: An abstract method is a method that is declared but contains no implementation.

Non-instantiable: A class is non-instantiable if objects of that class can be created.

Abstract Class: A class that contains abstract methods is an abstract class. The class header of an abstract class needs to contain the keyword abstract. Abstract classes may not be instantiated and require subclasses to provide implementations for the abstract methods.

Interface: An interface contains no attributes but only public abstract methods. An interface cannot be instantiated.

Interface Implementation: A class implements an interface by providing implementations of at least one of the abstract methods contained in the interface.

Interface Inheritance: There is also inheritance relationship among interfaces, just like among classes.

Dynamic Binding: In dynamic binding, the method call is bonded to the method body at runtime. This is also known as late binding.

Polymorphism: Polymorphism means that a reference variable can hold references to different types of objects. For example, a reference variable could refer to objects that belong to any of its subclasses. A reference variable can also hold references to objects belonging to different classes that implement the same interface.

Abstract Method: An abstract method is a method that is declared, but contains no implementation.

Non-instantiable: A class is non-instantiable if objects of that class can be created.

Abstract Class: A class that contains abstract methods is an abstract class. The class header of an abstract class needs to contain the keyword abstrast. Abstract classes may not be instantiated, and require subclasses to provide implementations for the abstract methods.

Interface: An interface contains no attributes but only public abstract methods. An interface cannot be instantiated.

Interface Implementation: A class implments an interface by providing implementations of at least one of the abstract methods contained in the interface.

Interface Inheritance: There is also inheritance relationship among interfaces, just like among classes.

When running your program, it is not uncommon to run into problems which cause the program to terminate or stop running. When these types of errors are detected in Java programs, the run-time environment creates an object known as an exception. Another definition for an exception is a run-time error that causes a program to crash. The name also implies that it is a situation that is not normal execution. The Java API contains a set of classes used as templates for the objects created when the errors are detected. In the package java.lang, these classes are sometimes called the exception classes. In an ideal world, no program would encounter exceptions. However, we don’t live in an ideal world so the Java language contains statements and constructs that allow us to "handle" exceptions when they occur. Handling an exception means that the program contains code to either correct an exception or provide an alternative to allowing the program to crash. Exceptions can be caused by errors generated by external inputs or simply a bad program design. Java uses the term "throw" to describe what happens when an exception occurs. The run-time environment is said to throw an exception when it occurs. What is actually happening is that the run-time environment is gathering information about the type of error that occurred and the line at which it occurred and storing that information into an object that is derived from the Java exception classes. The programmer can also include code which allows for an exception to be thrown by the program itself under certain circumstances. An unhandled exception will cause the running programming to terminate and print a stack trace. To help prevent this, the programmer can include try/catch blocks which allow the programmer to provide an alternate choice to ending the program. This is known as "handling" the exception. In addition, it is possible to write code which creates, throws and handles custom exceptions which inherit from the API provided exception classes. This chapter describes common Java API exceptions, how to programmatically throw exceptions, how to handle exceptions and how to create your own customized exceptions.

The idea of handling problems during execution has been a part of programming since there has been programming. However, Java was one of the first languages to provide special statements for the handling of these exceptional problems. Some common errors that generate exceptions are divide by zero errors and array index out of bounds. A pseudocode solution to prevent this error without special statements is shown below.

This traditional approach incorporates the handling of the error into the normal execution of the code. Java has incorporated an exception-handling model into the code itself. In the case of a divide-by-zero error occurring without exception handling code, the run-time environment detects the error and aborts the program. Then it prints a stack trace. An example stack trace for a divide-by-zero error is shown below.

As you can see, the stack trace first describes the exception that occurs and then lists the call stack ending with the line number and method name where the exception occurs. In this case, the error occurred in the main method of the java file DivideException.java on line 10. The stack trace is intended to help the programmer debug the problem and is not considered a very good error message for a casual user.

The act of detecting the error and causing the program to abort by default is known as "throwing" the exception. The exception shown - java.lang.ArithmeticException - is one of many provided in the Java API. Each exception is a class in the Java library. The diagram below shows a UML diagram of the exception classes in the Java library. As you can see in the diagram, all the Exceptions inherit from the class Throwable.

The exception classes are divided into checked and unchecked exceptions. The unchecked exceptions inherit from the class RunTimeException. Unchecked means that the compiler will not require exception handling code around a statement that has the potential to thrown an exception. Divide by zero is an example of an unchecked exception. If it were checked, every division statement would need to have exception handling code. Unchecked exceptions are typically conditions that the program can not anticipate or recover from. Many of these are indications of a logic error in the code that should be corrected by changing the code. For example, passing an object reference variable to a method before it is initialized will result in a NullPointerException being generated. The programmer should make sure that the reference variable is intialized before using it. Checked exceptions are conditions that a well-written program should anticipate and plan for. Many of the checked exceptions involve file processing and are used prominantly in the next chapter on file processing. A call to a method that is capable of throwing an exceptions will receive compiler errors if it does not use exception handling code. Custom designed exception can be either checked or unchecked depending upon which parent exception class they inherit from.

Exception handling code can be looked at as having three types of operations. *Declaring an exception *Throwing an exception *Catching an exception

When a method throws a checked exception or calls another method that does, the compiler will not compile the code unless the exception is either thrown or handled. To handle the exception, the method must contain a try/catch block as described in the previous section. Throwing an exception passes the burden of handling it to the calling method. If this is the main() method, there is no calling method and the exception causes program termination. To throw an exception, the method must use the key word throws in the method header.

It is possible to create and throw customized exceptions for a program. To do this, the first step is to create the custom exception. An exception is a Java class and it must inherit from one of the existing Java Exception classes from the Java API.

Once the custom exception class is created and compiled, your program can then explicitly cause that exception to happen.

A common use of exception handling is to make sure that the user enters the type of data desired when reading from the console. When using Scanner objects to read user input, a String input when requesting a numeric input can generate an InputMismatchException causing the program to abruptly terminate. Exception handling can prevent the termination and allow the user to try again. The following example asks the user to enter 4 numbers and then computes the average. The first version has no exception handling and if a letter is entered instead of a number- the program will throw an exception and terminate- download it and try!

Now let us look at an example with exception handling that simply ignores the exception.