Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
157 views

Object Oriented Programming Using

The document discusses object-oriented programming concepts in Java including method overriding, dynamic method dispatch, applying method overriding, using abstract classes, and using the final keyword with inheritance. Specifically: - Method overriding forms the basis for dynamic method dispatch where a call to an overridden method is resolved at runtime based on the object's actual type. - Abstract classes allow defining a generalized form shared by subclasses while leaving implementation of some methods to subclasses. - The final keyword can be used to prevent method overriding by making a method final, or to prevent inheritance by making a class final.

Uploaded by

Junaid khan
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
157 views

Object Oriented Programming Using

The document discusses object-oriented programming concepts in Java including method overriding, dynamic method dispatch, applying method overriding, using abstract classes, and using the final keyword with inheritance. Specifically: - Method overriding forms the basis for dynamic method dispatch where a call to an overridden method is resolved at runtime based on the object's actual type. - Abstract classes allow defining a generalized form shared by subclasses while leaving implementation of some methods to subclasses. - The final keyword can be used to prevent method overriding by making a method final, or to prevent inheritance by making a class final.

Uploaded by

Junaid khan
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 12

Object

Oriented
Programming
Using

JAVA
By:
Junaid Ali Siddiqui
junaid_upesh@yahoo.com
Method Overriding ( Override.java )
class A { class B extends A {
int i,j; int k;
A(int a, int b) {
i = a; B(int a, int b, int c) {
j = b; super(a, b);
} k = c;
}
void show() {
System.out.println("i and j: " + i + " " + j); void show() {
} System.out.println("k: " + k);
} }
}

class Override {
public static void main(String args[ ]) {
B subOb = new B(1, 2, 3);

subOb.show();
}
}
Dynamic Method Dispatch
 Method Overriding forms the basis for one of Java’s
most powerful concepts: Dynamic Method Dispatch.

 Dynamic Method Dispatch is the mechanism by which


a call to an overridden method is resolved at run time.
 An important principle: a superclass reference
variable can refer to a subclass object.

 Java uses this fact to resolve calls to overridden


methods at run time.
Dynamic Method Dispatch ( Dispatch.java )
class A { class Dispatch {
void callme() {
public static void main( String args[]) {
System.out.println("Inside A's Callme
Method"); A a = new A();
} B b = new B();
} C c = new C();
A r;
class B extends A {
void callme() { r = a;
System.out.println("Inside B's Callme r.callme();
Method");
}
r = b;
}
r.callme();
class C extends A {
void callme() { r = c;
System.out.println("Inside C's Callme r.callme();
Method"); }
} }
}
Applying Method Orridding ( FindAreas.java )
class Figure { class Triangle extends Figure {
double dim1; Triangle (double a, double b) {
double dim2; super(a, b);
Figure(double a, double b) { }
dim1 = a; double area() {
dim2 = b; System.out.println("Inside Area for Triangle.");
} return dim1 * dim2 / 2;
double area() { }
System.out.println("Area for Figure is undefined."); }
return 0; class FindAreas {
} public static void main(String args[]) {
} Figure f = new Figure(10, 10);
class Rectangle extends Figure { Rectangle r = new Rectangle(9,5);
Rectangle(double a, double b) { Triangle t = new Triangle(10, 8);
super(a, b); Figure figref;
}
figref = r;
double area() {
System.out.println("Area is " + figref.area());
System.out.println("Inside Area for Rectangle.");
return dim1 * dim2; figref = t;
} System.out.println("Area is " + figref.area());
}
figref = f;
System.out.println("Area is " + figref.area());
}
}
Using Abstract Classes
 In situations, when we don’t need the complete
implementation of every method in superclass.
 Superclass only defines a generalized form that will
be shared by all of its subclasses, leaving it to each
subclass to fill in the detail.
 Abstract keyword is used for that perpose.
 These methods are sometime reffered to as
subclasses responsibilty because they have to no
implementation specified in the superclass.
 A class having one or more abstract methods are
called abstract classes.
Using Abstract Classes ( AbstractDemo.java )
abstract class A {
abstract void callme();
void callmetoo() {
System.out.println ("This is a Concrete method.");
}
}
class B extends A {
void callme() {
System.out.println("Inside B's Callme Method");
}
}
class C extends A {
void callme() {
System.out.println("Inside C's Callme Method");
}
}
class AbstractDemo {
public static void main( String args[]) {
B b = new B();
b.callme();
b.callmetoo();
}
}
Using Abstract Classes ( AbstractAreas.java )
abstract class Figure { class Triangle extends Figure {
double dim1; Triangle (double a, double b) {
double dim2; super(a, b);
Figure(double a, double b) { }
dim1 = a; double area() {
dim2 = b; System.out.println("Inside Area for Triangle.");
} return dim1 * dim2 / 2;
abstract double area(); }
} }
class Rectangle extends Figure { class AbstractAreas {
Rectangle(double a, double b) { public static void main(String args[]) {
super(a, b); //Figure f = new Figure (10, 10); // illegal now
} Rectangle r = new Rectangle(9,5);
double area() { Triangle t = new Triangle (10, 8);
System.out.println("Inside Area for Figure figref;
Rectangle."); figref = r;
return dim1 * dim2; System.out.println("Area is " + figref.area());
} figref = t;
} System.out.println("Area is " + figref.area());
}
}
Using final with Inheritance
 Using final to prevent Overriding.
 Using final to prevent Inheritance.
Using final to prevent Overriding.
class A {
final void meth() {
System.out.println("This ia a final method.");
}
}

class B extends A {
void meth() { /// ERROR Can't Override
System.out.println("Illegal! ");
}
}
Using final to prevent Inheritance
final class A {
// ...
}

class B extends A { // ERROR! can't extends


// ...
}
Good Luck !!!

You might also like