Object Oriented Programming

plumponionchipsΛογισμικό & κατασκευή λογ/κού

18 Νοε 2013 (πριν από 3 χρόνια και 11 μήνες)

105 εμφανίσεις


Method Overriding


Abstract Classes


3 uses of Final



When a method of a sub
-
class has the same
name and type as a method of the super
-
class, we
say that this method is overridden.


When an overridden method is called from within
the sub
-
class:


it will always refer to the sub
-
class method


super
-
class method is hidden




When show() is invoked on an object of type B,
the version of show() defined in B is used:







The version of show() in A is hidden through
overriding.


The hidden super
-
class method may be invoked
using super:









The super
-
class version of show() is called within
the sub
-
class’s version.


Method overriding occurs only when the names
and types of the two methods (super
-
class and
sub
-
class methods) are identical.


If not identical, the two methods are simply
overloaded:


The show() method in B takes a String parameter,
while the show() method in A takes no parameters:


The two invocations of show() are resolved
through the number of arguments (zero versus
one):


Overriding is the basis for dynamic method dispatch


a
call to an overridden method is resolved at run
-
time,
rather than compile
-
time.


Method overriding allows for dynamic method
invocation:


an overridden method is called through the super
-
class
variable


Java determines which version of that method to execute
based on the type of the referred object at the time the
call occurs


when different types of objects are referred, different
versions of the overridden method will be called.


A super
-
class A:


Two sub
-
classes B and C:









B and C override the A’s callme() method.


Overridden method is invoked through the variable
of the super
-
class type.


Each time, the version of the callme() method
executed depends on the type of the object being
referred to at the time of the call:


One interface, many behaviors:


super
-
class defines common methods for sub
-
classes


sub
-
class provides specific implementations for some
of the methods of the super
-
class


A combination of inheritance and overriding


sub
-
classes retain flexibility to define their own
methods, yet they still have to follow a
consistent interface.


A class that stores the dimensions of various 2
-
dimensional objects:


Rectangle is a sub
-
class of Figure:


Triangle is a sub
-
class of Figure:



Invoked through the Figure variable and
overridden in their respective subclasses, the
area() method returns the area of the invoking
object:


Inheritance allows a sub
-
class to override the
methods of its super
-
class.


In fact, a super
-
class may altogether leave the
implementation details of a method and declare
such a method abstract:


abstract type name(parameter
-
list);


Two kinds of methods:


concrete


may be overridden by sub
-
classes


abstract


must be overridden by sub
-
classes


It is illegal to define abstract constructors or static
methods.


The area method cannot compute the area of an
arbitrary figure:





Instead, area should be defined abstract in Figure:






A class that contains an abstract method must be
itself declared abstract:






An abstract class has no instances
-

it is illegal to
use the new operator:



It is legal to define variables of the abstract class
type.


A sub
-
class of an abstract class:


implements all abstract methods of its super
-
class, or


is also declared as an abstract class


Abstract super
-
class, concrete sub
-
class:


Calling concrete and overridden abstract methods:


Figure is an abstract class; it contains an abstract
area method:


Rectangle is concrete


it provides a concrete
implementation for area:


Triangle is concrete


it provides a concrete
implementation for area:


Invoked through the Figure variable and
overridden in their respective subclasses, the
area() method returns the area of the invoking
object:


It is illegal to create objects of the abstract class:


Figure f = new Figure(10, 10);


It is legal to create a variable with the abstract
class type:


Figure figref;


Later,
figref

may be used to assign references to
any object of a concrete sub
-
class of Figure (e.g.
Rectangle) and to invoke methods of this class:


Rectangle r = new Rectangle(9, 5);


figref = r;


System.out.println(figref.area());


The final keyword has three uses:


declare a variable which value cannot change after
initialization


declare a method which cannot be overridden in
sub
-
classes


declare a class which cannot have any sub
-
classes


A method declared final cannot be overridden in
any sub
-
class:






This class declaration is illegal:


Two types of method invocation:


early binding


method call is decided at compile
-
time


late binding


method call is decided at run
-
time


By default, method calls are resolved at run
-
time.


As a final method cannot be overridden, their
invocations are resolved at compile
-
time. This is
one way to improve performance of a method
call.


A class declared final cannot be inherited


has no
sub
-
classes.


final class A { … }


This class declaration is considered illegal:


class B extends A { … }


Declaring a class final implicitly declares all its
methods final.


It is illegal to declare a class as both abstract and
final.


Object class is a super
-
class of all Java classes:


Object is the root of the Java inheritance hierarchy.


A variable of the Object type may refer to objects of any
class.


As arrays are implemented as objects, it may also refer
to any array.



Questions?

3
6