Static binding

STATIC BINDING

1. Static and Dynamic binding
Static Binding: it is also known as early binding the compiler resolve the
binding at compile time. all static method call is resolved at compile time
itself. Because static method are class method and they are accessed using
class name itself. Hence there is no confusion for compiler to resolve. which
version of method is going to call.
Class A
{
Public static void A1()
{
S.O.P(“”I am in A”);
}
}
Class B extends A
{
Public static void A1()
{
S.O.P(‘I am in B”);
}
}
Class C extends B
{
Public static void A1()
{
S.O.P(“I am in C”);
}

2. }
Class TT
{
Public static void main(String arr[])
{
A a= new C();//method call is statically binded so it will call at compile time itself and print Class A
a.A1(); //method
B.A1()//use of class name to access the static method
}
}
Dynamic Binding: dynamic binding also known as late binding it
means method implementation that actually determined at run time and
not at compile time.
Class A
{
Public doit()
{
S.O.P(“I am in A”);
}
}
Class B extends A
{
Public doit()
{
S.O.P(“I am in B”);
}

3. }
Class C extends B
{
Public doit()
{
S.O.P(“I am in C”);
}
}
Class Test
{
Public static void main(String arr[])
{
A x= new B();
x.doit(); // it will print I am in B
}}
Another example of dynamic binding given as
class A1
{
void who()
{
System.out.println("i am in AAA");
}
}

class B1 extends A1

4. {
void who()
{
System.out.println("i am oin BBB");
}
}

class C1 extends B1
{
void who()
{
System.out.println("i am in cc");
}
}


class Dynamicbinding
{
public static void main(String arr[])
{
A1 a=new B1();
a.who();
}
}

5. Note: x is reference variable of object of type A but it is instantiated an object of
Class B because of new B().JRE will look at this statement and say even though x is
clearly declared as type A,it is instantiated as an object of class B, so it will run the
version of doit method that is defined.

