Polymorphism. Polymorphism Abstract Classes Interfaces

Transcription

1 References: Beginning Java Objects, Jacquie Barker; Teach Yourself Object Oriented Programming in 21 Days, Anthony Sintes; Sara Stoecklin, FSU; IT350 Internet lectures 9/25/ Polymorphism Abstract Classes Interfaces 9/25/ Polymorphism Polymorphism is the ability of two or more objects belonging to different classes to respond to the same message in different ways (at run time). If a surgeon, a hairdresser and an actor all hear the message cut! each will respond in a different way. If these three professions were classes, then the cut message would have specific meaning to each class. 9/25/

2 Revisiting the Student/Grad Student Example class Student void print ( System.out.println( name : + \nid : + studentid + \n Major: + major + \ngpa : + gpa); //end print //end Student class GraduateStudent extends Student void print() 1 super.print(); System.out. println( Undergrad Deg: + undergraddegree + \nundergrad Inst: + undergradinstitution + \nthis IS A GRAD STUDENT ); //end print //end GraduateStudent class UndergraduateStudent extends Student void print() super.print(); System.out. Println( High School Attended: + highschool + \nthis IS AN UNDERGRAD STUDENT ); //end print //end UndergraduateStudent 2 1. GraduateStudent defines a print method specific for a grad student after calling on the general print method of Student. 2. UndergraduateStudent defines a print method specific for an undergrad student after calling on the general print method of Student. 9/25/ Revisiting the Student/GradStudent Example public class UseStudentClass Student [] studentbody = new Student[20]; UndergraduateStudentug1 = new UndergraduateStudent(); UndergraduateStudentug2 = new UndergraduateStudent(); GraduateStudent g1 = new GraduateStudent(); GraduateStudent g2 = new GraduateStudent();. //populate the array in random order studentbody]0] = ug1; studentbody]1] = g1; studentbody]2] = ug2; studentbody]3] = g2;. //Print attributes of all students for ( inti=0; i<20; i++) studentbody[i].print(); The array holds references to Student objects which, because of inheritance, can be either UndergraduateStudent or GraduateStudent references. Each object knows which version of the print() method to execute based on its internal knowledge of its type/class //end UseStudentClass 9/25/ Benefit of Polymorphism Without polymorphism, all the printing scenarios for different kinds of students would have to be tested in a series of if statements. for (int i=0; i<20; i++) if(studentbody[i] is an undergrad) printasundergradstudent(); else if(studentbody[i] is a grad student) printasgraduatestudent(); else. Different functions needed to print each kind of student Or, we would need a single print() method with the if test hidden inside. public print() if(this is an undergrad student) print attributes of undergrad student else if(this is a graduate student) print attributes of a graduate student else if. If we later define a MS student or a PhD student, the code body in either case must be modified, becoming more spaghettilike. 9/25/

3 How Does Polymorphism Work? Declaring an object only reserves enough memory to hold a reference to it. The memory to house the object is only allocated when a call to new is executed. Student y; Memory for a reference y = new Student(); This is dynamic instantiation Memory for an object Dynamic instantiation and dynamic binding are necessary for polymorphism and overriding. Static instantiation and compile time binding are what make overloading work. 9/25/ How Does Polymorphism Work? With procedure oriented languages, for any particular function call, the compiler can determine at compile-time what function gets called by matching the call against all of the method signatures that have been declared. This is static (compile time) binding Overloaded methods are checked at compile time With object-oriented languages it may not be possible to determine until runtime which function gets called. 9/25/ How Does Polymorphism Work? Dynamic binding refers to the process of connecting a function call with the appropriate method at runtime. A polymorphic function is one that requires dynamic binding. 9/25/

4 How Does Polymorphism Work? //main application Person p; Student s; Professor pr; if (some runtime condition) p = new Student(); else p = new Professor(); p.print(); It is not known at compile time which object will call the print method. Only at runtime is the object instantiated and the type/class of the object selected. 1 2 class Student extends Person.. public void print(int a, int b) //end print end Student class Professor extends Person.. public void print(int a, int b) //end print end Professor 1. p=new Student() was executed 2. p= new Professor() was executed 9/25/ class Base public void f() System.out.println( Base::f(() ); class Derived extends Base public void f() System.out.println( Derived::f() ); public class Test public static void main (String[] args) //Math.random() returns a random value >= 0.0 and < 1.0 if ( Math.random() > 0.5 ) g (new Derived()); else g (new Base()); public static void g (Base b) b.f(); Polymorphism The output of this code depends on the dynamic type passed to method g(). 9/25/ Polymorphism Polymorphism fulfills the goals of OO by producing software that is Natural: Enables you to more naturally model the real world and to program at the conceptual level of the problem instead of specific implementations. Overloading lets you concentrate on what an object does, not what kinds of parameters it might process Reliable: Results in reliable code because it simplifies code. You can write one case instead of many cases for each type of object you may manipulate. Don t have to update code each time you add a new subclass. You can write less code. 9/25/

5 Polymorphism Polymorphism fulfills the goals of OO by producing software that is Reusable: Maintainable: Extendable: Timely: For reuse, an object only needs to know the second object s interface, not the details of the implementation. Results in less code, so there is less to maintain. Code is less bulky and so, easier to maintain. You can add new subtypes to a system without having to alter the system to use the new subtype. With overloading, you can add new methods without having to worry about name conflicts. If you can write less code, you can deliver it sooner. You can add new types almost instantly to a program. Maintaining and extending is much faster. 9/25/ Static vs Dynamic Types A reference to an object is declared to be a reference to a specific static type. At runtime it may refer to objects of its static type or any object type that inherits from its static type. The dynamic type of an object reference may change. For example: Polygon p = new Rectangle(); The static type of p is Polygon. The dynamic type is Rectangle. 9/25/ class Base public void f(object o) System.out.println("Base::f(Object)"); //end f //end Base class Derived extends Base public void f(string s) System.out.println("Derived::f(String)"); //end f //end Derived public class Test public static void main(string[] args) Base b = new Derived(); b.f("think"); //end main //end Test Base::f(Object) Output Static vs Dynamic Types The static type of b is Base; the dynamic type of b is Derived Since f is not overridden, but overloaded in Derived, the call b.f( Think ) is bound at compile time to the Base method f(object) 9/25/

6 Static vs Dynamic Types Here is a simple, 2-step test you can use to determine which method will execute for any method call: 1. Associate the method call with a declaration statically. But, 2. If the method being called is non-static and is overridden, you consider the dynamic type of the object calling the function to resolve the method call to an actual implementation; otherwise, consider the static type of the object when resolving the method call. 9/25/ Abstract Classes An abstract class specifies the required behaviors of a class without having to provide an explicit implementation of each behavior. i.e., guarantees that subclasses use the base class properly Extended classes provide specific implementation of some or all of the methods. Each method not implemented in an abstract class is specifically marked abstract. Note: if all you need is to define a set of methods that someone will support, but provide no implementation, you should probably use an interface instead. 9/25/ Abstract Classes abstract class Boat protected int size; protected int weight; public abstract void turnright(); public class SailBoat extends Boat private int numberofsails; public void turnright() public void describe() //SailBoat inherits size and weight attributes //from Boat System.out.println( Size: + size); System.out.println( Weight: + weight); System.out.println( Number of sails: + numberofsails); The class Boat is an abstract class because it represents an abstract concept: a floatable conveyance that can turn right. It identifies a behavior without implementing it. Many other kinds of boats could be defined to extend Boat: MotorBoat, Canoe, etc. All would have the same abstract features of a Boat. 9/25/

7 Abstract Classes abstract class Boat protected String name; public abstract void turnright(); public String getidentification(); public class SailBoat extends Boat private int numberofsails; public void turnright() public class MotorBoat extends Boat private int licensenumber; public void turnright(); public String getidentification(); The classes MotorBoat and SailBoat extend the class Boat. Boat is an abstract class because it s impossible to specify the implementation for the method turnright(). The following call is polymorphic: Boat b;//can t do this... b.turnright(); Boat is an abstract class, so b must reference a specific type of boat (i.e. b = new?). It's impossible to determine what b will refer to at compile time, so the call is polymorphic. 9/25/ Abstract Classes Whenever a class contains one or more abstract methods, then the class as a whole is considered to be an abstract class. All methods in an abstract class don t have to be abstract; it can also contain concrete methods -- methods with a signature and a body. Because some of the implementation is missing, you can t create an instance of an abstract class. 9/25/ Abstract Classes in Java Many Java classes use inheritance and polymorphism public abstract class InputStream public abstract int read(); public class StringBufferInputStream extends InputStream protected String buffer; protected int pos; public int read() return buffer.charat(pos++); public class FileInputStream extends InputStream public native int read(); public void consumer(inputstream instream) int i = instream.read (); 9/25/

8 Abstract Classes Abstract classes solve the problem inherent in generalizing two existing classes that each have a method with the same signature, but different logic. class Professor String name; String ssn; float hourlysalary; public float computepay (int hrsworked) return hrsworked * hourlysalary; //end computepay //end Professor Same signature, different logic class Student String name; String ssn; float monthlystipend; int minimumrequiredhrs; public float computepay(int hrsworked) if (hrsworked > minimumrequiredhrs ) return monthlystipend; else return 0.0F; //end computepay //end Student 9/25/ Abstract Classes Solution is to create Person as an abstract class and define computepay() as an abstract method. public abstract class Person String name; String ssn; public abstract float computepay (int hrsworked); class Professor extends Person String name; String ssn; float hourlysalary; public float computepay (int hrsworked) return hrsworked * hourlysalary; //end computepay //end Professor class Student extends Person String name; String ssn; float monthlystipend; int minimumrequiredhrs; public float computepay(int hrsworked) if (hrsworked > minimumrequiredhrs ) return monthlystipend; else return 0.0F; //end computepay //end Student 9/25/ Interfaces 9/25/

9 Interfaces Java allows only single inheritance, not multiple inheritance Person Person Athlete Student Student Java has the mechanism of interfaces to provide some of the functionality of multiple inheritance 9/25/ Java Interfaces The term interface is an overloaded word. It can refer to the public messages you can send to an object or to the Java mechanism for representing abstractions. Java Interfaces are like classes without any implementation. The only value an interface provides is a new type. An interface provides a set of specifications of methods; it does not provide any code for the methods. (They look like class definitions inside C++ header files.) An interface can also provide a set of constants. 9/25/ Basic syntax Interfaces interface name constants method signatures Interface methods may not be static, because static methods are class-specific. All attributes in an interface are implicitly static and final (i.e.constants). 9/25/

10 Interfaces All methods in an interface are essentially abstract, and so no special keyword is required in their signatures. The keyword implements is used to specify that a class will implement an interface. Interfaces cannot be instantiated with new. Each class that implements an interface must implement all of its methods, or, if the class does not implement all of the methods, that class must be declared abstract. 9/25/ public interface Programmable void setcurrenttime (int mo, int d, int h, int m); void setchannel(int c); void setstart(int d, int h, int m); void setstop(int d, int h, int m); // end Programmable Notice how the VCR class has provided implementations for every method defined in the Programmable interface. It has to; otherwise the compiler will complain! Using this technique VCR can extend one class and implement as many as needed. Interface - Example public class VCR implements Programmable private int month, day, hour, minute; private int startday, starthour, startminute; private int stopday, stophour, stopminute; private int channel; public void setcurrenttime(int mo, int d, int h, int m) month=mo; day=d; hour = h; minute=m; // end setcurrenttime public void setchannel(int c) channel = c; // end setchannel public void setstart(int d, int h, int m) startday = d; starthour = h; startminute =m; // end setstart public void setstop(int d, int h, int m) stopday = d; stophour = h; stopminute = m; 9/25/2003 // end setstop 29 // end VCR Java Interfaces - Example public interface Programmable void setcurrenttime (int mo, int d,int h, int m); void setchannel(int c); void setstart(int d, int h, int m); void setstop(int d, int h, int m); // end Programmable public class SmartTV implements Programmable private int month, day, hour, minute; private int startday, starthour, startminute; private int stopday, stophour, stopminute; private int channel; public void setcurrenttime(int mo, int d, int h, int m) // end setcurrenttime public void setchannel(int c) Again, Notice how the channel = c; SmartTV class has provided // end setchannel implementations for every method defined in the public void setstart(int d, int h, int m) Programmable interface, startday = d; starthour = h; startminute =m; although one of the methods // end setstart has no statements. public void setstop(int d, int h, int m) stopday = d; stophour = h; stopminute = m; 9/25/2003 // end setstop 30 // end SmartTv 10

11 Java Interfaces Example 2 //Taxpayer.java public interface TaxPayer public static final int TAXYEAR=2002; public static final double TAXRATE = 0.40; public float filetaxes(); public void displaytaxreturn(int year); //FamousPerson.java public interface FamousPerson public void liststagenames(); public boolean starredin(string film); //Person.java public class Person implements TaxPayer,FamousPerson protected String name; public void setname(string name) this.name = name; public void liststagenames() public boolean starredin(string film) public float filetaxes() public void displaytaxreturn(int year) Java s answer to multiple inheritance 9/25/ Java Interfaces An object can simultaneously have any one of several identities by implementing multiple interfaces. The object can be plugged in to any method where any of its identities is appropriate. For example: class Film public void castactorinfilm (FamousPerson p); Any object belonging to a class that implements the FamousPerson interface can be passed in as an argument to this method, because if an object implements an interface, then it is an object of that type. 9/25/ Interfaces Use an interface to define methods that can extend the functionality of a variety of different classes. Defining a class that implements an interface allows the class to attach the methods contained in the interface. Example: java s ActionListener interface adds actionperformed() -- a method that enables objects to perform actions in response to events (e.g. mouse click) 9/25/

12 ActionListener interface Public abstract ActionListener extends EventListener public abstract void actionperformed(actionevent e); Details of the action performed are left to the implementor 9/25/ Interface Comparable java.lang.comparable: public interface Comparable public int compareto(object o); The Comparable interface is used to capture the abstraction of relative comparison or ordering. For example, people can be compared or ordered by height, weight, grade point average, etc. Stars can be ordered by age, distance from earth, size, etc. The interface captures the abstraction of ordering but doesn't say what defines the order (age, height, weight, etc). 9/25/ Interface Comparable The definition of the interface's only method compareto(object o) determines what defines the ordering. The semantics of compareto(object o) are: when the object that compareto() is called for is less than the parameter o, the result should be negative; if equal the result should be 0; if greater than, the result should be positive. 9/25/

13 Interface Comparable /** * Interface to compare the equality of two objects * */ public interface Comparable /** * Compare this object to a desired object. If current is * larger, then * return 1; if the tocompare object is larger, then return -1. * If the two objects are equal, return 0 tocompare the object for comparison -1 if tocompare > this, 0 if tocompare == this, * 1 if this > tocompare */ public int compareto (Object tocompare); All Comparable objects must implement the compare method. The interface is a contract the implementing class must fulfill. 9/25/ Example usage of Comparable public class Sort public static void sort(comparabledata[]) int n = data.length; for(int i=0;i<n-1;i++) for(int j=n-1; j>i;j--) // Descending sort if (data[j].compareto(data[j-1]) < 0) swap(data,j,j-1); public static void swap(object data[], int a, int b) Object o = data[a]; data[a] = data[b]; data[b] = o; 9/25/ Interface Comparable A reference to a Comparable object can refer to any object that implements the Comparable interface. For example, the numeric wrapper classes such as Integer, Float, etc. all implement the interface Comparable, so the following is valid: Integer i = new Integer(3); Comparable c = i; 9/25/

14 Interfaces Interfaces can extend other interfaces public interface Sortable extends Collectible A class implementing the Sortable interface must also fulfill the contract of the Collectible interface. 9/25/ Interfaces Using Java interfaces is good practice because it separates the definition of the interface from the class implementation of that interface You can write code to abstractions, which facilitates reuse When you separate interface from implementation, many otherwise unrelated classes could implement the interface you could write a routine that sorts objects of any type that implements the abstraction or interface Comparable (e.g. Integer, Float, Student, Telephone) Like inheritance, objects that share a common interface can also take part in substitutability relationships without having to be part of the same inheritance hierarchy. [Sintes,142] 9/25/