Abstract Data Types II

1
Abstract Data Types II
2
Sufficient operations

• Operations on an ADT are sufficient if they meet
  all the requirements
• They must be able to create all the values and
  perform all the operations required by the
  application
• Remember that the application cannot directly
  access the internal values
• They should be able to create all the values and
  perform all the operations required by any
  application in a given class of applications

3
Necessary operations

• An operation on an ADT is necessary if omitting
  it would fail to meet the requirements
• If the application can implement an operation
  easily and efficiently by combining other
  operations, that operation is unnecessary
• Its OK to have unnecessary operations if they
  add significantly to the convenience of using the
  ADT

4
Convenience operations

• An operation is a convenience operation if it
  could be accomplished by some overly complex
  combination of other operations
• People like things simple
• A class with 50 or more methods is just
  overwhelming
• Convenience operations should be justified
• Will it be used often?
• Does it really simplify the users task?
• Would the user expect this operation to be
  provided?
• Is it significantly more efficient?

5
Necessary and sufficient operations

• A class should define a necessary and sufficient
  set of operations
• Convenience operations should be justified
• Similarly, a class should have a necessary and
  sufficient data representation
• In general, a class should not contain data that
  can be easily computed from other data in the
  class

6
Example Strings

• Necessary and sufficient operators
• A constructor public String(char chs)
• Ways to access data
• public int length()
• public charAt(int index)
• Would you be happy with just these?
• If you invented the String class, could you
  justify operations such as equals and string
  concatenation?
• Convenience operators arent all bad!

7
Types of operations

• A constructor is creates a value of the ADT from
  input values
• An accessor uses a value of the ADT to compute a
  value of some other type
• A transformer uses a value of the ADT to computer
  another value of the ADT
• A mutative transformer changes the value of the
  ADT it is given
• An applicative transformer takes one ADT and,
  without changing it, returns a new ADT

8
Requirements

• The constructors and transformers must together
  be able to create all legal values of the ADT
• Or, at least, any needed by the application
• For a general use ADT, this means all legal
  values
• The accessors must be able to extract any data
• Or, at least, any needed by the application

9
Operations in Java

• Constructors can be implemented with Java
  constructors
• A constructors job is to construct an object of
  a class in a valid state
• That should be a constructors only job
• Accessors and transformers can be implemented
  with Java methods
• Mutative transformers are typically (but not
  always) implemented as void methods
• Sometimes they both modify an object and return it

10
Factory methods

• The problem with a constructor is that it will
  always construct an object of a given type
• This isnt always what you want
• You may want to check the constructors
  parameters for validity
• You may want to return an existing object, if
  there is one
• For example, you really only need one EOL Token
• You may want to return objects of different types
• You can solve these problems by using a factory
  method
• Example
• public Animal create(String voice) if
  (voice.equals("woof")) return new Dog() if
  (voice.equals("meow")) return new Cat() if
  (voice.equals("moo")) return new Cow() throw
  new IllegalArgumentException(voice)

11
Another factory method

• class Token Type t Object v Token
  eolToken new Token(Type.EOL, "\n")
  private Token(Type t, Object v) // constructor
  this.t t this.v v
  public Token create(Type t, Value v) if
  (t Type.EOL) return eolToken else
  return new Token(t, v)

12
Example ADT String

• Constructors
• "This is syntactic sugar for a constructor"
• public String(char chs)
• Accessors
• public int length()
• public char charAt()
• Transformers (applicative only)
• public String substring(int i, int j)
• public String concat(String that) (also )
• Etc.

13
Immutable objects

• A String is immutable it cannot be changed
• The String class has no mutative transformers
• Operations such as string concatenation create
  new Strings
• Advantages
• Efficient (for most uses)
• Easy to use and simple to understand (changing a
  String in one object doesnt change it in other
  objects)
• Disadvantage
• Every call to a transformer creates a new String

14
Example StringBuilder

• Constructors
• public StringBuilder(String s)
• Accessors
• public int length()
• public char charAt()
• Transformers (applicative)
• none
• Transformers (mutative)
• public StringBuilder append(Object obj)
• Etc.

15
Mutable objects

• A StringBuilder is mutable it can be changed
• The StringBuilder class has both applicative and
  mutative transformers
• Advantage
• Efficient (for doing a lot of string
  manipulation)
• Disadvantage
• Can be confusing (example coming up shortly)
• Operations on Strings are done by converting to
  StringBuffers (like StringBuilders), doing the
  work, and converting back

16
Safe use of Strings

• public class Person
• private String name
• Person(String name) this.name name
• String jan "Jan"
• Person doctor new Person(jan)
• String dan "D" jan.substring(1, 2)
• Person secretary new Person(dan)

17
Unsafe use of StringBuilders

• public class Person
• private StringBuilder name
• Person(StringBuilder name) this.name
  name
• StringBuilder buffer new StringBuilder("Jan")
• Person doctor new Person(buffer)
• buffer.setCharAt(0, 'D')
• Person secretary new Person(buffer)

18
Summary

• A class should define a necessary and sufficient
  set of operations
• Convenience operations should be justified
• Operations can be classified as
• Constructors
• Accessors
• Transformers (applicative or mutative)
• Immutable objects are often preferable to mutable
  objects

19
The End