Overloading

1. Overloading There is another aspect to polymorphism: Overloading Overloading is not overriding. In Turkish: Overridding: eskisini (geçersiz kılmak) Overloading: Aşırı yüklemek

2. Overloading Methods In Java it is possible to define two or more methods within the same class that share the same name, as long as the parameter declarations are different When this is the case, the methods are said to be overloaded, and the process is referred to as method overloading Method overloading is one of the ways that Java implements polymorphism When an overloaded method is invoked, Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actual call While overloaded methods may have different return types, the return type alone is insufficient to distinguish two versions of a method When Java encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call

3. //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) {void test ( double a) { System.out.println ("double a: " + a);System.out.println (“Inside test(dbl) a: " +a); return a*a; } } class Overload { public static void main (String args [ ] ) { OverloadDemo ob= new OverloadDemo ( ) double result;int i =88; //call all variables of test () ob.test(); ob.test(10);ob.test (i) // this will invoke test (dbl) ob.test(10,20);ob.test (123.45); //this will invoke test (dbl) result = ob.test(123.4); System.out.println ("Result of ob.test (123.4): " + result ); }}

4. The program generates the following output • C:\JBUILDER8\JDK1.4\bin\javaw -classpath"C:\WINDOWS\jbproject\overloading\classes;C:\JBUILDER8\JDK1.4\JRE\lib\rt.jar;C:\....................................:\JBUILDER8\JDK1.4\JRE\classes;C:\JBUILDER8\jdk1.4\lib\tools.jar" overloading.Overload No Parameters a: 10 a and b: 10 20 double a: 123.4Inside test (dbl) a:88 Result of ob.test (123.4): 15227.560000000001 • As we can see, test() is overloaded four times. • The fourth version of test() also return a value is of no consequence relative to overloading, since return typesdo not play a role in overloaded resolution • When an overloaded method is called, Java looks for a match between the arguments used to call the method and the method’s parameter. • This match need not always be exact. • In some automatic Java’s automatic type conversions can play a role in overloaded resolution. Inside test (dbl) a:88 Inside test(dbl) a:123.4

5. Automatic Type Conversion • The second version of OverloadDemo does not define test(int). • When test() is called with an integer inside Overload, no matching method is found. • Java can automatically convert an integer into a double, and this conversion can be used to resolve the call • After test(int) is not found, Java elevates i to double and then calls test(double) • If test(int) had been defined it would have been called. • Java will employ its automatic type conversion only no exact match is found.

6. The Superiority of Method Overloading • “One interface, multiple methods” paradigm is implemented by Java • If a language do not support method overloading, each method must be a unique name • However, it is frequently required to implement the same method for different types of data • There is no rule stating that overloaded methods must relate to one another • We can use the namesqr to create methods that returnthe square of an integer and square root of a floating point value. • These two operations are fundamentally different • Applying method overloading in this manner defeats its original purpose • In practice, we should only overload closely related operations

7. The Advantage of Overloading According to C • For example, absolute value function inC has three versions, • abs( ) returns absolute value of a integer, • labs( ) returns absolute value of a long integer, and • fabs( ) returns absolute value of a floating-point value. • Since C does not support overloading, each function has its own name, even though all three functions do essentially the same thing. • Java’s standard class library includes an absolute value method, called abs() • This method is overloaded by Java’s Math class to handle all numeric types. • Java determines which version of abs() to call based upon the type of argument. • The name abs represents the general action which is being performed • Through the application of polymorphism, several names have been reduced to one.

