Arrays –Collections (Set, Database, History) Inheritance –inheriting ancestor’s traits –inheriting benefactor’s assets –inheriting instance members( methods/variables) IS-A Relationship –human IS-A Mammal –salmon IS-A Fish –“Joe Doe” IS-A Student –ALoan IS-A Loan

Strings = Char Sequences JohnF.Kenndye hello String{sequences of characters} 143l0

Other Sequences as Predefined Types {sequences of integers} 80 JFKFDR {sequence of Strings} JCBCRRGB {sequences of doubles} IntSequence DoubleSequence StringSequence

Sequences of Programmer-Defined Type loan1loan2 {sequence of loans} loan3 temperature1 {sequence of temperatures} temperature2temperature3 temperature1temperature2 TemperatureSequence LoanSequenceLoan[] Temperature[] Array Types Arrays Array Element

Other Sequences as Array Types {sequences of integers} 80 {sequence of strings} {sequences of doubles} int[] double[] String[] JFKFDRJCBCRRGB

Initializing Array Declarations int[] assignmentScores = {100, 98, 99, 80}; double[] gpas = {3.8, 3.1, 3.7, 3.1, 3.6, 3.9};String[] initials = {“JFK”, “FDR”, “JC”, “BC”, “GW”, “WW”}; JFKFDRJCBCGWWW assignmentScores Array Type Element Type Array Literal Array Variable

Initializing Array Declaration [] = {, …, } Loan [] loans = {new ALoan(100000), new AnotherLoan (100)};

Array Operations String[] initials = {“JFK”, “FDR”, “JC”, “BC”, “GW”, “WW”}; JFKFDRJCBCGWWW initials.length  6 initials[0] initials[initials.length - 1] initials[initials.length]  ArrayIndexOutOfBoundsException public named constant initials[0] = “HT” HT initials[initials.length] = “HT”  ArrayIndexOutOfBoundsException Array Instance Size Fixed

Array Types have Variable-Size int[] int[] assignmentScores = {100, 98, 99, 100, 99, 80}; assignmentScores assignmentScores = {60, 40, 50}; assignmentScores

Uninitializing Array Declaration int[] assignmentScores; assignmentScores null assignmentScores = {60, 40, 50}; assignmentScores

Array Elements Uninitialized int[] assignmentScores = new int[3]; assignmentScores 000

Object Array Elements Uninitialized String[] initials = new String[3]; initials null

Uninitialized Array Vs Element String[] initials = new String[3]; initials null String[] initials; initials null initials[0]  null initials[0] initials[0].charAt(0)  StringIndexOutOfBounds  ArrayIndexOutOfBoundsException

Example

getStrings() static String[] getStrings() { System.out.println("Number of Strings:"); int numElements = Keyboard.readInt(); System.out.println("Please enter " + numElements + " strings"); String[] strings = new String[numElements]; for (int elementNum = 0; elementNum < numElements; elementNum++) strings[elementNum] = Keyboard.readLine(); return strings; } variable

print() static void print(String[] strings) { System.out.println("******************"); for ( int elementNum = 0; elementNum < strings.length; elementNum++) System.out.println(strings[elementNum]); System.out.println("******************"); } String array of arbitrary dimension (size)

