Polymorphism
- The polymorphic method call allows one type to express its distinction from another, similar type, as long as they’re both derived from the same base type.
Upcasting revisited
- Taking an object reference and treating it as a reference to its base type is called upcasting.
Forgetting the object type
- The compiler won’t give you any error messages if you forget to overload one of your methods and the whole process of working with types becomes unmanageable.
- Wouldn’t it be nice if you could forget that there are derived classes, and write your code to talk only to the base class?
The twist
Method-call binding
- Connecting a method call to a method body is called binding.
- When binding is performed before the program is run (by the compiler and linker, if there is one), it’s called early binding.
- late binding means that the binding occurs at run time, based on the type of object.
- There must be some mechanism to determine the type of the object at run time and to call the appropriate method.
- All method binding in Java uses late binding unless the method is static or final(private methods are implicitly final).
- Declaring a method final effectively “turns off” dynamic binding, or rather it tells the compiler that dynamic binding isn’t necessary.
Producing the right behavior
- Once you know that all method binding in Java happens polymorphically via late binding, you can write your code to talk to the base class and know that all the derived-class cases will work correctly using the same code.
Extensibility
- You can add new functionality by inheriting new data types from the common base class.
- Changes in your code don’t cause damage to parts of the program that should not be affected.
- Polymorphism is an important technique for the programmer to “separate the things that change from the things that stay the same.”
Pitfall: “overriding” private methods
- A private method is automatically final, and is also hidden from the derived class.
- Only non-private methods may be overridden.
- You should watch out for the appearance of overriding private methods, which generates no compiler warnings.
- You should use a different name from a private base-class method in your derived class.
Pitfall: fields and static methods
- Only ordinary method calls can be polymorphic.
- Any field accesses are resolved by the compiler, and are thus not polymorphic.
- If a method is static, it doesn’t behave polymorphically.
Constructors and polymorphism
- Constructors are not polymorphic (they’re actually static methods, but the static declaration is implicit).
Order of constructor calls
A constructor for the base class is always called during the construction process for a derived class.
The constructor has a special job: to see that the object is built properly.
Only the base-class constructor has the proper knowledge and access to initialize its own elements.
It’s essential that all constructors get called; otherwise the entire object wouldn’t be constructed.
It will silently call the default constructor if you don’t explicitly call a base-class constructor in the derived-class constructor body.
-
The order of constructor calls:
1.The base-class constructor is called.
2.Member initializers are called.
3.The body of the derived-class constructor is called. You must be able to assume that all the members of the base class are valid when you’re in the derived class.
Inside the constructor, however, you must be able to assume that all members that you use have been built.
The only way to guarantee this is for the base-class constructor to be called first. Then when you’re in the derived-class constructor, all the members you can access in the base class have been initialized.
Whenever possible, you should initialize all member objects at their point of definition in the class.
Inheritance and cleanup
- Most of the time you won’t have to worry about cleaning up.
- The order of disposal should be the reverse of the order of initialization, in case one subobject is dependent on another.
- This technique(reference counting) requires extra diligence to use, but if you are sharing objects that require cleanup you don’t have much choice.
Behavior of polymorphic methods inside constructors
- If you call a dynamically-bound method inside a constructor, the overridden definition for that method is used.
- The effect of this call can be rather unexpected because the overridden method will be called before the object is fully constructed.
- If the constructor is only one step in building an object of a class that’s been derived from that constructor’s class, the derived parts have not yet been initialized at the time that the current constructor is being called.
- In actual initialization, the storage allocated for the object is initialized to binary zero before anything else happens.
- Do as little as possible to set the object into a good state, and if you can possibly avoid it, don’t call any other methods in this class.
- The only safe methods to call inside a constructor are those that are final in the base class.
Covariant return types
- An overridden method in a derived class can return a type derived from the type returned by the base-class method.
Designing with inheritance
- It’s possible to dynamically choose a type (and thus behavior) when using composition, whereas inheritance requires an exact type to be known at compile time.
- You can’t decide to inherit differently at run time; that must be completely determined at compile time.
- Use inheritance to express differences in behavior, and fields to express variations in state.
Substitution vs. extension
- pure substitution： derived class objects can be perfectly substituted for the base class.
- The base class can receive any message you can send to the derived class because the two have exactly the same interface.
- “is-like-a” relationship: the derived class is like the base class—it has the same fundamental interface—but it
has other features that require additional methods to implement. - The extended part of the interface in the derived class is not available from the base class, so once you upcast, you can’t call the new methods.
Downcasting and runtime type information
- With a downcast, you don’t really know that a shape (for example) is actually a circle.
- In Java, every cast is checked!
- This act of checking types at run time is called runtime type identification (RTTI).
- You can try to downcast. If it’s the correct type, it will be successful. Otherwise, you’ll get a ClassCastException.