8. Overloading Constructors class Box { double width;//Box () constructor requires three parameters. double height;// This means all declarations of Box objects must double depth;// pass three argumants to the Box() constructor Box (double w, double h, double d){ width = w; height =h; depth =d; }//constructor used when no dimensions specified Box ( ) { // use -1 to indicate width = -1; // an uninitialized height= -1; // box depth = -1 } //constructor used when cube is created Box (double len) { width = height= depth = len; }//compute and return volume double volume ( ) { return width*height*depth; } }

9. class overloadCons { public static void main (String args [ ] ) { //create boxes using various constructors Box mybox1 = new Box (10,20,15); Box mybox2 = new Box (); Box mycube = new Box (7); double vol; //get volume of boxes vol =mybox1.volume(); System.out.println (“Volume of mybox1 is ” +vol); vol = mybox2.volume(); System.out.println (“Volume of mybox2 is ” +vol); vol =mycube.volume(); System.out.println (“Volume of mycube is ” +vol); } } The program generates the following output C:\JBUILDER8\JDK1.4\bin\javaw -classpath "C:\WINDOWS\jbproject\OverloadCons\classes;C:\JBUILDER8\JDK1.4\JRE\lib\rt.jar; C:\JBUILDER8\JDK1.4\JRE\lib\i18n.jar;C:\:\JBUILDER8\JDK1.4\JRE\classes;C:\ ………….. JBUILDER8\jdk1.4\lib\tools.jar" overloadcons.overloadCons Volume of mybox1 is 3000.0 Volume of mybox2 is -1.0 Volume of mycube is 343.0 • As we can see, the proper overloaded constructor is called based upon the parameters specified when new is executed

10. class overloadCons { public static void main (String args [ ] ) { //create boxes using various constructors Box mybox1 = new Box (10,20,15); Box mybox2 = new Box (); Box mycube = new Box (7); double vol; //get volume of boxes vol =mybox1.volume(); System.out.println (“Volume of mybox1 is ” +vol); vol = mybox2.volume(); System.out.println (“Volume of mybox2 is ” +vol); vol =mycube.volume(); System.out.println (“Volume of mycube is ” +vol); } } The program generates the following output C:\JBUILDER8\JDK1.4\bin\javaw -classpath "C:\WINDOWS\jbproject\OverloadCons\classes;C:\JBUILDER8\JDK1.4\JRE\lib\rt.jar; C:\JBUILDER8\JDK1.4\JRE\lib\i18n.jar;C:\:\JBUILDER8\JDK1.4\JRE\classes;C:\ ………….. JBUILDER8\jdk1.4\lib\tools.jar" overloadcons.overloadCons Volume of mybox1 is 3000.0 Volume of mybox2 is -1.0 Volume of mycube is 343.0 • As we can see, the proper overloaded constructor is called based upon the parameters specified when new is executed

11. Here is an example of method overriding • This example defines two classes • Parent and • Child. • The Parent class defines a simple string s, and it defines one method for retrieving that string, getS(). • The Child class also defines a getS() method, • Therefore overriding the Parent class's getS(). • They have the same name, but they do different things. • The main difference between an overloaded method and an overridden method is that overriding does not allow you to change the return type.

12. package chp7; // Parent is superclass of Child // it just defines a string and an access method, getS() public class Parent { String s = "I am Darth Vader (Parent). "; String getS() { return s; } //demonstrates overridding getS() method of Parent // "extends" means that Child inherits from the Parent class public class Child extends Parent { // this value is part of the Child

13. class String s; // overrides Parent's method String getS() { // the "super" keyword calls the parent of current class. // i.e. "super" refers to the value after the "extends" keyword s = super.s + " I am Luke (child). "; return s; } public static void main(String [] args) { // make a new baby Child luke = new Child(); // call the Child's overriding method System.out.println(luke.getS()); } } Here is the output of running Child: I am Darth Vader (Parent). I am Luke (child).

14. Overloading occurs in the compiler at compile time. • The compiler chooses which one you mean by finding the corresponding argument type to what you called for. • By contrast, overriding occurs at runtime. • It happens when one class extends another, and • the subclass has a method with the same signature as a method of the superclass.

15. Question: Explain the difference between compile-time type and run-time type • Variables and other Java source codeexpressions have a compile-time type, which the compiler uses to determine legality of certain expressions (such as field accesses or method calls). • Objects that are created during the execution of a Java program have a run-time type, which the Java virtual machine uses to determine what method implementations should be called and to check the legality of casts. According to type checking: • "compile-time type" means "apparent type" and • "run-time type" means "actual type”

16. Here is an example to help distinguish between compile-time types and run-time types: import java.util.Vector; import java.util.List; ... Vector vec = new Vector(); List list = vec; Object obj = list; ... • There is only one instance of an object; • The object created by the expression new Vector(). • It has a run-time type of Vector; • Expressions of the form "new X(...)" will always return an instance of X. • There are three variables: vec, list, and obj. • They all refer to the same object, but each has a different compile-time type ( Vector, List, and Object, respectively).

17. The compiler will allow calls like vec.lastElement(), list.clear(), and obj.toString(), • Because those are all methods associated with the compile-time types for each of those variables. • The compiler will also statically ensure that the Vector class actually implements all of those methods • Because the Vector class subclasses Object and implements List. • The compiler will not allow calls like obj.clear() or list.lastElement(), • Because those methods are not declared by the compile-time types associated with those variables, • therefore are not guaranteed to be implemented by every object that the variables might point to.

18. io package as Java’s basic I/O system

19. I/O is performed by streams • A streamis anabstractionthat either produces or consumes information • Java implements streams within class hierarchies defined in the java.iopackage • Since most real applications of Java are not text-based, console programs, none of I/O methods have been used significantly except print() and println() • We generally generate graphically oriented applets using AWT for the interaction • Although text -based programs are excellent as teaching examples, Java’s support for console I/O is limited , and text-based console I/O is not very important to Java programming

20. Streams • Streams are the "fundamental element" ofthe java.io package • The simplest streams are the abstract classes InputStream and OutputStream • We cannot use them directly • They define i/o in terms of bytes

21. Reading data • An input stream is typically opened for you automatically • when it is retrieved from the corresponding data source object or • when you construct one of the reader objects. • For example, to open the input stream for a file, we pass the name of the file into a java.io.FileReader object's constructor as follows: java.io.FileReader fileReader = new java.io.FileReader("/home/me/myfile.txt");

22. Reading Console Input • Console input is accomplished by reading from System.in • To obtain a character based stream that is attached to console, we wrap System.in in a Buffered Reader object to create a character stream BufferedReader (Reader inputReader) • inputReader is a stream that is linked to the instance of BufferedReader that is being created • Reader is an abstract class • One of its concrete classes is InputStreamReader, which converts bytes to character. • To obtain an InputStreamReader object that is linked to System,in ,we use the following constructor InputStreamReader(InputStream input Stream) Because System.in refers to an object type InputStream, it can be used for inputStream.

23. Putting all together, the following line of code creates a Bufferedreader that is connected to the keyboard BufferedReader br= new BufferedReader (new InputStreamReader (System.in)); After this statement executes, bt is a character based stream that is linked to the console through System.in • To read a character from a Buffered Reader, we use read(). The version of read() that we will be using is: int read() throws IO Exception • Each time read() is called, it reads a character from the input stream and returns it as an integer value. It returns -1 when the end of stream is encountered.

24. Following program reads a string from console using BufferedReader • To read a string from keyboard, we usethe version readLine() that is the member of BufferedReader class. • String readLine() throws IO Exception • As we can see, it returns a String object.

25. package untitled28; import java.io.*; public class BRReadLines { public static void main ( String args[]) throws IOException { //create a BufferedReader using System.in BufferedReader br= new BufferedReader (new InputStreamReader (System.in)); String str; System.out.println ("Enter lines of text."); System.out.println ("Enter stop' to quit."); do { str=br.readLine(); System.out.println(str); } while (!str.equals("stop")); } }