1. 1 IM103 Wk 7 (C&K ch14, p323) Abstraction, inheritance and interfaces Learning objectives By the end of this lecture you should be able to:  explain the terms abstraction and abstract data type ;  distinguish between method overloading and method overriding ;  explain the difference between dynamic (run-time) binding and static (compile-time) binding ;  create your own interfaces in Java;  make use of adapters in programs;  explain the purpose of the toString method.

2. 2 Abstraction The idea of focusing on what an object does, without worrying about the detail of how it does it. the more abstract our specification, the more likely we are to build a system that is flexible and maintainable; this is because we do not tie ourselves down to one particular design.

3. 3 Oblong length : real number height : real number calculateArea() : real number calculatePerimeter() : real number at the specification stage we don’t concern ourselves with unnecessary detail, and we don't use types that are specific to one particular programming language. Reminder: specification of the Oblong class

4. 4 Abstract Data Types a class template is often referred to as an abstract data type; all that is available to the user of such a type is the method descriptions (inputs and output); in object-oriented programming languages the the principal data types are abstract data types (objects of a class).

5. More on inheritance and polymorphism Reminder: the Employee hierarchy Employee number : String name : String Employee(String, String) getNumber() : String getName() : String getStatus() : String FullTimeEmployee annualSalary : double FullTimeEmployee(String, String, double) setAnnualSalary(double) getAnnualSalary() : double calculateMonthlyPay () : double getStatus() : String PartTimeEmployee hourlyPay : double PartTimeEmployee(String,String, double) setHourlyPay(double) getHourlyPay() : double calculateWeeklyPay(int) : double getStatus() : String

6. 6 Reminder of the getStatus method was declared as an abstract method in the superclass (the Employee class) was overridden in the subclasses ( FullTimeEmployee and PartTimeEmployee ). calling this method causes a String to be returned: "Full-Time" for a FullTimeEmployee object; "Part-Time" for a PartTimeEmployee object.

7. 7 Third item Second item First item Part-time employee Full-time employee Full-time employee An array holding items of different types Program 14.1 creates an array like this.

8. 8 Analysis of program 14.1 An array is declared, big enough for three employees: Employee[] employeeList = new Employee[3]; Local variables ared declared to hold values entered by the user: String num, name; double pay; char status;

9. for(int i = 0; i < employeeList.length; i++) { System.out.print("Enter the employee number: "); num = EasyIn.getString(); System.out.print("Enter the employee's name: "); name = EasyIn.getString(); System.out.print(" ull-time or art-time? "); status = EasyIn.getChar(); if(status == 'f' || status == 'F') { System.out.print("Enter the annual salary: "); } else { System.out.print("Enter the hourly pay: "); } pay = EasyIn.getDouble();........................ A for loop is used to get details of the three employees:

10. 10 The for loop continues; we create the new employee, either full-time or part-time:........................ if(status == 'f' || status == 'F') { employeeList[i] = new FullTimeEmployee(num, name, pay); } else { employeeList[i] = new PartTimeEmployee(num, name, pay); } System.out.println(); }

11. 11 for(int i = 0; i < employeeList.length; i++) { System.out.println("Employee number: " + employeeList[i].getNumber()); System.out.println("Employee name: " + employeeList[i].getName()); System.out.println("Status: " + employeeList[i].getStatus()); System.out.println(); } we display the details of each employee the correct status is displayed, even the status of the employee was not known until run-time.

12. 12 Enter the employee number: 1 Enter the employee's name: Jones ull-time or art-time? f Enter the annual salary: 30000 Enter the employee number: 2 Enter the employee's name: Agdeboye ull-time or art-time? f Enter the annual salary: 35000 Enter the employee number: 3 Enter the employee's name: Sharma ull-time or art-time? p Enter the hourly pay: 15 Employee number: 1 Employee name: Jones Status: Full-Time Employee number: 2 Employee name: Agdeboye Status: Full-Time Employee number: 3 Employee name: Sharma Status: Part-Time Sample Output

