![A closure look at methods and classes
Usingcommandlinearguments
Understandingstatic
Recursion
Method overloading with an
example:
// Demonstrate method overloading.
class OverloadDemo
{
void test()
{
System.out.println("No parameters"); }
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a); }
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b); }
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a); return a*a; }
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.25);
System.out.println("Result of ob.test(123.25): " +
result); } }
This program generates the following output:
No parameters
a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
Methodoverloading](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-3-320.jpg)
![A closure look at methods and classes
Usingcommandlinearguments
Understandingstatic
Recursion
Constructor overload with an
example
/* Here, Box defines three constructors to initialize
the dimensions of a box various ways. */
class Box {
double width;
double height;
double depth;
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d; }
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box }
// constructor used when cube is created
Box(double len) {
width = height = depth = len; }
// compute and return volume
double volume() {
return width * height * depth; } }
class OverloadCons {
public static void main(String args[]) {
// create boxes using the various constructors
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mycube = new Box(7);
double vol;
// get volume of first
box vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
// get volume of second
box vol = mybox2.volume();
System.out.println is " + vol);
// get volume of
cube vol = mycube.volume();
System.out.println("Volume of mycube is " + vol);
} }
The output produced by this program is shown
here:
Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0
Volume of mycube is 343.0
Constructoroverloading](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-7-320.jpg)
![A closure look at methods and classes
Usingcommandlinearguments
Understandingstatic
Methodoverloading
Recursion with example
// A simple example of recursion.
class Factorial {
// this is a recursive method
int fact(int n) {
int result;
if(n==1)
return 1;
result = fact(n-1) * n; return result; } }
class Recursion { public static void main(String args[]) {
Factorial f = new Factorial(); System.out.println("Factorial of 3 is " +
f.fact(3)); System.out.println("Factorial of 4 is " + f.fact(4));
System.out.println("Factorial of 5 is " + f.fact(5)); } }
The output from this program is shown here: Factorial of 3 is 6 Factorial of
4 is 24 Factorial of 5 is 120
Recursion](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-9-320.jpg)
![A closure look at methods and classes
Usingcommandlinearguments
Recursion
Methodoverloading
Understanding static
Understandingstatic // Demonstrate static variables, methods, and blocks.
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[]) {
meth(42);
}
}](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-12-320.jpg)
![Inheritance
Usingabstractclassandfinalwith
inheritance
MethodOverriding
Usingsuper
InheritanceBasics
Inheritance with an example.
syntax:
class subclassname extends superclassname
{
variables declaration;
methods declaration;
}
class Employee{
float salary=40000;
}
class Programmer extends Employee{
int bonus=10000;
public static void main(String args[]){
Programmer p=new Programmer();
System.out.println("Programmer salary is:"+p.salary);
System.out.println("Bonus of Programmer is:"+p.bonus);
}
}
}](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-16-320.jpg)
![Inheritance
Usingabstractclassandfinalwith
inheritance
MethodOverriding
Usingsuper
InheritanceBasics
Single inheritance
A
B
When a class extends another one class only
then we call it a single inheritance.
Class A {
public void methodA() {
System.out.println("Base class method"); }
}
Class B extends A { public void methodB()
{ System.out.println("Child class method");
}
public static void main(String args[]) {
B obj = new B();
obj.methodA(); //calling super class method
obj.methodB(); //calling local method } }](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-18-320.jpg)
![Inheritance
Usingabstractclassandfinalwith
inheritance
InheritanceBasics
Usingsuper
Finalizermethod
A first Use for super
class a
{
a(){System.out.println("A");}
}
class b extends a
{
b()
{
super();
System.out.println("B");}
}
class c extends b
{
c(){System.out.println("c");}
}
class last
{
public static void main(String args[])
{
c obj = new c();
}](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-27-320.jpg)
![Inheritance
Usingabstractclassandfinalwith
inheritance
InheritanceBasics
Usingsuper
Finalizermethod A Second Use for super
// Using super to overcome name hiding.
class A {
int i;
}
// Create a subclass by extending class A.
class B extends A {
int i; // this i hides the i in A
B(int a, int b) {
super.i = a; // i in A
i = b; // i in B
}
void show() {
System.out.println("i in superclass: " + super.i);
System.out.println("i in subclass: " + i);
}
}
class UseSuper {
public static void main(String args[]) {
B subOb = new B(1, 2);
subOb.show();
}
}
This program displays the following:
i in superclass: 1
i in subclass: 2](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-29-320.jpg)
![Inheritance
Commandlinearguments
InheritanceBasics
Usingsuper
Methodoverriding Command line arguments
// Use an array to pass a variable number of
// arguments to a method. This is the old-style
// approach to variable-length arguments.
class PassArray {
static void vaTest(int v[]) {
System.out.print("Number of args: " + v.length +
" Contents: ");
for(int x : v)
System.out.print(x + " "); System.out.println();
}
public static void main(String args[])
{
// Notice how an array must be created to
// hold the arguments.
int n1[] = { 10 };
int n2[] = { 1, 2, 3 };
int n3[] = { };
vaTest(n1); // 1 arg
vaTest(n2); // 3 args
vaTest(n3); // no args
}
}
The output from the program is shown here:
Number of args: 1 Contents: 10
Number of args: 3 Contents: 1 2 3
Number of args: 0 Contents:](https://image.slidesharecdn.com/inheritance-150330053039-conversion-gate01/85/Inheritance-33-320.jpg)
Ad
More Related Content
What's hot (20)
Viewers also liked (7)
Ad
Similar to Inheritance (20)
Ad
More from Mavoori Soshmitha (6)
Recently uploaded (20)
Inheritance
- 1. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion Methodsandclasses abstract continue for new switch assert default package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum instanceof return transient catch extends int short try char final interface static void class finally long strictfp volatile const float native super java keywords
- 2. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion Methodsandclasses overloading methods and its purpose If a class have multiple methods by same name but different parameters it is known as method overloading. If we have to perform only one operation , having same name of the methods increases the readability of the program. Different ways to overload the method: 1. By changing number of arguments 2. By changing data type
- 3. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion Method overloading with an example: // Demonstrate method overloading. class OverloadDemo { void test() { System.out.println("No parameters"); } // Overload test for one integer parameter. void test(int a) { System.out.println("a: " + a); } // Overload test for two integer parameters. void test(int a, int b) { System.out.println("a and b: " + a + " " + b); } // overload test for a double parameter double test(double a) { System.out.println("double a: " + a); return a*a; } } class Overload { public static void main(String args[]) { OverloadDemo ob = new OverloadDemo(); double result; // call all versions of test() ob.test(); ob.test(10); ob.test(10, 20); result = ob.test(123.25); System.out.println("Result of ob.test(123.25): " + result); } } This program generates the following output: No parameters a: 10 a and b: 10 20 double a: 123.25 Result of ob.test(123.25): 15190.5625 Methodoverloading
- 4. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion Why method overloading is not possible by changing the return type? Can we overload main() method? Method overloading is not possible by changing the return type of method because there may occur ambiguity. Yes, we can have any number of main methods in a class by method overloading Methodoverloading
- 5. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion What is constructor overloading ? Just like in case of method overloading you have multiple methods with same name but different signature , in Constructor overloading you have multiple constructor with different signature with only difference that Constructor doesn't have return type in Java. Those constructor will be called as overloaded constructor. Overloading is also another form of polymorphism in Java which allows to have multiple constructor with different name in one Class in java. Constructoroverloading
- 6. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion Why do you overload Constructor? Allows flexibility while create array list object. It may be possible that you don't know size of array list during creation than you can simply use default no argument constructor but if you know size then its best to use overloaded Constructor which takes capacity. Since Array List can also be created from another Collection, may be from another List than having another overloaded constructor makes lot of sense. By using overloaded constructor you can convert your Array List into Set or any other collection. Constructoroverloading
- 7. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Recursion Constructor overload with an example /* Here, Box defines three constructors to initialize the dimensions of a box various ways. */ class Box { double width; double height; double depth; // constructor used when all dimensions specified Box(double w, double h, double d) { width = w; height = h; depth = d; } // constructor used when no dimensions specified Box() { width = -1; // use -1 to indicate height = -1; // an uninitialized depth = -1; // box } // constructor used when cube is created Box(double len) { width = height = depth = len; } // compute and return volume double volume() { return width * height * depth; } } class OverloadCons { public static void main(String args[]) { // create boxes using the various constructors Box mybox1 = new Box(10, 20, 15); Box mybox2 = new Box(); Box mycube = new Box(7); double vol; // get volume of first box vol = mybox1.volume(); System.out.println("Volume of mybox1 is " + vol); // get volume of second box vol = mybox2.volume(); System.out.println is " + vol); // get volume of cube vol = mycube.volume(); System.out.println("Volume of mycube is " + vol); } } The output produced by this program is shown here: Volume of mybox1 is 3000.0 Volume of mybox2 is -1.0 Volume of mycube is 343.0 Constructoroverloading
- 8. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Methodoverloading Recursion Recursion is the process of defining something in terms of itself. As it relates to Java programming, recursion is the attribute that allows a method to call itself. A method that calls itself is said to be recursive. The classic example of recursion is the computation of the factorial of a number. The factorial of a number N is the product of all the whole numbers between 1 and N. For example, 3 factorial is 1 × 2 × 3, or 6. Here is how a factorial can be computed by use of a recursive method: Recursion
- 9. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Methodoverloading Recursion with example // A simple example of recursion. class Factorial { // this is a recursive method int fact(int n) { int result; if(n==1) return 1; result = fact(n-1) * n; return result; } } class Recursion { public static void main(String args[]) { Factorial f = new Factorial(); System.out.println("Factorial of 3 is " + f.fact(3)); System.out.println("Factorial of 4 is " + f.fact(4)); System.out.println("Factorial of 5 is " + f.fact(5)); } } The output from this program is shown here: Factorial of 3 is 6 Factorial of 4 is 24 Factorial of 5 is 120 Recursion
- 10. A closure look at methods and classes Usingcommandlinearguments Understandingstatic Methodoverloading Access ControlAccessControl public private protected < unspecified > Class allowed Not allowed Not allowed not allowed Constructor allowed allowed allowed allowed Variable allowed allowed allowed allowed method allowed allowed allowed allowed Visible ?? class Sub class package Outside Package private Yes No No No protected Yes Yes Yes No public Yes Yes Yes Yes < unspecified > Yes Yes No No
- 11. A closure look at methods and classes Usingcommandlinearguments Recursion Methodoverloading Understanding static and final Understandingstatic Why do we use static? There will be times when you will want to define a class member that will be used independently of any object of that class. Instance variables declared as static are, essentially, global variables. When objects of its class are declared, no copy of a static variable is made. Instead, all instances of the class share the same static variable. Methods declared as static have several restrictions: • They can only call other static methods. • They must only access static data. • They cannot refer to this or super in any way.
- 12. A closure look at methods and classes Usingcommandlinearguments Recursion Methodoverloading Understanding static Understandingstatic // Demonstrate static variables, methods, and blocks. class UseStatic { static int a = 3; static int b; static void meth(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Static block initialized."); b = a * 4; } public static void main(String args[]) { meth(42); } }
- 13. A closure look at methods and classes Usingcommandlinearguments Recursion Methodoverloading Understanding static Understandingstatic Why main method is declared as static? Java program's main method has to be declared static because keyword static allows main to be called without creating an object of the class in which the main method is defined. If we omit static keyword before main Java program will successfully compile but it won't execute.
- 14. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics what is inheritance ? Object-oriented programming allows classes to inherit commonly used state and behavior from other classes The mechanism of deriving a new class from existing old one is called inheritance. The old class is known as super class or base class or parent class The new class is known as child class or subclass or derived class. To inherit properties of base class to sub class we use extends keyword in the inherited class i.e. in sub class.
- 15. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics Why use inheritance ? For method overriding. For code reusability.
- 16. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics Inheritance with an example. syntax: class subclassname extends superclassname { variables declaration; methods declaration; } class Employee{ float salary=40000; } class Programmer extends Employee{ int bonus=10000; public static void main(String args[]){ Programmer p=new Programmer(); System.out.println("Programmer salary is:"+p.salary); System.out.println("Bonus of Programmer is:"+p.bonus); } } }
- 17. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics Forms of inheritance: Inheritance allows subclass to inherit all the variables and methods of their parent classes. Inheritance may take different forms: 1. Single inheritance(only one super class). 2. Multiple inheritance(several super classes). 3. Hierarchical inheritance(one super class many sub classes). 4. Multilevel inheritance(derived from derived class).
- 18. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics Single inheritance A B When a class extends another one class only then we call it a single inheritance. Class A { public void methodA() { System.out.println("Base class method"); } } Class B extends A { public void methodB() { System.out.println("Child class method"); } public static void main(String args[]) { B obj = new B(); obj.methodA(); //calling super class method obj.methodB(); //calling local method } }
- 19. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics In such kind of inheritance one class is inherited by many sub classes. In below example class B,C and D inherits the same class A. A is parent class (or base class) of B,C & D. A B C D Hierarchical inheritance Account Current Savings Fixed-deposit
- 20. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics A B C Grand father Son Father Multilevel inheritance Class a member Class c member Class b member Class a member class A {………… ………….} Class B extends A //first { ………… level ………..} class C extends A// second level {…………. ………….}
- 21. Inheritance Usingabstractclassandfinalwith inheritance MethodOverriding Usingsuper InheritanceBasics Multiple inheritance A B C Multiple Inheritance” refers to the concept of one class extending (Or inherits) more than one base class. The inheritance we learnt earlier had the concept of one base class or parent. The problem with “multiple inheritance” is that the derived class will have to manage the dependency on two base classes. Note 1: Multiple Inheritance is very rarely used in software projects. Using Multiple inheritance often leads to problems in the hierarchy. This results in unwanted complexity when further extending the class.
- 22. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Methodoverriding Overriding methods and its purpose Overridden methods allow Java to support run-time polymorphism . Polymorphism is essential to object-oriented programming for one reason: it allows a general class to specify methods that will be common to all of its derivatives, while allowing subclasses to define the specific implementation of some or all of those methods Overridden methods are another way that Java implements the “one interface, multiple methods” aspect of polymorphism.
- 23. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalvariables,methodsandclasses Final variables , methods and classes All methods and variables can be Overridden by default in subclass. If we wish to prevent the subclass from overriding the members of the superclass. We can declare tem as final using the keyword final as a modifier. Ex : final int SIZE=100; final void showstatus(){………….} Making a method final ansures that the functionality defined in this method will never be altered in anyway.
- 24. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalvariables,methodsandclasses Final variables , methods and classes A class that cannot be subclassed is called a final class Ex : final class Aclass{…….} final class Bclass extends Cclass{………….} Any attempt to inherit these classes will cause an error and the compiler will not allow it. Declaring a class final prevents any unwanted extension to the class. It also allows the complier to perform some optimization when a method of a final class is invoked.
- 25. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalizermethod Finalize() method We know that java run time is an automatic garbage collection system . It automatically frees up the memory resources used by the objects . But objects may hold other non-object resources such as window system fonts. The garbage collector cannot free these resources. In order to free these resources we must use finalize method.tis is similar to destructor in C++. The finalizer method is simply finalize() and can be added to any class . Java calls that method whenever it is about to reclaim te space for that object . The finalize method should explicitly define the task to be performed.
- 26. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalizermethod Using super super has two general forms. The first calls the superclass constructor. The second is used to access a member of the superclass that has been hidden by a member of a subclass
- 27. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalizermethod A first Use for super class a { a(){System.out.println("A");} } class b extends a { b() { super(); System.out.println("B");} } class c extends b { c(){System.out.println("c");} } class last { public static void main(String args[]) { c obj = new c(); }
- 28. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalizermethod A Second Use for super The second form of super acts somewhat like this, except that it always refers to the superclass of the subclass in which it is used. This usage has the following general form: super.member Here, member can be either a method or an instance variable. Most applicable to situations in which member names of a subclass hide members by the same name in the superclass. Consider this simple class hierarchy:
- 29. Inheritance Usingabstractclassandfinalwith inheritance InheritanceBasics Usingsuper Finalizermethod A Second Use for super // Using super to overcome name hiding. class A { int i; } // Create a subclass by extending class A. class B extends A { int i; // this i hides the i in A B(int a, int b) { super.i = a; // i in A i = b; // i in B } void show() { System.out.println("i in superclass: " + super.i); System.out.println("i in subclass: " + i); } } class UseSuper { public static void main(String args[]) { B subOb = new B(1, 2); subOb.show(); } } This program displays the following: i in superclass: 1 i in subclass: 2
- 30. Inheritance Usingabstractclass InheritanceBasics Usingsuper Abstractmethodsandclasses Abstract methods and classes A final class can never be subclassed. Java allows us to do somethin exactly opposite to this i.e. we can indicate that te method must always be redefined in a subclass , thus making overriding compulsory. This is done by using the modifier keyword abstract. Ex : abstract class shape { ………….. ………….. abstract void draw(); …………… …………… } A class with more than one abstract methods should be declared as abstract class
- 31. Inheritance Usingabstractclass InheritanceBasics Usingsuper Methodoverriding Abstract methods and classes While using abstract classes , following conditions must satisfy 1. We cannot use abstract classes to instantiate objects directly. Ex : Shape s = new Shape() is illegal because is an abstract class. 2. The abstract methods of an abstract class must be defined in its subclass. 3. We cannot declare abstract constructors or abstract static methods.
- 32. Inheritance Commandlinearguments InheritanceBasics Usingsuper Methodoverriding Command line arguments Java has included a feature that simplifies the creation of methods that need to take a variable number of arguments. This feature is called varargs and it is short for variable- length arguments. A method that takes a variable number of arguments is called a variable-arity method, or simply a varargs method. Situations that require that a variable number of arguments be passed to a method are not unusual. For example, a method that opens an Internet connection might take a user name, password, filename, protocol, and so on, but supply defaults if some of this information is not provided. In this situation, it would be convenient to pass only the arguments to which the defaults did not apply
- 33. Inheritance Commandlinearguments InheritanceBasics Usingsuper Methodoverriding Command line arguments // Use an array to pass a variable number of // arguments to a method. This is the old-style // approach to variable-length arguments. class PassArray { static void vaTest(int v[]) { System.out.print("Number of args: " + v.length + " Contents: "); for(int x : v) System.out.print(x + " "); System.out.println(); } public static void main(String args[]) { // Notice how an array must be created to // hold the arguments. int n1[] = { 10 }; int n2[] = { 1, 2, 3 }; int n3[] = { }; vaTest(n1); // 1 arg vaTest(n2); // 3 args vaTest(n3); // no args } } The output from the program is shown here: Number of args: 1 Contents: 10 Number of args: 3 Contents: 1 2 3 Number of args: 0 Contents:
- 34. Thank you