CT 229 Object-Oriented Programming Continued

Transcription

1 CT 229 Object-Oriented Programming Continued 24/11/2006 CT229

2 Summary - Inheritance Inheritance is the ability of a class to use the attributes and methods of another class while adding its own functionality extends keyword in class definition identifies the base class of the new class being defined Derived class inherits public and protected variables and methods of base class, as if they were its own Derived class can override methods of the base class Private methods and variables of base class not directly accessible by derived class (access methods must be used) The keyword super can be used to access variables and methods of its superclass. super.variablename; super.methodname(); ( Example super.getfulldetails() ) 24/11/2006 CT229 1

3 Visibility Modifiers Modifier Same Class Same Package Subclass Everyone public YES YES YES YES protected YES YES YES default YES YES private YES 24/11/2006 CT229 2

4 Final Keyword You cannot subclass a final class public final class Employee { I could not write a class that extends Employee (Salesman) You cannot overwrite a final method If I declared the method getfulldetails() in Employee.java to be final then Salesman.java could not override this method public final string getfulldetails A final variable is a constant final double temperature = 32.23; If you mark a variable of reference type (that is, any class type) as final, that variable cannot refer to any other object. However, you can change the object s contents, because only the reference itself is final. 24/11/2006 CT229 3

5 Polymorphism Polymorphism is the capability of an action or method to perform different operations depending on the object that it is acting upon Example: Employee[] staff = new Employee[10]; staff[0] = new Manager(); staff[1] = new Salesman(); staff[2] = new Secretary(); 24/11/2006 CT229 4

6 The instanceof Operator Consider the following method public double calculatechristmasbonus(employee employee){ Assume the Christmas Bonus received depends on the type of employee you are. For example a manager would receive 1000, while a poor engineer may only receive 100 The method takes an parameter of type employee but it could be a manager or an engineer. How do I find out? public double calculatechristmasbonus(employee employee){ if (employee instanceof Manager) return 1000; else if (employee instanceof Engineer) return 100; 24/11/2006 CT229 5

7 Casting Objects Use instanceof to test the type of an object Restore full functionality of an object by casting (for example if the Manager class implemented a method that was specific to that class you would have to cast the object to a Manager) For example if (employee instanceof Manager) Manager manager = (Manager) employee; 24/11/2006 CT229 6

8 Abstract Classes Usually, after defining a class, you create instances of it Some classes are so general they will be defined without the intention of creating instances of them They are base classes for other derived classes E.g. may have a common base class Animal for classes Dog, Cat and Bear, but every object we create will be a Dog, Cat or Bear -- none will be the 'generic animal Also we can create a manager, engineer, secretary but not the generic employee. To declare a class as abstract, use abstract keyword Compiler error if you try to create an object of class: e.g. Animal a = new Animal( ); // ERROR 24/11/2006 CT229 7

9 Abstract Classes Example public abstract class Animal { public abstract void sayhello(); public void saybye() { System.out.println("Bye from Animal"); Abstract classes and methods force prototype standards to be followed (ie. they provide templates). For example any class that extends the Animal class must implement the sayhello method or else declare it as an abstract method. Notice that an Abstract class can have concrete methods 24/11/2006 CT229 8

10 Interface Java only allows for single inheritance. A class can only inherit attributes and methods from one other class To tie elements of different classes together java uses an interface An interface is like an abstract class, but: does not have any instance variables does not have any default method implementations To define: Keyword interface (rather than class) Contains set of public abstract methods (abstract => no body supplied for methods) All variables should be static final Essentially, any class the implements the interface must implement its set of public methods Interface is implemented in a class definition: public class <class-name> implements <iface-name> {... 24/11/2006 CT229 9

11 Interface public class Cat implements Animal{ public interface Animal { public void sayhello(); public void saybye(); public void sayhello() { System.out.println("Hello from the cat"); public void saybye() { System.out.println("Goodbye from the Cat"); Any class that implements Animal must implement each method within animal. 24/11/2006 CT229 10

12 Using Multiple Interfaces public interface Animal { public void sayhello(); public interface FarmWorker { public void jobtitle(); public class Cow implements Animal, FarmWorker{ public void sayhello() { System.out.println("Hello from the cow"); public void jobtitle() { System.out.println("Provision of Milk"); 24/11/2006 CT229 11

13 Principles of Object-Oriented Programming Abstraction Subdivide a complicated problem into it s constituent parts and describe these parts in simple, precise language. Typically, describing parts of the system involves naming the different parts and describing their functionality (Interface). Encapsulation The different components of a software system should implement an abstraction, without revealing the internal details of the implementation. Encapsulation is the ability of an object to place a boundary around its attributes and methods. Programs written in older languages suffered from side effects where variables sometimes had their contents changed or reused in unexpected ways. Object variables and certain methods can be hidden completely from external access. You are in complete control of specifying how you code should be utilised. Modularity An organising structure where the different units of a software project are divided into separate functional units. Promotes the reuse of code 24/11/2006 CT229 12

14 CT 229 Stacks and Queues 24/11/2006 CT229

15 Abstract Data Type Remember the idea of abstraction from the previous slides When this concept is applied to the design of data structures it gives rise to abstract data types (ADTs) An abstract model of a data structure, that specifies Data stored Operations that may be performed on data Types of parameters for the operations Specifies what each operation does, but not how In Java, this corresponds naturally to an Interface Definition An ADT is realised as a concrete data structure In Java, this is a class that implements the interface 24/11/2006 CT229 14

16 Overview Stacks and Queues : linear ordered list ADTs Stack: Last In, First Out: Items can only enter/leave via the top Push and Pop to add and remove Example Applications: Queue: Processing nested structures Undo operation in editor First In, First Out: Items enter at the rear, leave at the front Enqueue and Dequeue to add and remove Example Applications: Ensuring 'fair treatment' to each of a list of pending tasks (first come first served) 24/11/2006 CT229 15

17 Stack ADT Stack is a last in, first out list. No sort order assumed. Objects: A finite sequence of elements of the same type. Operations: n: Object s: Stack b: Boolean value s.push(n) s.pop() n s.top( ) n s.isempty( ) b s.isfull( ) b Place item n on to top of stack Remove top item from stack and returns it Examine the top item on stack without removing it Returns b = True if stack is empty Returns b = True if stack is full (relevant if it has limited storage) 24/11/2006 CT229 16

18 Stack Interface in Java Note: Built-in Stack class: java.util.stack Nonetheless, we will make our own Stack.java: public interface Stack { public void push(object n); public Object pop(); public Object top(); public boolean isempty(); public boolean isfull(); Other operations: size(); makeempty() Can implement this interface using array, linked list or other storage type 24/11/2006 CT229 17

19 Stack Array Implementation Index s Consider stack implemented as an array with indexes [0..N-1] Need to maintain a variable, numitems, which counts the number of items in the stack. numitems = 0 => stack is empty numitems = N => stack is full Also necessary to know the index of the top item and the index of the bottom item Two possibilities: (1) Top of stack is first index of array (2) Top of stack is last index of array 24/11/2006 CT229 18

20 Stack Array Implementation Index N-1 s Bottom Top Of these two possibilities, (2) is the more efficient As both Push and Pop occur at the top of the stack, it is better to have room at this end. The index of Top therefore holds the value numitems - 1 With possibility (1), items would have to be shuffled up and down the stack. 24/11/2006 CT229 19

21 ArrayStack.java An array-based stack implementation import javax.swing.joptionpane; public class ArrayStack implements Stack { protected int capacity; protected static final int CAPACITY = 1000; protected Object elements[]; protected int top = -1; // The actual capacity of the stack array // default array capacity // array used to implement the stack // index for the top of the stack public ArrayStack() { // default constructor: creates stack with default capacity capacity = CAPACITY; elements = new Object[capacity]; public ArrayStack(int cap) { // this constructor allows you to specify capacity of stack capacity = cap; elements = new Object[capacity]; 24/11/2006 CT229 20

22 ArrayStack.java push The method push should allow a user to place an object onto the stack public void push (Object element) { top++; elements[top] = element; 24/11/2006 CT229 21

23 ArrayStack.java push What if the stack is already full when we push a new element on? public void push(object element) { if (isfull()) { JOptionPane.showMessageDialog(null, "ERROR: stack is full."); return; top++; elements[top] = element; public boolean isfull() { return (top == capacity-1); 24/11/2006 CT229 22

24 ArrayStack.java pop public Object pop() { Object element; if (isempty()) { JOptionPane.showMessageDialog(null, "ERROR: stack is empty."); return null; element = elements[top]; elements[top] = null; top--; return element; public boolean isempty() { return (top < 0); 24/11/2006 CT229 23

25 ArrayStack.java top public Object top() { if (isempty()) { JOptionPane.showMessageDialog(null, "ERROR: stack is empty."); return null; return elements[top]; 24/11/2006 CT229 24

26 Using ArrayStack.java import javax.swing.joptionpane; public class StackTest { public static void main(string[] args) { // Create a Stack ArrayStackStack s = new ArrayStack(); time"); // Put some strings onto the stack JOptionPane.showMessageDialog(null, "About to push words onto stack: \nonce upon a s.push("once"); s.push("upon"); s.push("a"); s.push("time"); // Now pop them from the stack JOptionPane.showMessageDialog(null, "About to pop words from stack..."); while(! s.isempty()) { String word = (String)s.pop(); // Note: have to cast Objects popped to String JOptionPane.showMessageDialog(null, "Word popped: " + word); 24/11/2006 CT229 25

27 Queue ADT A Queue is a first-in, first out list. No sort order assumed. Objects: A finite sequence of elements of the same type. Front item has been in the queue longest; rear item entered the queue most recently Operations: e: Object q: Queue b: Boolean value enqueue(e) Place e at rear of q, assuming room dequeue e Remove front item from q and return it front( ) Return front element without removing it isempty( ) b Returns true if queue is empty isfull( ) b Returns true if queue is full 24/11/2006 CT229 26

28 Queue Interface in Java Queue.java: public interface Queue { public void enqueue(object n); public Object dequeue(); public boolean isempty(); public boolean isfull(); public Object front(); Other operations: size(); makeempty() Again, can implement this interface using various storage types We will use an array: ArrayQueue.java 24/11/2006 CT229 27

29 Queue Array Implementation With array implementation, items must be shuffled towards the front after a dequeue Note that with the array implementation, once Rear becomes equal to N-1 no further items can be enqueued (array space limitation) q Front Rear n = dequeue( ) ; enqueue (8); n = dequeue( ); n = dequeue( ); q /11/2006 CT229 28

30 ArrayQueue.java import javax.swing.joptionpane; public class ArrayQueue implements Queue { protected Object elements[]; protected int rear = -1; protected int capacity; public static final int CAPACITY = 1000; // array used to implement the Queue // index for the rear of the Queue // The actual capacity of the Queue array // default array capacity public ArrayQueue() { // default constructor: creates Queue with default capacity capacity = CAPACITY; elements = new Object[capacity]; public ArrayQueue(int cap) { // this constructor allows you to specify capacity capacity = cap; elements = new Object[capacity]; 24/11/2006 CT229 29

31 ArrayQueue.java public void enqueue(object element) { if (isfull()) { JOptionPane.showMessageDialog(null, "ERROR: Queue is full."); return; elements[++rear] = element; 24/11/2006 CT229 30

32 ArrayQueue.java public Object dequeue() { Object element; if (isempty()) { JOptionPane.showMessageDialog(null, "ERROR: elementsueue is empty."); return null; element = elements[0]; // shuffle all other elements to the front for (int i=0; i<rear; i++) elements[i] = elements[i+1]; elements[rear] = null; rear--; return element; 24/11/2006 CT229 31

33 ArrayQueue.java public Object front() { if (isempty()) { JOptionPane.showMessageDialog(null, "ERROR: Stack is empty."); return null; return elements[0]; 24/11/2006 CT229 32

34 import javax.swing.joptionpane; Using ArrayQueue.java public class QueueTest { public static void main(string[] args) { // Create a Queue ArrayQueue q = new ArrayQueue(); // Put some strings onto the queue JOptionPane.showMessageDialog(null, "About to enqueue words onto queue: \nthe end is nigh!"); q.enqueue("the"); q.enqueue("end"); q.enqueue("is"); q.enqueue("nigh!"); // Now dequeue them from the queue JOptionPane.showMessageDialog(null, "About to dequeue the words..."); while(! q.isempty()) { String word = (String)q.dequeue(); // Note: have to cast Objects popped to String JOptionPane.showMessageDialog(null, "Word dequeued: " + word); System.exit(0); 24/11/2006 CT229 33

35 End of Semester 1Material End of Semester 1 Enjoy the Christmas Break! 24/11/2006 CT229 34