main() public static void main(String[] args){ String[] names = getStrings(); while (true) { String command = Keyboard.readLine(); if (command.length > 0 && command.charAt(0) == 'q') break; if (command.length > 0 && command.charAt(0) == 'p') print(names); }

main()

Variable-Size Collection filled part unfilled part current size maximum size

3 James Dean Joe Doe Jane Smith sizearray Variable-Size Collection filled part unfilled part current size maximum size

Variable-Size Collection public class { … final static int A_MAX_SIZE = 50; String[] a = new String [MAX_SIZE]; int aSize = 0; … //process a for (int index = 0; index < aSize; index++) System.out.println(a[index]); … final int B_MAX_SIZE = 50; String[] b = new String [MAX_SIZE]; int bSize = 0; //process b … }

Special Type public class {... AVariableSizeCollection a = new AVariableSizeCollection();... for (int index = 0; index < a.size; index++) System.out.println(a.contents[index]); … AVariableSizeCollection b = new AVariableSizeCollection();... } public class AVariableSizeCollection { public static final int MAX_SIZE = 50; public String[] contents = new String [MAX_SIZE]; public int size = 0; } No encapsulation! a.contents[a.size] = Keyboard.readString(); Size not updated

Supporting Encapsulation public interface …. { public static final int MAX_SIZE = 50; } public void addElement (String element); public void print (); Implementation specific User specific

History public interface StringHistory { } public void addElement (String element); public int size(); public String elementAt (int index);

Implementing a History public class AStringHistory implements StringHistory { public final int MAX_SIZE = 50; String[] contents = new String[MAX_SIZE]; int size = 0; public int size() { return size;} public String elementAt (int index) { return contents[index]; } boolean isFull() { return size == MAX_SIZE; } public void addElement(String element) { if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; }

Using a History public static void main(String[] args) { StringHistory names = new AStringHistory(); while (true) { String input = Keyboard.readLine(); if (input.length > 0) if (input.charAt(0) == 'q') break; else if (input.charAt(0) == 'p' ) print(names); else names.addElement(input); }

Printing a History static void print(StringHistory strings) { System.out.println("******************"); for ( int elementNum = 0; elementNum < strings.size(); elementNum++) System.out.println(strings.elementAt(elementNum)); }

Database

public interface StringDatabase { //from history public int size(); public void addElement (String element); public String elementAt (int index); //additional methods } public void member (String element); public void deleteElement(String element); public void clear();

deleteElement (String element) 4 James Dean Joe Doe Jane Smith sizearray John Smith deleteElement(“Joe Doe”); public void deleteElement (String element) { contents[indexOf(element)] = contents[size - 1]; size--; } John Smith 3 Elements out of order!

deleteElement (String element) 4 James Dean Joe Doe Jane Smith sizearray John Smith deleteElement(“Joe Doe”); public void deleteElement (String element) { shiftUp(indexOf(element)); } 1 index

Multi-element window 4 James Dean Joe Doe Jane Smith sizearray John Smith deleteElement(“Joe Doe”); public void deleteElement (String element) { shiftUp(indexOf(element)); } Jane Smith 1 index contents[index] = contents[index + 1];

deleteElement (String element) 4 James Dean Joe Doe Jane Smith sizearray John Smith deleteElement(“Joe Doe”); public void deleteElement (String element) { shiftUp(indexOf(element)); } Jane Smith John Smith 3 void shiftUp (int startIndex) { for (int index = startIndex ; index + 1 < size; index++) contents[index] = contents[index + 1]; size--; } 2 index

indexOf (String element) 4 James Dean Joe Doe Jane Smith sizearray John Smith indexOf(“Joe Doe”); 0 index

indexOf (String element) 4 James Dean Joe Doe Jane Smith sizearray John Smith deleteElement(“Joe Doe”); 1 index public int indexOf (String element) { for ( index = 0; index < size && !element.equals(contents[index]; index++) ; return index; }

public boolean member(String element) 4 James Dean Joe Doe Jane Smith sizearray John Smith member(“Joe Doe”); public int indexOf (String element) { for ( index = 0; index < size && !element.equals(contents[index]; index++) ; return index; } public boolean member (String element) { } return indexOf (element) < size;

public void clear() 4 James Dean Joe Doe Jane Smith sizearray John Smith clear() public void clear() { while ( size > 0) deleteElement(size -1); } 3210

public void clear() 4 James Dean Joe Doe Jane Smith sizearray John Smith clear() public void clear() { size = 0; } 0

addElement(“Mary Doe”) 4 Mary Doe Joe Doe Jane Smith sizearray John Smith 1

Logical but not Physical Extensions clear( ) elementAt( ) size( ) member( ) deleteElement( ) addElement( ) String Database String History size( ) elementAt( ) addElement( ) IMPLEMENTS elementAt( ) member( ) deleteElement( ) indexOf( ) size( ) addElement( ) shiftUp( ) size contents MAX_SIZE AString Database clear( ) MAX_SIZE size contents size( ) addElement( ) elementAt( ) AString History isFull( )

Database public interface StringDatabase { //from history public int size(); public void addElement (String element); public String elementAt (int index); //additional methods } public void member (String element); public void deleteElement(String element); public void clear();

Physical and Logical Extensions String History size( ) elementAt( ) addElement( ) EXTENDS member( ) deleteElement( ) String Database clear( ) member( ) deleteElement( ) indexOf( ) shiftUp( ) AString Database clear( ) IMPLEMENTS EXTENDS Supertype Subtype MAX_SIZE size contents size( ) addElement( ) elementAt( ) AString History isFull( ) Superclass Subclass

Extending an Interface public interface StringDatabase extends StringHistory { } public void member (String element); public void deleteElement(String element); public void clear(); public interface StringHistory { } public void addElement (String element); public int size(); public String elementAt (int index); extends/ inherits from Inherited members

Extending a Class public class AStringDatabase extends AStringHistory implements StringDatabase { public void deleteElement (String element) { … } int indexOf (String element) { … } void shiftUp (int startIndex) { … } public boolean member(String element) { } public void clear() { } }

Physical and Computer Inheritance Human AStringDatabase Physical Object Animal Mammal Primate AStringHistory String Object Implicit extension Regular Accord Deluxe Accord Car Vehicle StringDatabase StringHistory

No Explicit Extension public class AStringHistory implements StringHistory { public final int MAX_SIZE = 50; String[] contents = new String[MAX_SIZE]; int size = 0; public int size() { return size;} public String elementAt (int index) { return contents[index]; } boolean isFull() { return size == MAX_SIZE; } public void addElement(String element) { if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; }

Equivalent Class Definition public class AStringHistory extends Object implements StringHistory { public final int MAX_SIZE = 50; String[] contents = new String[MAX_SIZE]; int size = 0; public int size() { return size;} public String elementAt (int index) { return contents[index]; } boolean isFull() { return size == MAX_SIZE; } public void addElement(String element) { if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; }

Some Methods of Class Object MAX_SIZE size contents size( ) addElement( ) elementAt( ) member( ) deleteElement( ) indexOf( ) shiftUp( ) AString Database AString History EXTENDS clear( ) isFull( ) Object EXTENDS toString( ) equals( ) clone( ) (new AStringHistory()).toString() (new AStringDatabase()).toString() (new ALoan()).toString() “hello”.toString() ‘h’.toString() 5.toString() Used by println()

IS-A Relationships Object StringHistoryAStringHistoryString AStringDatabaseStringDatabase implementsextends

IS-A & Polymorphism public static Loan add(Loan loan1, Loan loan2) { return new ALoan(loan1.getPrincipal() + loan2.getPrincipal())); } AnotherLoan Instance ALoan Instance Actual Parameters of different types IS-A

Printing a History static void print(StringHistory strings) { System.out.println("******************"); for ( int elementNum = 0; elementNum < strings.size(); elementNum++) System.out.println(strings.elementAt(elementNum)); } AStringHistory Instance AStringDatabase Instance AStringHistory IS-A StringHistory AStringDatabase IS-A AStringHistory AStringDatabase IS-A StringHistory

Assignment Rules for Primitive Types If T1 narrower than T2 (Set of instances of T1  Set of instances of T2) Expression of type T1 can be assigned to Variable of type T2 Expression of type T2 can be assigned to Variable of type T1 with cast.

Assignment Rules for Object Types If T1 IS-A T2 Expression of type T1 can be assigned to Variable of type T2 Expression of type T2 can be assigned to Variable of type T1 with cast.

IS-A Definition Implements: T1 implements T2 => T1 IS-A T2 Extends: T1 extends T2 => T1 IS-A T2 Transitive: –T1 IS-A T2 –T2 IS-A T3 –=> T1 IS-A T3 Reflexive: –T1 == T2 => T1 IS-A T2

Type Checking Examples StringHistory stringHistory = new AStringDatabase(); StringDatabase stringDatabase = new AStringHistory();

Getting an Upgrade Regular Model Requested ARegularModel myCar = new ADeluxeModel (); ((ADeluxeModel) myCar). setCity(“Raleigh”); Deluxe Model Assigned myCar.steer(); Navigation System myCar. setCity(“Raleigh”);

Getting a Downgrade Deluxe Model Requested ADeluxeModel myCar = new ARegularModel (); Regular Model Assigned myCar.steer(); myCar. setCity(“Raleigh”);

Type Checking Examples StringHistory stringHistory = new AStringDatabase(); stringHistory.size() stringDatabase.clear() ((StringDatabase) stringHistory).clear() StringDatabase stringDatabase = new AStringHistory(); stringHistory.clear()

Type Checking Examples Object[] objects = { “Joe Doe”, new AStringDatabase(), new AStringHistory()}; String[] strings = { “Joe Doe”, new Object()};

Database

Set

Overriding Inherited Methods MAX_SIZE size contents size( ) addElement( ) elementAt( ) member( ) deleteElement( ) indexOf( ) shiftUp( ) AString Database AString History EXTENDS clear( ) isFull( ) Object EXTENDS toString( ) equals( ) clone( ) AString Set addElement( ) Overriden Method Overriding Method

Overriding addElement() public void addElement(String element) { if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; } public void addElement(String element) { if (member(element)) return; if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; }

super public void addElement(String element) { if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; } public void addElement(String element) { if (member(element)) return; super.addElement(); } inherited addElement()

Omitting Super public void addElement(String element) { if (isFull()) System.out.println("Adding item to a full history"); else { contents[size] = element; size++; } public void addElement(String element) { if (member(element)) return; addElement(); } Recursive call

More Overriding MAX_SIZE size contents size( ) addElement( ) elementAt( ) member( ) deleteElement( ) indexOf( ) shiftUp( ) AString Database AString History EXTENDS clear( ) isFull( ) Object EXTENDS toString( ) equals( ) clone( ) AString Set addElement( ) Overriden Method Overriding Method toString( )

More Overriding public String toString() { String retVal = “”; for (int i = 0; i < size; i++) retVal += “:” + contents[i]; return retVal; } stringSet.toString()  stringSet.toString()  “James Dean:John Smith”

Motivation for Switch public static void main(String args[]) { StringDatabase names = new AStringDatabase(); while (true) { String input = Keyboard.readLine(); if (!(input.length() == 0)) if (input.charAt(0) == 'q') break; else if (input.charAt(0) == 'p') print(names); else if (input.charAt(0) == 'd') names.deleteElement(input.substring(2, input.length())); else if (input.charAt(0) == 'm') System.out.println(names.member(input.substring(2, input.length()))); else if (input.charAt(0) == 'c') names.clear(); else names.addElement(input); }

Main with Switch public static void main(String args[]) { StringDatabase names = new AStringDatabase(); while (true) { String input = Keyboard.readLine(); if (!(input.length() == 0)) if (input.charAt(0) == 'q') break; else switch (input.charAt(0)) { case 'p': print(names); break; case 'd': names.deleteElement(input.substring(2, input.length())); break; case 'm': System.out.println(names.member(input.substring(2, input.length()))); break; case 'c': names.clear(); break; default: names.addElement(input); } Breaks out of the loop Breaks out of the switch Switch expression Switch arm Switch case (value of switch expressiuon)

Multi-case arms public static void main(String args[]) { StringDatabase names = new AStringDatabase(); while (true) { String input = Keyboard.readLine(); if (!(input.length() == 0)) if (input.charAt(0) == 'q') break; else switch (input.charAt(0)) { case 'p’, ‘P’: print(names); break; case 'd’, ‘D’: names.deleteElement(input.substring(2, input.length())); break; case 'm’, ‘M’: System.out.println(names.member(input.substring(2, input.length()))); break; case 'c’, ‘C’: names.clear(); break; default: names.addElement(input); }

Omitting break public static void main(String args[]) { StringDatabase names = new AStringDatabase(); while (true) { String input = Keyboard.readLine(); if (!(input.length() == 0)) if (input.charAt(0) == 'q') break; else switch (input.charAt(0)) { case 'p’, ‘P’: print(names); case 'd’, ‘D’: names.deleteElement(input.substring(2, input.length())); case 'm’, ‘M’: System.out.println(names.member(input.substring(2, input.length()))); case 'c’, ‘C’: names.clear(); default: names.addElement(input); }

Illegal Switch switch (input ){ case “print”: print(names); case “clear”: names.clear(); default: names.addElement(input); } Type of switch expression must be ordinal type

Ordinal Type Values of type are ordered. Each value has a unique successor and predecessor intcharStringdouble