Written by John Bell for CS 342, Spring 2018

Transcription

1 Advanced OO Concepts Written by John Bell for CS 342, Spring 2018 Based on chapter 3 of The Object-Oriented Thought Process by Matt Weisfeld, with additional material from other sources.

2 Constructors Constructors are called automatically by the system, whenever space is allocated for a class object, which may occur before main( ) starts. The purpose of a constructor is to initialize the contents of a newly allocated class object. ( They could have been called initializers. Constructors are used to initialize default values of class variables, allocate resources such as files and network connections, etc. Constructors have the same name as their class, and have NO return type, ( not even void ).

3 Chaining Constructors A class may have multiple overloaded constructors, each with different method signatures. A constructor may call upon an overloaded constructor of the same class, generally as a first step before doing any other work. Exactly how this is done is a language-dependent issue. In both Java and C++ the system will automatically call the constructor(s) of the parent class(es), if the programmer does not do so.

4 Default Constructors If the programmer does not provide any constructors at all for a class, then the system will provide a default no-argument constructor. The default constructor provided by the system will call the no-argument constructor(s) for any relevant parent class(es), and will set variables specific to this class to some form of zero ( or null ). A programmer-written no-argument constructor is not the same as a default constructor, though many authors do not make the distinction.

5 Advice: Always Write a Constructor If the programmer does not write a constructor for a class, then the system will use its own default constructor. This can be a problem later if code relies on this, and then the default constructor is no longer available when a different constructor is written. It is best to always write at least one constructor, even if it doesn t do anything ( yet. )

6 Controlling Access Through Private Constructors Singleton private static Singleton theinstance private Singleton( ) {... } public static Singleton getsingleton( ) { if(! theinstance ) theinstance = new Singleton( ) return theinstance }

7 Destructors Destructors are called automatically when space for an object is deallocated, which may occur automatically when an object goes out of scope or is garbage-collected, or even after main( ) exits. Destructors in C++ are named with a ~ and the class name, and are vital for deallocating dynamic memory. Destructors in all languages may log information, close files or network connections, report results, etc. In Java the finalize( ) method inherited from Object acts as a destructor, less commonly used than in C++.

8 Error Handling Four options for handling errors: 1. Ignore the problem and push on. ( NOT recommended! ) 2. Check for problems, and exit if found. 3. Check for problems, and attempt to recover. ( Revert to 1 or 2 if no recovery is possible. ) 4. Throw an Exception. This is generally the preferred approach in OO programming.

9 try - throw - catch Exception handling generally consists of 3 parts: A try block contains code that may throw an exception. A throw statement creates an exception, and passes it to the system. A catch block contains code for handling an exception. When an exception is thrown, the system searches for a suitable catch block for this exception type, ( possibly in a different method ), and transfers control to that block.

10 Exception Types C++ can throw anything. Java can only throw objects of type Exception ( or classes descending from Exception. ) A given try block may have multiple catch blocks, each prepared to catch a different type of exception. When looking for a suitable catch block, the system will favor a more specific catch over a more general one. Catch blocks may re-throw an exception, or throw a totally different kind of exception.

11 Scope in OO Programming Local variables, function parameters, very local variables - Same as in C, static or not. Global variables - In C++, same as in C. Globals don t exist in Java. Ordinary class variables: A separate variable for each instance of the class created. Allocated with new reference to dynamic memory. Otherwise ( C++ only ) stored same as basic types. Ordinary class methods: A reference in each allocated object to single block of shared code.

12 Static Variables Static local variables are stored in a separate static storage area. There is only one copy of each static variable no matter how many ( if any ) copies of the function are running, and it does not go away when the function exits. Static class variables are stored with the static local variables ( and globals in C/C++ ). There is exactly one copy of each static class variable, no matter how many ( if any ) instances of the class have been created.

13 Static Methods Code for static class methods is accessed through a static reference, stored with the static data. Static class methods can be accessed through any instance, or through the class name, whether there are any instances allocated or not. Static class methods only have access to static class data, unless an instance is passed in as an argument. In the latter case, the static methods would have privilege to access the private fields of the passed-in parameters. ( There is no this pointer for static methods. )

14 Operator Overloading Some languages, such as C++, allow programmers to define how operators operate with derived data types. For example: Book b; Chapter c; b += c; cout << b = << b << endl; This can be both powerful and problematic, particularly with conflicting data type conversions or operators used contrary to conventional use.

15 Multiple Inheritance Some languages, such as C++, allow new classes to inherit from multiple parents. Again, this can be both powerful and problematic. Student Worker StudentWorker

16 Problems with Multiple Inheritance Inheriting the same identifier ( field or method name ) from multiple parents, with different types or meanings. Inheriting multiple copies of the same entity ( field or method ) through multiple parents, from a common grandparent Human Student Worker StudentWorker

17 Java Interfaces Java classes may only inherit from a single parent. However Java classes may implement as many Interfaces as they would like. Java Interfaces are similar to abstract classes, with a few differences. Interfaces do not have constructors. Prior to Java 8, Interfaces were purely abstract. Java 8 now allows default and static methods. Static methods cannot be overridden

18 Deep vs. Shallow Copies Book b = new Book( ); Book data Book shallow = b; Book deep = b.clone( ) Book data In C++ the assignment operator ( = ) is often overridden to provide deep copying of class objects.

19