13. 13 Run-time binding vs compile-time binding the technique that makes the above program possible is known as run-time binding or dynamic binding; if the language used compile-time (static) binding, then when the code for a class was compiled, the code for each of its methods would be compiled alongside it; every time an object received a message to invoke that method, the control of the program would jump to the place where the code for the method was stored; the instructions in that method would then be executed, and the program control would then return to the place where it left off.

14. 14 in the MixedListTester we don't know until run-time what sort of object we are dealing with. where should the program jump to in the following line? System.out.println("Status: " + employeeList[i].getStatus()); this decision must be made at run-time; when a new object is created, it must hold information about where its methods are stored; thus, the decision about which actual method is called can be postponed until run-time; this technique is called run-time binding. Run-time binding vs compile-time binding... continued

15. 15 Java normally uses dynamic (run-time) binding; however, dynamic binding involves more processing and more storage space than static binding; if we know that a method is not going to be overridden we can use the final modifier with a method; this means that the method cannot be overridden; if we make the method final, then static binding will be used. Using the final modifier with methods

16. 16 both method overriding and method overloading are forms of polymorphism; overriding involves redefining a superclass method in a subclass; overloading means having many methods with the same name, each with a different parameter list. Overriding vs Overloading (Reminder)

17. 17 Abstract classes and interfaces an interface is a class in which all methods are abstract; examples that we have used are ActionListener and MouseListener ; we can also write our own interfaces.

18. 18 Developing our own interface we wish to produce a re-usable class to which we could attach a logo of our choice; to make a class attachable, we need to provide an attach method; to ensure that a class has an attach method we can develop Attachable interface.

19. 19 The attachable interface import java.awt.*; interface Attachable { public void attach(Component c, int xPos, int yPos); }

20. 20 the interface has a single abstract method, attach ; we do not have to use the abstract modifier because all interface methods are abstract by definition; a class that implements Attachable, will become a kind of Attachable, and will "inherit" and redefine the attach method. Notes on the Attachable interface