UNIT-3
Abstract Method:
It is an method without implementation it represents what to be done. but does
not specify how it will be done.
Any class which contains one or more abstract method is defined as abstract
class.
An abstract class has following characteristics’.
1. It cannot be instantiated(i.e its object is not created).
2. It forces all its subclasses to provide the implementation of its abstract
method.
If any subclass does not provide implementation of even a single abstract
method of super class then subclass is also declared as abstract.
e.g
abstract class A
{
Abstract void callMe(); //abstract method
{
Class B extends A
{
Void callMe()

6. {
S.O.P(“this is a call for me”);
}
Public static void main(String arr[])
{
B b= new B();
b.callMe();
}
}
Note:
1. Abstract class is not interface.
2. An abstract class must have an abstract method
3. Abstract class can have constructor, member variable and normal methods.
4. Abstract classes can never be instantiated.
5. When you extend abstract class with abstract method you must define the
abstract method in child class. or make child class abstract.
Abstract is an important feature of OOPs.it means hiding complexity. Abstract
class used to provide abstraction.

Example: we are casting instance of car type under Vehicle .now vehicle
reference can be used to provide implementation but it will hide the actual
implementation process.

abstract class vehicle
{
public abstract void engine();
}
public class Car extends Vehicle
{
Public void engine()
{
System.out.println(“Car engine”);

7. //here you can write any other code
}
public static void main(String arr[])
{
Vehicle v=new Car();
v.engine();
}
}
Output: car Engine
Abstract methods are usually declared where two or more subclasses are expected to do
similar things in different ways through different implementation.
These subclasses extend the same abstract class and provide different implementation for
abstract method.

INTERFACE:
Interface is collection of abstract methods and static final data members.
Interface cannot be instantiated but their reference variable can be created.
Syntax:
interface identifier
{
Static final data members;
Implicit abstract method();
}

8. e.g.
interface Printable
{
Void print ();
}
Interface is implemented by class. If a class implements’ an interface then it need
to provide public definition of all interface methods. Otherwise class is made
abstract
Syntax of implementation:
Class identifier implements interface-name
{
Public definition of interface method;
Additional method of class
}
e.g
Class A implements Printable
{
Public void print ()
{
S.O.P(“A is printable”);
}
}

9. Difference between class and interface
{
Class interface
Degree of abstraction:
Class support Zero to 100 % abstraction.i.e.
in a class we can have all abstract have all
abstract methods all non abstract method
or both combination

Interface support only 100% abstraction
i.e. they can only have abstract methods
Type of inheritance:
Class facilitate feature based inheritance
(all part of class is inherited in another
class) in java as well as in life multiple
feature based inheritance is not supported.

It facilitate role based inheritance (only
specific part of class is called).in java as
well as in real life multiple role based
inheritance is supported.

Inheritance Purpose Analogy
Feature based
inheritance
Code reusability and run
time polymorphism
Represent blood relation
of real life .A is son of B.in
such relation both feature
and name of is inherited
from single family.i.e
multiple feature based
inheritance is not
supported in real life .
same is the case with java

Role based inheritance
Run time polymorphism Represent non blood
relations of real life . e.g A
is friend of C and C is a
doctor . in such realtion

10. only name is inherited .
each name represents a
role in real life multiple
role is played by same
person i.e multiple role
based inheritance .

If a class impliments interface then interface name is inherited by the class
e.g
public interface Doable
{
Void canbeDone();
}
Class A impliments Doable

{
Public void canbe Done()
{
;;;;;
}
}
Now A is Doable

11. From figure we can found that Krishna is playing different role at different
instance.
During software development programmers need to refer classes of other
programmers class can be referenced in the following three ways.
1. By Name(we can access the instance variable and method using class name)
2. By family(inheritance is the best example)
3. By Role(we need interface here)
1.in the first approach a class is directly referenced by its name . in this
approach in order to refer the class its name must be known available
classes is called static class environment referencing and referenced class.
Tight coupling created the maintenance problem.
e.g
let the programmer A and B who are working on a software.
Programmer A is assigned a class name one
Programmer B is assigned a class name two
Class one is simple and A will nedd only 10 hours to complete.
Class two is complex and B nedd 10 days to complete.
krishna
VISHNU
DWARKADHESH
VASUDEV
KAHANA

12. Class one has a dependence on class two


Class one
{
Public static void invoke(two x)
{
x.display();
}
}
Class two
{
/will complete in 10 days
}

Limitation:
 A need to wait till completion of class two in order to complete his
class.
 If B changes name of his class. A will require to modify his class(tight
coupling)
2.By Family:
Class one
{
Public static void
invoke(canbeDisplayed x)
{
x.display();
}
Abstract class canbeDisplayed
{
Abstract void display()
}
Class two extends canbeDisplayed
{
/will complete in 10 days
}
Advantage:
 Unknown and unavailable classes can be referenced as long as they are
part of referenced family.
 Name of reference classes can be changed without affecting the reference
class
Disadvantage:
 Top most class of family must be known and available.

13.  Facility of referencing unknown and unavailable class is combined to
one family
3.By Role:

Class one
{
Public static void
invoke(canbeDisplayed x)
{
x.display();//completed in 10 min
;;;;;;;;;;;;;;;;;;;;;
}
Interface canbeDisplayed
{
Void disaplay() //completed in 10 min

}
Class two impliments canbeDisplayed
{
//completed in 10 days
}
Advantages:
1. Any class belongs to any family which plays the referenced role can be
referenced . this facility of referencing unknown and unavailable classes is
called dynamic classing environment.
2. Only the role nedd to be known to refrence class
3. Role based reference creates loose coupling between refrencing and
refrenced class.

Following use case demonstrate the nedd of role based inheritance i.e
requirement of only name in inheritance.
Let there are three programmer named A ,B and C A is defining a class
named PQR which conatins P,Q,and R methods.
A need to expose only method P of this class to Class B.
And only method Q to class C
Let A can achieve his object only as
Claa of A interface Class of B
Class PQR impliments
P,Q
{
Interface P
{
Void P()
Class Puser
{
Public static void

14. Public void P()
{
;;;;;;;;;;;;;
‘’’’’’
}
Public void Q()
{
;;;;;;;;;;;;;;
;;;;;;;;;;;;;;
}
Public void R()
{
;;;;;;;;;;;;
;;;;;;;;;;;;;
}
}
}
Interface Q
{
Void Q
{
Void Q();
}
invoke(P x)
{
x.P();

;;;;;;;;;;;;
}
}
Class of C
Class Quser
{
Public static void
invoke(Q x)
{
Public static void
invoke(Q x)
{
x.Q();
;;;;;;;;;;;;;;;;;;;
}
}


Example of interface: there are two interfaces one for whattype and one
for vegetable class. Through these two interfaces we can decide what type
of fruit or vegetable has.




interface Fruit {
public boolean hasAPeel();
//has a peel must be implemented in any class implementing Fruit
//methods in interfaces must be public
}

15. interface Vegetable {
public boolean isARoot();
//is a root must be implemented in any class implementing Vegetable
//methods in interfaces must be public
}



class whattype{
static String doesThisHaveAPeel(Fruit fruitIn)
{
if (fruitIn.hasAPeel())
return "This has a peel";
else
return "This does not have a peel";
}
static String isThisARoot(Vegetable vegetableIn)
{
if (vegetableIn.isARoot())
return "This is a root";
else
return "This is not a root";
}
static String doesThisHaveAPeelOrIsThisRoot(
Tomato tomatoIn)
{
if (tomatoIn.hasAPeel() && tomatoIn.isARoot())
return "This both has a peel and is a root";
else if (tomatoIn.hasAPeel() || tomatoIn.isARoot())
return "This either has a peel or is a root";
else
return "This neither has a peel or is a root";

16. }
}





class Tomato implements Fruit, Vegetable {


boolean peel = false;
boolean root = false;


public Tomato() {}


public boolean hasAPeel()
//must have this method,
// because Fruit declared it
{
return peel;
}
public boolean isARoot()
//must have this method,
// because Vegetable declared it
{
return root;
}


public static void main(String[] args) {

17. //Part one: making a tomato
Tomato tomato = new Tomato();


System.out.println(whattype.isThisARoot(tomato));
//output is: This is not a root
System.out.println(
whattype.doesThisHaveAPeel(tomato));
//output is: This does not have a peel
System.out.println
(whattype.doesThisHaveAPeelOrIsThisRoot
(tomato));
//output is: This neither has a peel or is a root


//Part two: making a fruit
//Fruit = new Fruit();
//can not instantiate an interface like
// this because Fruit is not a class
Fruit tomatoFruit = new Tomato();
//can instantiate by interface like
// this because Tomato is a class


//System.out.println(
// FandVUtility.isThisARoot(tomatoFruit));
//can not treat tomatoFruit as a Vegetable
// without casting it to a Vegetable or Tomato
System.out.println(
whattype.doesThisHaveAPeel(tomatoFruit));
//output is: This does not have a peel
//System.out.println

18. // (whattype.doesThisHaveAPeelOrIsThisRoot
// (tomatoFruit));
//can not treat tomatoFruit as a Vegetable
// without casting it to a Vegetable or Tomato

}
}

Example: write a program to calculate area of class rectangle and class
triangle through interface .
class Rectangle
{
public float compute(float x, float y)
{
return(x * y);
}
}

class Triangle
{
public float compute(float x,float y)
{
return(x * y/2);
}
}

class InterfaceArea
{
public static void main(String args[])
{
Rectangle rect = new Rectangle();
Triangle tri = new Triangle();

19. System.out.println("Area Of Rectangle = "+ rect.compute(1,2));


System.out.println("Area Of Triangle = "+ tri.compute(10,2));
}
}
Example: make the interface for addition and subtraction and access the
classes with various methods in it.
interface Addd
{
public int Add(int x,int y);
public int sub(int a,int b);
}
interface Subb
{
public double sub(double x,double y);
}
class Addition implements Addd
{

public int Add(int x,int y)
{
return x+y;
}

public int sub(int x,int y)
{
return x-y;
}
public float Add( float x ,float y)
{

20. return x+y;
}

public double Add(double x , double y, double z)
{

return x+y+z;
}

}

class Subtraction implements Subb
{
public int sub(int x,int y)
{
return x-y;
}


public float sub(float x,float y)
{
return x-y;
}

public double sub(double x , double y)
{

return x-y;
}
}
class Math
{
public static void main(String arr[])

21. {

Addd a1=new Addition();
Subb a11= new Subtraction();

System.out.println("addition is="+a1.Add(10,29));

System.out.println("subtraction is="+a1.sub(20,12));
System.out.println("subtraction is="+a11.sub(20.0,12.0));

}
}