java基础之继承和多态概念

java基础之继承和多态概念

Inheritance

Inheritance is a reusability mechanism
in object-oriented programming. With inheritance, the common

properties of various objects are exploited to form relationships with each other. The abstract and common

properties are provided in the superclass, which is available to the more specialized subclasses. For example,

a color printer and a black-and-white printer are kinds of a printer (single inheritance); an all-in-one printer

is a printer, scanner, and photocopier (multiple inheritance).

Why is inheritance a powerful feature? Because it supports modeling classes in a hierarchy, and such

hierarchical models are easy to understand. For example, you can logically categorize vehicles as two-wheelers, three-wheelers, four-wheelers, and so on. In the four-wheelers category, there are cars, vans,

buses, and trucks. In the cars category, there are hatchbacks, sedans, and SUVs. When you categorize

hierarchically, it becomes easy to understand, model, and write programs.

Polymorphism

The Greek roots of the term polymorphism refer to the “several forms” of an entity. In the real world,

every message you communicate has a context. Depending on the context, the meaning of the message may

change and so may the response to the message. Similarly in OOP, a message can be interpreted in multiple


ways (polymorphism), depending on the object.

Polymorphism can be of two forms: dynamic and static.

• When different forms of a single entity are resolved duringruntime (late binding),

such polymorphism is called dynamic polymorphism. In the previous section

on inheritance, we discussed overriding. Overriding is an example of runtime


polymorphism.

• When different forms of a single entity are resolved atcompile time (early binding),

such polymorphism is called static polymorphism. Function overloading is an


example of static polymorphism.

Please note that abstract methods use runtime polymorphism.

Runtime Polymorphism

You just learned that a base class reference can refer to a derived class object. You can invoke methods from

the base class reference; however, the actual method invocation depends on the dynamic type of the object

pointed to by the base class reference. The type of the base class reference is known as the static type of the

object and the actual object pointed by the reference at runtime is known as the dynamic type of the object.

When the compiler sees the invocation of a method from a base class reference and if the method

is an overridable method (a nonstatic and nonfinal method), the compiler defers determining the exact

method to be called to runtime (late binding). At runtime, based on the actual dynamic type of the object, an

appropriate method is invoked. This mechanism is known as dynamic method resolution or dynamic method

invocation.

Now, let’s ask a more fundamental question: Why do you need to override methods? In OOP, the

fundamental idea in inheritance is to provide a default or common functionality in the base class; the

derived classes are expected to provide more specific functionality.

Method Overloading

In a class, how many methods can you define with the same name? Many! In Java, you can define multiple

methods with the same name, provided the argument lists differ from each other. In other words, if you

provide different types of arguments, different numbers of arguments, or both, then you can define multiple

methods with the same name. This feature is called method overloading. The compiler will resolve the call to

a correct method depending on the actual number and/or types of the passed parameters.

Such overloaded methods are useful for avoiding repeating the same code in different functions.

Constructor Overloading

A default constructor is useful for creating objects with a default initialization value. When you want to

initialize the objects with different values in different instantiations, you can pass them as the arguments to

constructors. And yes, you can have multiple constructors in a class, which is constructor overloading. In a

class, the default constructor can initialize the object with default initial values, while another constructor

can accept arguments that need to be used for object instantiation. You can

used the this keyword (which refers to the current object) to call one constructor from another constructor

of the same class.

Points to Remember

Here are some interesting rules regarding method overloading :

• Overload resolution takes place entirely at compile time (not at runtime).

• You cannot overload methods with the methods differing in return types alone.

• You cannot overload methods with the methods differing in exception specifications alone.

• For overload resolution to succeed, you need to define methods such that the

compiler finds one exact match. If the compiler finds no matches for your call or

if the matching is ambiguous, the overload resolution fails and the compiler issues

an error.

The signature of a method is made up of the method name, number of arguments, and types of

arguments. You can overload methods with same name but with different signatures. since return type and

exception specification are not part of the signature, you cannot overload methods based on return type or

exception specification alone.

Invoking Superclass Methods

It is often useful to call the base class method inside the overridden method. To do that, you can use the

super keyword. In derived class constructors, you can call the base class constructor using the super

keyword. Such a call should be the first statement in a constructor if it is used. You can use the super

keyword for referring to the base class members also. In those cases, it need not be the first statement in the

method body.

if you’re using an object in containers like HashSet or HashMap, make sure you override the hashCode()

and equals() methods correctly. if you don’t, you’ll get nasty surprises (bugs) while using these containers!

Okay, how do you override the hashCode() method? In the ideal case, the hashCode() method should

return unique hash codes for different objects.

The hashCode() method should return the same hash value if the equals() method returns true. What

if the objects are different (so that the equals() method returns false)? It is better (although not required) for

the hashCode() to return different values if the objects are different. The reason is that it is difficult to write a

hashCode() method that gives unique value for every different object.

The methods hashCode() and equals() need to be consistent for a class. For practical purposes, ensure

that you follow this one rule: the hashCode() method should return the same hash value for two objects if the

equals() method returns true for them.

读书笔记：

Oracle Certified Professional Java SE 8 Programmer Exam 1Z0-809: A Comprehensive

OCPJP 8 Certification Guide

Copyright © 2016 by S G Ganesh, Hari Kiran, and Tushar Sharma

ISBN-13 (pbk): 978-1-4842-1835-8

ISBN-13 (electronic): 978-1-4842-1836-5