Designing Classes Chapter 3

Contents Encapsulation Specifying Methods Java Interfaces – Writing an Interface – Implementing an Interface – An Interface as a Data Type – Generic Types Within an Interface – Type Casts Within an Interface Implementation – Extending an Interface – Interfaces Versus Abstract Classes – Named Constants Within an Interface

Contents Choosing Classes – Identifying Classes – CRC Cards – The Unified Modeling Language Reusing Classes

Encapsulation Hides the fine detail of the inner workings of the class – The implementation is hidden – Often called "information hiding" Part of the class is visible – The necessary controls for the class are left visible – The class interface is made visible – The programmer is given only enough information to use the class

Encapsulation Fig. 3-1 An automobile's controls are visible to the driver, but its inner workings are hidden.

Abstraction A process that has the designer ask what instead of why – What is it you want to do with the data – What will be done to the data The designer does not consider how the class's methods will accomplish their goals The client interface is the what The implementation is the how

Abstraction Fig. 3-2 An interface provides well-regulated communication between a hidden implementation and a client.

Specifying Methods Specify what each method does Precondition – Defines responsibility of client code Postcondition – Specifies what will happen if the preconditions are met

Specifying Methods Responsibility – Precondition implies responsibility for guarantee of meeting certain conditions Where to place responsibility – Client? or … – Method? Best to comment this clearly before method's header – Also good to have method check during debugging

Specifying Methods Assertion is statement of truth about aspect of a program's logic – Like a boolean statement that should be true at a certain point Assertions can be written as comments to identify design logic // Assertion: intVal >= 0 Assert Statement – assert someVal < 0; – If false, program execution terminates

Java Interface A program component that contains – Public constants – Signatures for public methods – Comments that describe them Begins like a class definition – Use the word interface instead of class

Writing an Interface Consider geometric figures which have both a perimeter and an area We want classes of such objects to have such methods – And we want standardization signatures View example of the interface Measurable View example

Java Interface Example Recall class Name from previous chapterclass Name Consider an interface for the class Name – View example listing View example Note – Comments of method purpose, parameters, pre- and post-conditions – Any data fields should be public, final, and static – Interface methods cannot be final

Implementing an Interface A class that implements an interface must state so at start of definition with implements clause The class must implement every method declared in the interface Multiple classes can implement the same interface A class can implement more than one interface

Implementing an Interface Fig. 3-3 The files for an interface, a class that implements the interface, and the client.

An Interface as a Data Type An interface can be used as a data type or …

Generic Types Within an Interface Recall class OrderedPair from Chapter 2 OrderedPair – Note the setPair method Consider an interface Pairable that declares this method A class that implements this interface could begin with the statement

The Interface Comparable Method compareTo compares two objects, say x and y – Returns signed integer – Returns negative if x < y – Returns zero if x == y – Returns positive if x > y

The Interface Comparable Consider a class Circle – Methods equals, compareTo – Methods from Measurable View source code View source Note – Implements Measurable interface – Shown with two alternative versions of compareTo

Extending an Interface Use inheritance to derive an interface from another When an interface extends another – It has all the methods of the inherited interface – Also include some new methods Also possible to combine several interfaces into a new interface – Not possible with classes

Interfaces Versus Abstract Classes Purpose of interface similar to purpose of abstract class But … an interface is not a base class – It is not a class of any kind Use an abstract base class when – You need a method or private data field that classes will have in common Otherwise use an interface

Named Constants Within an Interface An interface can contain named constants – Public data fields initialized and declared as final Consider an interface with a collection of named constants – Then derive variety of interfaces that can make use of these constants

Choosing Classes Look at a prospective system from a functional point of view Ask – What or who will use the system – What can each actor do with the system – Which scenarios involve common goals Use a case diagram

Choosing Classes Fig. 3-4 A use case diagram for a registration system

Identifying Classes Describe the system – Identify nouns and verbs Nouns suggest classes – Students – Transactions – Customers Verbs suggest appropriate methods – Print an object – Post a transaction – Bill the customer

Identifying Classes Fig. 3-5 A description of a use case for adding a course

CRC Cards Index cards – each card represents one class Write a descriptive name for class at top List the class's responsibilities – The methods Indicate interactions – The collaborations These are CRC cards "Class-Responsibility-Collaboration"

CRC Cards Fig. 3-6 A class-responsibility-collaboration card

Unified Modeling Language Used to illustrate a system's classes and relationships Provides a class diagram – Class name – Attributes – Operations Fig. 3-7 A class representation that can be part of a class diagram.

Unified Modeling Language Fig. 3-8 UML notation for a base class Student and two derived classes

Unified Modeling Language Fig. 3-9 A class diagram showing the base class Student and two derived classes

Unified Modeling Language Fig Part of a UML class diagram with associations.

Reusing Classes Much software combines: – Existing components – New components When designing new classes – Plan for reusability in the future – Make objects as general as possible – Avoid dependencies that restrict later use by another programmer

Interfaces A Java interface is a collection of abstract methods and constants An abstract method is a method header without a method body An abstract method can be declared using the modifier abstract, but because all methods in an interface are abstract, usually it is left off An interface is used to establish a set of methods that a class will implement

Interfaces public interface Doable { public void doThis(); public int doThat(); public void doThis2 (float value, char ch); public boolean doTheOther (int num); } interface is a reserved word None of the methods in an interface are given a definition (body) A semicolon immediately follows each method header

