Transcript compile-time type

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
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
//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 );
} }
The program generates the following output
• C:\JBUILDER8\JDK1.4\bin\javaw -classpath
"C:\WINDOWS\jbproject\overloading\classes;C:\JBUILDER8\JDK1.4\JR
E\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.4
Inside
test
Inside
test(dbl)
(dbl)a:88
a:88
Result of ob.test (123.4): 15227.560000000001
Inside test(dbl) a:123.4
 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 types do 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.
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.
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 name sqr to create methods that
return the 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
The Advantage of Overloading According to C
 For example, absolute value function in C 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
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;
}
}
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
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
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.
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
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).
 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.
Question: Explain the difference between
compile-time type and run-time type
 Variables and other Java source code expressions
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”
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).
 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.
io package as Java’s basic
I/O system
 I/O is performed by streams
A stream is an abstraction that either produces or consumes
information
 Java implements streams within class hierarchies defined in
the java.io package
 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 textbased console I/O is not very important to Java programming
Streams
 Streams are the "fundamental element" of
the 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
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");
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.
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.
Following program reads a string from
console using BufferedReader
To read a string from keyboard, we use the version
readLine() that is the member of BufferedReader class.
String readLine() throws IO Exception
As we can see, it returns a String object.
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"));
} }