|
Chapter 6
Objects and Classes
Implementing OO relationships:
·
“is a” relationship is implemented by inheritance (extends
keyword)
·
“has a” relationship is implemented by providing the class
with member variables.
Overloading and Overriding:
·
Overloading is an example of polymorphism. (operational /
parametric)
·
Overriding is an example of runtime polymorphism (inclusive)
·
A method can have the same name as another method in the same
class, provided it forms either a valid overload or override
|
Overloading
|
Overriding
|
|
Signature has to be different. Just a difference in
return type is not enough.
|
Signature has to be the same. (including the return
type)
|
|
Accessibility may vary freely.
|
Overriding methods cannot be more private than the
overridden methods.
|
|
Exception list may vary freely.
|
Overriding methods may not throw more checked
exceptions than the overridden methods.
|
|
Just the name is reused. Methods are independent
methods. Resolved at compile-time based on method signature.
|
Related directly to sub-classing. Overrides the
parent class method. Resolved at run-time based on type of the object.
|
|
Can call each other by providing appropriate argument
list.
|
Overriding method can call overridden method by
super.methodName(), this can be used only to access the immediate
super-class’s method. super.super won’t work. Also, a class outside
the inheritance hierarchy can’t use this technique.
|
|
Methods can be static or non-static. Since the
methods are independent, it doesn’t matter. But if two methods have the
same signature, declaring one as static and another as non-static does not
provide a valid overload. It’s a compile time error.
|
static methods don’t participate in overriding,
since they are resolved at compile time based on the type of reference
variable. A static method in a sub-class can’t use ‘super’ (for the
same reason that it can’t use ‘this’ for)
Remember that a static method can’t be overridden
to be non-static and a non-static method can’t be overridden to be
static. In other words, a static method and a non-static method cannot
have the same name and signature (if signatures are different, it would
have formed a valid overload)
|
|
There’s no limit on number of overloaded methods a
class can have.
|
Each parent class method may be overridden at most
once in any sub-class. (That is, you cannot have two identical methods in
the same class)
|
·
Variables can also be overridden, it’s known as shadowing or
hiding. But, member variable references are resolved at compile-time. So at the
runtime, if the class of the object referred by a parent class reference
variable, is in fact a sub-class having a shadowing member variable, only the
parent class variable is accessed, since it’s already resolved at compile time
based on the reference variable type. Only methods are resolved at run-time.
public
class Shadow {
public static void main(String s[]) {
S1 s1 = new S1();
S2 s2 = new S2();
System.out.println(s1.s); // prints S1
System.out.println(s1.getS()); // prints S1
System.out.println(s2.s); // prints S2
System.out.println(s2.getS()); // prints S2
s1 = s2;
System.out.println(s1.s); // prints
S1, not S2 -
// since variable is resolved
at compile time
System.out.println(s1.getS()); // prints
S2 -
// since method is resolved at run time
}
}
class
S1 {
public String s = "S1";
public String getS() {
return s;
}
}
class
S2 extends S1{
public String s = "S2";
public String getS() {
return s;
}
}
In the above code, if we didn’t have the
overriding getS() method in the sub-class and if we call the method from
sub-class reference variable, the method will return only the super-class member
variable value. For explanation, see the following point.
·
Also, methods access variables only in context of the class of the
object they belong to. If a sub-class method calls explicitly a super class
method, the super class method always will access the super-class variable.
Super class methods will not access the shadowing variables declared in
subclasses because they don’t know about them. (When an object is created,
instances of all its super-classes are also created.) But the method accessed
will be again subject to dynamic lookup. It is always decided at runtime which
implementation is called. (Only static methods are resolved at compile-time)
public
class Shadow2 {
String s = "main";
public static void main(String s[]) {
S2 s2 = new S2();
s2.display(); // Produces an
output – S1, S2
S1 s1 = new S1();
System.out.println(s1.getS()); //
prints S1
System.out.println(s2.getS()); // prints
S1 – since super-class method
// always accesses super-class variable
}
}
class
S1 {
String s = "S1";
public String getS() {
return s;
}
void display() {
System.out.println(s);
}
}
class
S2 extends S1{
String s = "S2";
void display() {
super.display(); //
Prints S1
System.out.println(s); // prints S2
}
}
·
With OO languages, the class of the object may not be known at
compile-time (by virtue of inheritance). JVM from the start is designed to
support OO. So, the JVM insures that the method called will be from the real
class of the object (not with the variable type declared). This is accomplished
by virtual method invocation (late binding). Compiler will form the argument
list and produce one method invocation instruction – its job is over. The job
of identifying and calling the proper target code is performed by JVM.
·
JVM knows about the variable’s real type at any time since when
it allocates memory for an object, it also marks the type with it. Objects
always know ‘who they are’. This is the basis of instanceof operator.
·
Sub-classes can use super keyword to access the shadowed variables
in super-classes. This technique allows for accessing only the immediate
super-class. super.super is not valid. But casting the ‘this’ reference to
classes up above the hierarchy will do the trick. By this way, variables in
super-classes above any level can be accessed from a sub-class, since variables
are resolved at compile time, when we cast the ‘this’ reference to a
super-super-class, the compiler binds the super-super-class variable. But this
technique is not possible with methods since methods are resolved always
at runtime, and the method gets called depends on the type of object, not the
type of reference variable. So it is not
at all possible to access a method in a super-super-class from a subclass.
public class
ShadowTest {
public static void main(String
s[]){
new STChild().demo();
}
}
class
STGrandParent {
double wealth = 50000.00;
public double getWealth() {
System.out.println("GrandParent-" + wealth);
return wealth;
}
}
class STParent
extends STGrandParent {
double wealth = 100000.00;
public double getWealth() {
System.out.println("Parent-" + wealth);
return wealth;
}
}
class STChild
extends STParent {
double wealth = 200000.00;
public double getWealth() {
System.out.println("Child-" + wealth);
return wealth;
}
public void demo() {
getWealth(); // Calls Child method
super.getWealth(); // Calls Parent method
//
Compiler error, GrandParent method cannot be accessed
//super.super.getWealth();
// Calls Child method, due to dynamic method lookup
((STParent)this).getWealth();
//
Calls Child method, due to dynamic method lookup
((STGrandParent)this).getWealth();
System.out.println(wealth); // Prints Child wealth
System.out.println(super.wealth); // Prints Parent wealth
// Prints Parent wealth
System.out.println(((STParent)(this)).wealth);
//
Prints GrandParent wealth
System.out.println(((STGrandParent)(this)).wealth);
}
}
·
An inherited method, which was not abstract on the super-class,
can be declared abstract in a sub-class (thereby making the sub-class abstract).
There is no restriction. In the same token, a subclass can be declared abstract
regardless of whether the super-class was abstract or not.
·
Private members are not inherited, but they do exist in the
sub-classes. Since the private methods are not inherited, they cannot be
overridden. A method in a subclass with the same signature as a private method
in the super-class is essentially a new method, independent from super-class,
since the private method in the super-class is not visible in the sub-class.
public class
PrivateTest {
public static void main(String
s[]){
new PTSuper().hi(); //
Prints always Super
new
PTSub().hi(); //
Prints Super when subclass doesn't have hi method
// Prints Sub when subclass has hi method
PTSuper
sup;
sup = new PTSub();
sup.hi();
// Prints Super when subclass doesn't have hi method
// Prints Sub when subclass has hi method
}
}
class PTSuper
{
public void hi() { // Super-class implementation always calls
superclass hello
hello();
}
private void hello() { // This method is not inherited by subclasses, but
exists in them.
// Commenting out both the methods in the subclass show this.
// The test will then print "hello-Super" for all three calls
// i.e. Always the super-class implementations are called
System.out.println("hello-Super");
}
}
class PTSub
extends PTSuper {
public void hi() { // This method overrides super-class hi, calls
subclass hello
try {
hello();
}
catch(Exception e) {}
}
void hello() throws Exception { // This method is independent from super-class
hello
// Evident from, it's allowed to throw Exception
System.out.println("hello-Sub");
}
}
·
Private methods are not overridden, so calls to private methods
are resolved at compile time and not subject to dynamic method lookup. See the
following example.
public class
Poly {
public static void main(String
args[]) {
PolyA ref1 = new PolyC();
PolyB ref2 = (PolyB)ref1;
System.out.println(ref2.g()); //
This prints 1
// If f() is not private in PolyB, then prints 2
}
}
class PolyA {
private int f() { return 0; }
public int g() { return 3; }
}
class PolyB
extends PolyA {
private int f() { return 1; }
public int g() { return f(); }
}
class PolyC
extends PolyB {
public int f() { return 2; }
}
Constructors and Sub-classing
·
Constructors are not inherited as normal methods, they have to be
defined in the class itself.
·
If you define no constructors at all, then the compiler provides a
default constructor with no arguments. Even if, you define one constructor, this
default is not provided.
·
We can’t compile a sub-class if the immediate super-class
doesn’t have a no argument default constructor, and sub-class constructors are
not calling super or this explicitly (and expect the compiler to insert an
implicit super() call )
·
A constructor can call other overloaded constructors by ‘this
(arguments)’. If you use this, it must be the first statement in the
constructor. This construct can be used only from within a constructor.
·
A constructor can’t call the same constructor from within.
Compiler will say ‘ recursive constructor invocation’
·
A constructor can call the parent class constructor explicitly by
using ‘super (arguments)’. If you do this, it must be first the statement in
the constructor. This construct can be used only from within a constructor.
·
Obviously, we can’t use both this and super in the same
constructor. If compiler sees a this or super, it won’t insert a default call
to super().
·
Constructors can’t have a return type. A method with a class
name, but with a return type is not considered a constructor, but just a method
by compiler. Expect trick questions using this.
·
Constructor body can have an empty return statement. Though void
cannot be specified with the constructor signature, empty return statement is
acceptable.
·
Only modifiers that a constructor can have are the accessibility
modifiers.
·
Constructors cannot be overridden, since they are not inherited.
·
Initializers are used in initialization of objects and classes and
to define constants in interfaces. These initializers are :
1.
Static and Instance variable initializer expressions.
Literals and
method calls to initialize variables. Static variables can be initialized
only by static
method calls.
Cannot pass on
the checked exceptions. Must catch and handle them.
2.
Static initializer blocks.
Used to initialize static
variables and load native libraries.
Cannot pass on
the checked exceptions. Must catch and handle them.
3.
Instance initializer blocks.
Used to factor out code that is
common to all the constructors.
Also useful with anonymous
classes since they cannot have constructors.
All constructors must declare
the uncaught checked exceptions, if any.
Instance Initializers in
anonymous classes can throw any exception.
·
In all the initializers, forward referencing of variables is not
allowed. Forward referencing of methods is allowed.
·
Order of code execution (when creating an object) is a bit tricky.
1.
static variables initialization.
2.
static initializer block execution. (in the order of declaration, if
multiple blocks found)
3.
constructor header ( super or this – implicit or explicit )
4.
instance variables initialization / instance initializer block(s)
execution
5.
rest of the code in the constructor
Interfaces:
·
All methods in an interface are implicitly public, abstract, and
never static.
·
All variables in an interface are implicitly static, public,
final. They cannot be transient or volatile. A class can shadow the variables it
inherits from an interface, with its own variables.
·
A top-level interface itself cannot be declared as static or final
since it doesn’t make sense.
·
Declaring parameters to be final is at method’s discretion, this
is not part of method signature.
·
Same case with final, synchronized, native. Classes can declare
the methods to be final, synchronized or native whereas in an interface they
cannot be specified like that. (These are implementation details, interface need
not worry about this)
·
But classes cannot implement an interface method with a static
method.
·
If an interface specifies an exception list for a method, then the
class implementing the interface need not declare the method with the exception
list. (Overriding methods can specify sub-set of overridden method’s
exceptions, here none is a sub-set). But if the interface didn’t specify any
exception list for a method, then the class cannot throw any exceptions.
·
All interface methods should have public accessibility when
implemented in class.
·
Interfaces cannot be declared final, since they are implicitly
abstract.
·
A class can implement two interfaces that have a method with the
same signature or variables with the same name.
Inner Classes:
·
A class can be declared in any scope. Classes defined inside of
other classes are known as nested classes.
There are four categories of nested classes.
1.
Top-level nested classes / interfaces
·
Declared as a class member with static modifier.
·
Just like other static features of a class. Can be accessed /
instantiated without an instance of the outer class. Can access only static
members of outer class. Can’t access instance variables or methods.
·
Very much like any-other package level class / interface. Provide
an extension to packaging by the modified naming scheme at the top level.
·
Classes can declare both static and non-static members.
·
Any accessibility modifier can be specified.
·
Interfaces are implicitly static (static modifier also can be
specified). They can have any accessibility modifier. There are no non-static
inner, local or anonymous interfaces.
2.
Non-static inner classes
·
Declared as a class member without static.
·
An instance of a non-static inner class can exist only with an
instance of its enclosing class. So it always has to be created within a context
of an outer instance.
·
Just like other non-static features of a class. Can access all the
features (even private) of the enclosing outer class. Have an implicit reference
to the enclosing instance.
·
Cannot have any static members.
·
Can have any access modifier.
3.
Local classes
·
Defined inside a block (could be a method, a constructor, a local
block, a static initializer or an instance initializer). Cannot be specified
with static modifier.
·
Cannot have any access modifier (since they are effectively local
to the block)
·
Cannot declare any static members.(Even declared in a static
context)
·
Can access all the features of the enclosing class (because they
are defined inside the method of the class) but can access only final variables
defined inside the method (including method arguments). This is because the
class can outlive the method, but the method local variables will go out of
scope – in case of final variables, compiler makes a copy of those variables
to be used by the class. (New meaning for final)
·
Since the names of local classes are not visible outside the local
context, references of these classes cannot be declared outside. So their
functionality could be accessed only via super-class references (either
interfaces or classes). Objects of those class types are created inside methods
and returned as super-class type references to the outside world. This is the
reason that they can only access final variables within the local block. That
way, the value of the variable can be always made available to the objects
returned from the local context to outside world.
·
Cannot be specified with static modifier. But if they are declared
inside a static context such as a static method or a static initializer, they
become static classes. They can only access static members of the enclosing
class and local final variables. But this doesn’t mean they cannot access any
non-static features inherited from super classes. These features are their own,
obtained via the inheritance hierarchy. They can be accessed normally with
‘this’ or ‘super’.
4.
Anonymous classes
·
Anonymous classes are defined where they are constructed. They can
be created wherever a reference expression can be used.
·
Anonymous classes cannot have explicit constructors. Instance
initializers can be used to achieve the functionality of a constructor.
·
Typically used for creating objects on the fly.
·
Anonymous classes can implement an interface (implicit extension
of Object) or explicitly extend a class. Cannot do both.
Syntax: new
interface name() { } or new class name() { }
·
Keywords implements and extends are not used in anonymous classes.
·
Abstract classes can be specified in the creation of an anonymous
class. The new class is a concrete class, which automatically extends the
abstract class.
·
Discussion for local classes on static/non-static context,
accessing enclosing variables, and declaring static variables also holds good
for anonymous classes. In other words, anonymous classes cannot be specified
with static, but based on the context, they could become static classes. In any
case, anonymous classes are not allowed to declare static members. Based on the
context, non-static/static features of outer classes are available to anonymous
classes. Local final variables are always available to them.
·
One enclosing class can have multiple instances of inner classes.
·
Inner classes can have synchronous methods. But calling those
methods obtains the lock for inner object only not the outer object.
If you need to synchronize an inner class method based on outer object,
outer object lock must be obtained explicitly. Locks on inner object and outer
object are independent.
·
Nested classes can extend any class or can implement any
interface. No restrictions.
·
All nested classes (except anonymous classes) can be abstract or
final.
·
Classes can be nested to any depth. Top-level static classes can
be nested only within other static top-level classes or interfaces. Deeply
nested classes also have access to all variables of the outer-most enclosing
class (as well the immediate enclosing class’s)
·
Member inner classes can be forward referenced. Local inner
classes cannot be.
·
An inner class variable can shadow an outer class variable. In
this case, an outer class variable can be referred as (outerclassname.this.variablename).
·
Outer class variables are accessible within the inner class, but
they are not inherited. They don’t become members of the inner class. This is
different from inheritance. (Outer class cannot be referred using ‘super’,
and outer class variables cannot be accessed using ‘this’)
·
An inner class variable can shadow an outer class variable. If the
inner class is sub-classed within the same outer class, the variable has to be
qualified explicitly in the sub-class. To fully qualify the variable, use
classname.this.variablename. If we don’t correctly qualify the variable, a
compiler error will occur. (Note that this does not happen in multiple levels of
inheritance where an upper-most super-class’s variable is silently shadowed by
the most recent super-class variable or in multiple levels of nested inner
classes where an inner-most class’s variable silently shadows an outer-most
class’s variable. Problem comes only when these two hierarchy chains
(inheritance and containment) clash.)
·
If the inner class is sub-classed outside of the outer class (only
possible with top-level nested classes) explicit qualification is not needed (it
becomes regular class inheritance)
// Example 1
public class InnerInnerTest {
public
static void main(String s[]) {
new Outer().new Inner().new InnerInner().new
InnerInnerInner().doSomething();
new Outer().new InnerChild().doSomething();
new Outer2().new Inner2().new InnerInner2().doSomething();
new InnerChild2().doSomething();
}
}
class Outer {
String
name = "Vel";
class
Inner {
String name = "Sharmi";
class InnerInner {
class InnerInnerInner {
public void doSomething() {
// No problem in accessing
without full qualification,
// inner-most class
variable shadows the outer-most class variable
System.out.println(name);
// Prints "Sharmi"
System.out.println(Outer.this.name);
// Prints "Vel", explicit reference to Outer
// error, variable is not inherited from the
outer class, it can be just accessible
//
System.out.println(this.name);
//
System.out.println(InnerInner.this.name);
//
System.out.println(InnerInnerInner.this.name);
// error, super cannot be used to access
outer class.
// super will always refer the parent, in
this case Object
//
System.out.println(super.name);
System.out.println(Inner.this.name);
// Prints "Sharmi", Inner has declared 'name'
}
}
}
}
/*
This is an inner class extending an inner class in the same scope */
class
InnerChild extends Inner {
public void doSomething() {
// compiler error, explicit qualifier needed
// 'name' is inherited from Inner, Outer's
'name' is also in scope
//
System.out.println(name);
System.out.println(Outer.this.name);
// prints "Vel", explicit reference to Outer
System.out.println(super.name);
// prints "Sharmi", Inner has declared 'name'
System.out.println(this.name);
// prints "Sharmi", name is inherited by InnerChild
}
}
}
class Outer2 {
static
String name = "Vel";
static
class Inner2 {
static String name = "Sharmi";
class InnerInner2 {
public void doSomething() {
System.out.println(name);
// prints "Sharmi", inner-most hides outer-most
System.out.println(Outer2.name);
// prints "Vel", explicit reference to Outer2's static variable
//
System.out.println(this.name);
// error, 'name' is not inherited
//
System.out.println(super.name);
// error, super refers to Object
}
}
}
}
/* This is a stand-alone class extending an
inner class */
class InnerChild2 extends Outer2.Inner2 {
public void doSomething() {
System.out.println(name);
// prints "Sharmi", Inner2's name is inherited
System.out.println(Outer2.name);
// prints "Vel", explicit reference to Outer2's static variable
System.out.println(super.name);
// prints "Sharmi", Inner2 has declared 'name'
System.out.println(this.name);
// prints "Sharmi", name is inherited by InnerChild2
}
}
// Example 2
public class InnerTest2 {
public
static void main(String s[]) {
new OuterClass().doSomething(10, 20);
// This is legal
//
OuterClass.InnerClass ic = new OuterClass().new InnerClass();
//
ic.doSomething();
// Compiler error, local inner classes cannot
be accessed from outside
//
OuterClass.LocalInnerClass lic = new OuterClass().new LocalInnerClass();
//
lic.doSomething();
new OuterClass().doAnonymous();
}
}
class OuterClass {
final
int a = 100;
private
String secret = "Nothing serious";
public
void doSomething(int arg, final int fa) {
final int x = 100;
int y = 200;
System.out.println(this.getClass() + " - in doSomething");
System.out.print("a = " + a + " secret = " + secret +
" arg = " + arg + " fa = " + fa);
System.out.println(" x = " + x + " y = " + y);
// Compiler error, forward reference of local
inner class
//
new LocalInnerClass().doSomething();
abstract class AncestorLocalInnerClass { } // inner class can be abstract
final class LocalInnerClass extends AncestorLocalInnerClass { // can be
final
public void doSomething() {
System.out.println(this.getClass()
+ " - in doSomething");
System.out.print("a
= " + a );
System.out.print("
secret = " + secret);
//
System.out.print("
arg = " + arg); // Compiler
error, accessing non-final argument
System.out.print("
fa = " + fa);
System.out.println("
x = " + x);
//
System.out.println("
y = " + y); // Compiler error, accessing non-final variable
}
}
new InnerClass().doSomething(); // forward reference fine for member
inner class
new LocalInnerClass().doSomething();
}
abstract
class AncestorInnerClass { }
interface
InnerInterface { final int someConstant = 999;} // inner interface
class
InnerClass extends AncestorInnerClass implements InnerInterface {
public void doSomething() {
System.out.println(this.getClass() + " - in doSomething");
System.out.println("a = " + a + " secret = " + secret
+ " someConstant = " + someConstant);
}
}
public
void doAnonymous() {
// Anonymous class implementing the inner interface
System.out.println((new InnerInterface() { }).someConstant);
// Anonymous class extending the inner class
( new InnerClass() {
public void
doSomething() {
secret =
"secret is changed";
super.doSomething();
}
} ).doSomething();
}
}
|
Entity
|
Declaration
Context
|
Accessibility
Modifiers
|
Outer
instance
|
Direct
Access to enclosing context
|
Defines
static or non-static members
|
|
Package
level class
|
As
package member
|
Public
or default
|
No
|
N/A
|
Both
static and non-static
|
|
Top
level nested class (static)
|
As
static class member
|
All
|
No
|
Static
members in enclosing context
|
Both
static and non-static
|
|
Non
static inner class
|
As
non-static class member
|
All
|
Yes
|
All
members in enclosing context
|
Only
non-static
|
|
Local
class (non-static)
|
In
block with non-static context
|
None
|
Yes
|
All
members in enclosing context + local final variables
|
Only
non-static
|
|
Local
class (static)
|
In
block with static context
|
None
|
No
|
Static
members in enclosing context + local final variables
|
Only
non-static
|
|
Anonymous
class (non-static)
|
In
block with non-static context
|
None
|
Yes
|
All
members in enclosing context + local final variables
|
Only
non-static
|
|
Anonymous
class (static)
|
In
block with static context
|
None
|
No
|
Static
members in enclosing context + local final variables
|
Only
non-static
|
|
Package
level interface
|
As
package member
|
Public
or default
|
No
|
N/A
|
Static
variables and non-static method prototypes
|
|
Top
level nested interface (static)
|
As
static class member
|
All
|
No
|
Static
members in enclosing context
|
Static
variables and non-static method prototypes
|
|