Interfaces An interface cannot be instantiated Methods in an interface have public visibility by default A class formally implements an interface by – stating so in the class header – providing implementations for each abstract method in the interface If a class asserts that it implements an interface, it must define all methods in the interface

Interfaces public class CanDo implements Doable { public void doThis () { // whatever } public void doThat () { // whatever } // etc. } implements is a reserved word Each method listed in Doable is given a definition

Interfaces A class that implements an interface can implement other methods as well In addition to (or instead of) abstract methods, an interface can contain constants When a class implements an interface, it gains access to all its constants

Interfaces An example of an interface in use

SecretTest.java //******************************************************************** // SecretTest.java Java Foundations // // Demonstrates the use of a formal interface. //******************************************************************** public class SecretTest { // // Creates a Secret object and exercises its encryption. // public static void main (String[] args) { Secret hush = new Secret ("Wil Wheaton is my hero!"); System.out.println (hush); hush.encrypt(); System.out.println (hush); hush.decrypt(); System.out.println (hush); }

Encryptable.java //******************************************************************** // Encryptable.java Java Foundations // // Represents the interface for an object that can be encrypted // and decrypted. //******************************************************************** public interface Encryptable { public void encrypt(); public String decrypt(); }

Secret.java //******************************************************************** // Secret.java Java Foundations // // Represents a secret message that can be encrypted and decrypted. //******************************************************************** import java.util.Random; public class Secret implements Encryptable { private String message; private boolean encrypted; private int shift; private Random generator; // // Constructor: Stores the original message and establishes // a value for the encryption shift. // public Secret (String msg) { message = msg; encrypted = false; generator = new Random(); shift = generator.nextInt(10) + 5; } (more…)

Secret.java // // Encrypts this secret using a Caesar cipher. Has no effect if // this secret is already encrypted. // public void encrypt () { if (!encrypted) { String masked = ""; for (int index=0; index < message.length(); index++) masked = masked + (char)(message.charAt(index)+shift); message = masked; encrypted = true; } (more…)

Secret.java // // Decrypts and returns this secret. Has no effect if this // secret is not currently encrypted. // public String decrypt() { if (encrypted) { String unmasked = ""; for (int index=0; index < message.length(); index++) unmasked = unmasked + (char)(message.charAt(index)-shift); message = unmasked; encrypted = false; } return message; } // // Returns true if this secret is currently encrypted. // public boolean isEncrypted() { return encrypted; } (more…)

Secret.java // // Returns this secret (may be encrypted). // public String toString() { return message; }

Interfaces A class can implement multiple interfaces The interfaces are listed in the implements clause The class must implement all methods in all interfaces listed in the header class ManyThings implements interface1, interface2 { // all methods of both interfaces }

Interfaces The Java standard class library contains many helpful interfaces The Comparable interface contains one abstract method called compareTo, which is used to compare two objects We discussed the compareTo method of the String class in Chapter 4 The String class implements Comparable, giving us the ability to put strings in lexicographic order

The Comparable Interface Any class can implement Comparable to provide a mechanism for comparing objects of that type if (obj1.compareTo(obj2) < 0) System.out.println ("obj1 is less than obj2"); The value returned from compareTo should be negative is obj1 is less that obj2, 0 if they are equal, and positive if obj1 is greater than obj2 When a programmer designs a class that implements the Comparable interface, it should follow this intent

The Comparable Interface It’s up to the programmer to determine what makes one object less than another For example, you may define the compareTo method of an Employee class to order employees by name (alphabetically) or by employee number The implementation of the method can be as straightforward or as complex as needed for the situation

The Iterator Interface As we discussed in Chapter 4, an iterator is an object that provides a means of processing a collection of objects one at a time An iterator is created formally by implementing the Iterator interface, which contains three methods The hasNext method returns a boolean result – true if there are items left to process The next method returns the next object in the iteration The remove method removes the object most recently returned by the next method

The Iterator Interface By implementing the Iterator interface, a class formally establishes that objects of that type are iterators The programmer must decide how best to implement the iterator functions Once established, the for-each version of the for loop can be used to process the items in the iterator

Interfaces You could write a class that implements certain methods (such as compareTo ) without formally implementing the interface ( Comparable ) However, formally establishing the relationship between a class and an interface allows Java to deal with an object in certain ways Interfaces are a key aspect of object-oriented design in Java

Polymorphism via Interfaces An interface name can be used as the type of an object reference variable Speaker current; The current reference can be used to point to any object of any class that implements the Speaker interface The version of speak that the following line invokes depends on the type of object that current is referencing current.speak();

Polymorphism via Interfaces Suppose two classes, Philosopher and Dog, both implement the Speaker interface, providing distinct versions of the speak method In the following code, the first call to speak invokes one version and the second invokes another Speaker guest = new Philospher(); guest.speak(); guest = new Dog(); guest.speak();

Event Processing Polymorphism plays an important role in the development of a Java graphical user interface As we’ve seen, we establish a relationship between a component and a listener JButton button = new JButton(); button.addActionListener(new MyListener()); Note that the addActionListener method is accepting a MyListener object as a parameter In fact, we can pass the addActionListener method any object that implements the ActionListener interface

Event Processing The source code for the addActionListener method accepts a parameter of type ActionListener (the interface) Because of polymorphism, any object that implements that interface is compatible with the parameter reference variable The component can call the actionPerformed method because of the relationship between the listener class and the interface Extending an adapter class to create a listener represents the same situation; the adapter class implements the appropriate interface already