21. 21 import java.awt.*; class CAndKLogo implements Attachable { public void attach(Component c, int xPos, int yPos) { Graphics g = c.getGraphics(); g.setFont(new Font("Serif", Font.BOLD,15)); g.setColor(Color.red); g.fillRect(xPos,yPos,125,20); g.setColor(Color.yellow); g.drawString("Charatan & Kans",xPos + 3, yPos + 15); } Using the Attachable interface

22. 22 Notes on the CAndKlogo class the first line gets the graphics context - that is, it creates a Graphics object associated with this component: Graphics g = c.getGraphics(); the next line sets the font to one of our own creation: g.setFont(new Font("Serif", Font.BOLD,15)); this logo, or any other Attachable, can be attached to a graphical component such as a Panel ; this is done in the LogoPane l class.

23. The LogoPanel class import java.awt.*; class LogoPanel extends Panel { private Attachable logo; private int xPos; private int yPos; public LogoPanel(Attachable logoIn, int xIn, int yIn) { logo = logoIn; xPos = xIn; yPos = yIn; } public void paint(Graphics g) { logo.attach(this, xPos, yPos); }

24. 24 public class LogoTester { public static void main(String[] args) { EasyFrame f = new EasyFrame(); CAndKLogo logo = new CAndKLogo(); LogoPanel loPanel = new LogoPanel(logo, 10, 5); f.add(loPanel); f.setSize(250,250); f.setLocation(200,200); f.setVisible(true); } Adding the LogoPanel to a frame

25. 25 Running the LogoTester

26. 26 Analysis of the EasyFrame class import java.awt.*; import java.awt.event.*; // uses the WindowListener Interface public class EasyFrame extends Frame implements WindowListener { // constructors public EasyFrame() { addWindowListener(this); } // provides a title for the frame public EasyFrame(String msg) { super(msg); addWindowListener(this); } …………………………………………………………………………………

27. 27 ……………………………………………………………………………………… /* the frame is disposed of when the cursor is clicked on the crosshairs */ public void windowClosing(WindowEvent e) { dispose(); // disposes of the frame } // when the window closes the program is shut down public void windowClosed(WindowEvent e) { System.exit(0); // ends the program } ……………………………………………………………………………………… Analysis of the EasyFrame class … continued

28. ……………………………………………………………………………… /* the remaining methods are required by the WindowListenrer interface */ public void windowDeactivated(WindowEvent e) { } public void windowActivated(WindowEvent e) { } public void windowDeiconified(WindowEvent e) { } public void windowIconified(WindowEvent e) { } public void windowOpened(WindowEvent e) { } Analysis of the EasyFrame class … continued

29. 29 using an interface means that we have to code all the interface methods, even those we are not interested in; as an alternative we can use an adapter; an adapter acts as an intermediary between our class and the interface, making it unnecessary to code all the methods; an adapter is provided for every interface that comes with the standard Java packages. Adapters

30. 30 an adapter has to be inherited; our EasyFrame class can't inherit the adapter as it already inherits Frame ; we will have to write a new class to add to a Frame later on - we will call it EasyListener. Creating a closing frame using an adapter

31. The EasyListener class import java.awt.*; import java.awt.event.*; class EasyListener extends WindowAdapter { public void windowClosing(WindowEvent e) { // determine which window caused the event Window win = e.getWindow(); // dispose of that window win.dispose(); } public void windowClosed(WindowEvent e) { // close down the whole system System.exit(0); }

32. 32 Using the EasyListener class // this just produces an empty frame import java.awt.event.*; import java.awt.*; public class RunChangingFace2 { public static void main(String[] args) { Frame frame = new Frame(); frame.setSize(250,200); // add an EasyListener to the frame frame.addWindowListener(new EasyListener()); frame.setVisible(true); }

33. import java.awt.event.*; import java.awt.*; public class RunChangingFace3 { public static void main(String[] args) { class EasyListener extends WindowAdapter // an inner class { public void windowClosing(WindowEvent e) { Window win = e.getWindow(); win.dispose(); } public void windowClosed(WindowEvent e) { System.exit(0); } Frame frame = new Frame(); frame.setSize(250,200); frame.addWindowListener(new EasyListener()); frame.setVisible(true); } Using an inner class

34. 34 Reminder Every class is inherited from a "super superclass" called Object. the Object class has a method called toString that returns a Strin g, and that can be overridden by subclasses of Object ; methods of other classes can be set up to use this method; some classes in the standard Java packages have methods (for example print and println ) which take an Object object as a parameter and use its toString method. The toString method

35. 35 Overriding the toString method in the BankAccount class public String toString() { return "Account Number: " + accountNumber + "\nAccount Name: " + accountName + "\nCurrent Balance: " + balance + "\n"; }

36. 36 Using the toString method public class RunAccount { public static void main(String[] args) { BankAccount account1 = new BankAccount("001", "Sarah Patel"); BankAccount account2 = new BankAccount("002", "Robinder Grewel"); System.out.println(account1); System.out.println(account2); EasyIn.pause(); }

37. 37 Output Account Number: 001 Account Name: Sarah Patel Current Balance: 0.0 Account Number: 002 Account Name: Robinder Grewel Current Balance: 0.0 This works because there is a version of println that accepts an object and outputs the return value of its toString method.

38. 38 We will create a class called EasyText which extends the TextArea class, giving it a display method. The EasyText class import java.awt.*; class EasyText extends TextArea { public void display(Object objectIn) { //call the setText method of the superclass super.setText(objectIn.toString()); }

39. import java.awt.*; public class EasyTextTester { public static void main(String[] args) { EasyFrame frame = new EasyFrame(); BankAccount account = new BankAccount("001", "Bill Tin-Wardrobe"); EasyText eText = new EasyText(); frame.setSize(300,170); frame.setBackground(Color.lightGray); frame.add(eText); frame.setVisible(true); eText.display(account); } Using the EasyText class with the BankAccount class

40. 40 Result of using the display method of EasyText