Core java day5

Inheritance: A brief recap
• Inheritance is of 4 types: Single, Multilevel, Multiple
and Hybrid( also known as hierarchical).
• Java does not support Multiple inheritance with
sohamsengupta@yahoo.com 1
classes.
• In java, if a class A inherits from another class B, the
syntax is going to be :
class A extends B
{
// codes ( data & method & blocks if any)
}

More on Inheritance
• Here class A is called the child/ derived class
• Class B is called the base/parent class
• With respect to the child class, the base class is
referred to as “super”.
• All non-private data and method are inherited
from the base class to the derived or child class.
• Inheritance bears the polymorphism concept
that incorporates the code reusability and
method overriding paradigms.

Sample Code Snippet
class Base
{
int x=940;
static int percentage=94;
void show(){
System.out.println(“Your score is ”+x);
}
}
class Child extends Base
{
int y=89;
void display(){
System.out.println("My parent's score was "+x); // x is now available here
System.out.println("My parent's score was "+super.x); // x is accessible by super
System.out.println("My parent's score was "+this.x); // x is now available here
System.out.println(“Parent’s percentage can be expressed as ”+percentage+ “,”+Base.percentage+
“,”+Child.percentage+ “,”+super.percentage);
System.out.println(“I’m child with marks “+y);
}
}
class A
{
public static void main(String[] args){
Child ch=new Child();
ch.show(); // show in Base available to Child
ch.display();
}
}

When a child-class field has name as that of one in the base class
class Base
{
int x=940;
}
{
int x=719;
void show(){
System.out.println("My marks is "+x);
System.out.println("Parent's marks was "+super.x);
}
}// super.x denotes Base-class data. Methods in child class with same name
//can be accessed likewise
class A
{
ch.show();
}
} // keyword “super” cannot be accessed from within static context.

Role of Constructors in Inheritance
class Base
{
Base(){
System.out.println("From Base Constructor");
}
}
{
Child(){
System.out.println("From Child Constructor");
}
}
class A
{
}
}
When the child class constructor is invoked, the following
steps take place behind the scene…
1. The static blocks and initializers in the Base class
execute when the class is loaded into memory
followed by the same in the Child class
2. Now for each object of Child class, first the non-static
blocks and constructor of base class execute
3. Then those in the child class execute.
FAQ:
1. We are not calling the base-class constructor, then how
come the base-class constructor is invoked?
Answer: See, although the call isn’t explicit, there is an
implicit call to super(), the default/no-arg Base class
Constructor at the very first line in Child().
However, if there is not any no-arg constructor in the base
class it’ll be an error (Onto next slide)

super() constructor
class Base
{
Base(int x){
System.out.println("From Base Constructor "+x);
}
}
{
Child(){ // Error super() not found; call super(940);
System.out.println("From Child Constructor");
}
}
class A // call to super constructor must be the very 1st line in child constructor
else won’t compile
{
}
}

Method overriding
1. If a child class redefines an inherited method
present in the Base class, it’s known as a case of
overriding and the method in the base class is
said to have been overridden in subclass.
2. private methods can never be overridden since
they are not inherited.
3. static methods can never be inherited.
4. overriding cannot impose more restrictive access
on the method
5. Its parameter list is kept unchanged.
6. Return type generally same.( details later)
7. Can never declare to throw broader checked
Exceptions. (More on this later)
8. Method overriding is Runtime Polymorphism.

An example of method overriding
class Base
{
void show(){
System.out.println("Hello");
}
}
{
void show(){
System.out.println("Born!");
}
}
class A
{
Base ref=new Base();
ref.show(); // output: Hello
ref=new Child(); // the ref to Base can hold obj of
// Child
//But converse isn't true without explicit type cast.
// type cast may turn out to be fatal
//ClassCastException depending on code
ref.show(); // output: Born! it's because, the
// ref although being a reference of Base, holds
//object of Child
// this is runtime( ? ) polymorphism or dynamic
method dispatch
}
}

static methods can’t be overridden
class Base
{
static void show(){
System.out.println("Hello");
}
}
{
void show(){
System.out.println("Born!");
}
}
// Error… to avoid: either both should be
static or neither should. Well, let’s make
both static. Now it compiles. But
overriding is not possible. Create an
object of Child and store to a Base’s
reference. Call the method show(). But
Dynamic method dispatch is never seen.
class A
{
public static void main(String[] rt){
Base ref=new Child();
ref.show();
}
}
Output: Hello.
So, static methods are not overridden as
they don’t follow the rule of dynamic
method dispatch

Why overriding can’t impose more restrictive access?
Assume, if it were possible, the method show()
in default access-specifier in class Base is
overridden in class Child to be private. OK up to
this!
Now just think of dynamic method dispatch
where the decision to call which version of the
method is taken at runtime. So, the code will
compile. But, poor Programmer! He/she hardly
knew that this won’t work since the method is
imposed private access in Child class. This will
make to code inconsistent in every aspect.

Why no multiple Inheritance in Java ?
Assume a class A has 2 subclasses B and C
and that each overrides a method, say,
method1() and also assume that if multiple
inheritance were possible, a class D extending
both B and C. So, question will arise which of
the implementations of the same method will the
class D inherit? This is a fallacy. This is known
as the “Deadly Diamond of Death” problem

More on Inheritance
 if you add the keyword “final” before a method
it can’t be anymore overridden.
If it’s used with a class, the class can’t be
anymore inherited or sub-classed.
In order of decreasing restriction, the access
specifiers are private, default, protected and
public
So far we’ve covered only access specifiers with
methods and data but not with class itself. We’ll
see it shortly.

Abstract Methods & Classes
 An abstract method is one, which does not declare any
body. Eg. abstract void show();
 An abstract class is one which has the keyword abstract
associated with its declaration. We can’t create objects
of abstract classes due to compilation errors.
 Abstract classes may have constructors.
 If a class contains at least one abstract method, it must
be declared abstract. But an abstract class may have no
abstract methods at all.
 Any class that inherits an abstract class, will either
define all the inherited abstract methods, if any, or be
itself declared abstract.
 The keyword “final” does not apply with the keyword
“abstract”. Also an abstract method can’t be private.
 The reference to Base can hold object of Child. But here
basrRef can’t access methods which are not in Base.

iinnssttaanncceeooff ooppeerraattoorr
 It’s a binary operator taking first operand as a
reference of a class and the second as a class name
itself.
If the object contained by the reference is of the second
operand class type or a sub type, it returns true else
false.
If the reference and class name are not bound by single
or multilevel inheritance hierarchy, compilation error
occurs complaining of inconvertible or incompatible
types.
Java.lang.Object is the Universal superclass. Every
class inherits from Object clas
 An Example of instanceof operator

class B1
{}
class B2 extends B1
{}
class B3 extends B1
{}
class A
{
B1 b1=new B1();
B2 b2=new B2();
B3 b3=new B3();
System.out.println(b1 instanceof B1); // true
System.out.println(b1 instanceof B2); // false
b1=new B2();
System.out.println(null instanceof B1);// false
System.out.println(b1 instanceof Object); // true
// System.out.println(b3 instanceof B2); Error
}}

Overloading Versus Overriding
• Exhibited inside a class
• Return type can be different
and does not play any role
• Compile time polymorphism.
• Parameters must be different
in regard of type, number,
and/or order.
• No restriction imposed on
declaring Exceptions
• Reference Arguments are
passed depending on the type
of reference not the object it
refers to.
• Can’t be generally prevented.
• Requires both Base & Child
class
• The overridden method must
have return type either same
or super type of the overrider
method.
• Runtime plymorphism
• Parameters must be same.
• Cannot declare to throw
broader checked
exceptions( details later)
• Dynamic method dispatch is
dependent on the type of the
object not the reference type.
• We can prevent overriding by
declaring the method to be
final.

Core java day5

Core java day5

More Related Content

What's hot

Similar to Core java day5

More from Soham Sengupta

Recently uploaded

Core java day5