Object-Oriented Design and Programming (Java)

Transcription

1 Object-Oriented Design and Programming (Java)

2 Topics Covered Today 2.2 Collections Arrays Vectors and Iterators Implementing the Collections of the Library System 2

3 What is a Collection? A collection object sometimes called a container is simply an object that groups multiple elements into a single unit Collections are used to store, retrieve, manipulate, and communicate aggregate data Typically, they represent data items that form a natural group, such as a poker hand (a collection of cards), a mail folder (a collection of letters), or a telephone directory (a mapping of names to phone numbers). 3

4 Array Group data objects of the same type 数组是同类数据的集合 数组中的每一项叫元素 (element), 用 [] 和下标值 ( 整型 ) 来访问, 下标值从 0 开始 ; Declare arrays char ch[]; or char[] ch; Create space for a reference Remember an array is an object not memory reserved for primitive types 4

5 Creating an Array Use the new keyword to create an array object new datatype[arraysize] int[] anarray = new int[10]; The statement in the sample program allocates an array with enough memory for ten integer elements and assigns the array to the variable anarray declared earlier. 5

6 Accessing an Array Element Now that some memory has been allocated for the array, the program assign values to the array elements: for (int i=0; i<anarray.length; i++) { anarray[i] = i; System.out.print(anArray[i] + " "); Note that in Java, array indices begin at 0 and end at the array length minus 1. 6

7 Example Array class ArrayDemo { public static void main(string[] args) { // declare an array of integers and create an array of integers int[] anarray = new int[10]; // assign a value to each array element and print for (int i=0; i< anarray.length; i++) { anarray[i] = i; System.out.print(anArray[i] + " "); System.out.println(); 7

8 Initializing an array Java provides a shortcut syntax for creating and initializing an array. int[] x = { 1, 3, 5, 7, 9 ; String[] strdays = { Mon, Wed, Fri ; boolean[] answers = { true, false, true, true ; 8

9 Arrays Summary The size of an array is fixed at the time it is created and can not be changed afterwards. Any attempt to access an element outside the length of an array will throw an ArrayIndexOutOfBoundsException. All the elements stored in the array must be of the same type or class. An array has a public attribute called length which indicates the number of elements that it contains. The elements contained in an array can also be arrays! (And the elements in those arrays can be arrays, and so on ). These are known as multi-dimensional 9

10 Example Using Arrays Dictionary.java 10

11 java.util.vector Package java.util The Vector class implements a growable array of objects. The size of a Vector can grow or shrink as needed to accommodate adding and removing items after the Vector has been created. The objects in the vector can be accessed using an integer index. 11

12 methods defined in class Vector Vector(). Constructs an empty collection. int size(). Returns the number of objects in the collection. boolean isempty(). Determines if there are no objects in the collection. boolean contains(object elem). Determines if the specified object is an element of the collection (as determined by the method equals). boolean add(e o). Appends the specified object to the end of the collection. void add(int index, E element). Inserts the specified object at the specified index position, shifting any subsequent elements to the right (adds one to their indices). E get(int index). Returns the object at the specified position. public E set(int index, E element). Replaces the element at the specified index position with the specified object. public boolean remove(object o). Removes the first occurrence of the specified object (using method equals), shifting any subsequent elements to the left (subtracts one from their indices). E remove(int index). Returns the object at the specified position after first removing it from the collection and shifting any subsequent elements to the left (subtracts one from their indices). 12

13 using Vector import java.util.vector; public class test { public static void main(string[] args) { Vector vector = new Vector(); vector.add("hello"); vector.add(new Integer(10)); vector.add(new Employee("John Smith")); String string = (String) vector.get(0); Integer integer = (Integer) vector.get(1); Employee employee = (Employee) vector.get(2); System.out.println(string); System.out.println(integer); System.out.println(employee); 13

14 Generic Types in Java 5 When using a collection (e.g., LinkedList, HashSet, HashMap), we generally have a single type T of elements that we store in it (e.g., Integer, String) Before 1.5, when extracting an element, had to cast it to T before we could invoke T's methods Compiler could not check that the cast was correct at compile-time, since it didn't know what T was Inconvenient and unsafe, could fail at runtime 14

15 Generic Types in Java 5. Generics in Java 1.5 provide a way to communicate T, the type of elements in a collection, to the compiler Compiler can check that you have used the collection consistently Result: safer and more-efficient code 15

16 Vector (Using Generic Type) Before JDK5.0: String string = (String) vector.get(0); JDK5.0 Vector<String> vector = new Vector<String>(); vector.add("hello"); String hello = vector.elementat(0); 16

17 The ArrayList Class The class java.util.arraylist<e> implements a collection of objects that can grow to accommodate new items when the collection is full. 17

18 Methods Defined in Class ArrayList ArrayList(). Constructs an empty collection. int size(). Returns the number of objects in the collection. boolean isempty(). Determines if there are no objects in the collection. boolean contains(object elem). Determines if the specified object is an element of the collection (as determined by the method equals). boolean add(e o). Appends the specified object to the end of the collection. void add(int index, E element). Inserts the specified object at the specified index position, shifting any subsequent elements to the right (adds one to their indices). E get(int index). Returns the object at the specified position. public E set(int index, E element). Replaces the element at the specified index position with the specified object. public boolean remove(object o). Removes the first occurrence of the specified object (using method equals), shifting any subsequent elements to the left (subtracts one from their indices). E remove(int index). Returns the object at the specified position after first removing it from the collection and shifting any subsequent elements to the left (subtracts one from their indices). 18

19 ArrayList Example ArrayList<Employee> employees = new ArrayList<Employee>(); employees.add(new Employee("John Smith")); employees.add(new Employee("Mary Williams")); employees.add(new Employee("Peter Jefferson")); Employee firstemployee = employees.get(0); 19

20 ArrayList Example ArrayList<Integer> numbers = new ArrayList<Integer>(); numbers.add(1); int num = numbers.get(0); 20

21 java.util.iterator<e> An iterator is an object for traversing a vector from start to finish. Iterator 是一个用于遍历 Vector 中的每个元素的对象 The ArrayList method iterator() returns a java.util.iterator<e> object over the elements Methods of Iterator: boolean hasnext(). Returns true if the iteration has more elements. E next(). Returns the next element in the iteration. void remove(). Removes from the collection the last element returned by the iterator. 21

22 Using Iterator ArrayList<String> list = new Arralist<String>(); list.add("arraylist"); list.add(" and "); list.add("iterators"); String result = ""; for (Iterator<String> listiterator = list.iterator(); listiterator.hasnext(); ) { result += listiterator.next(); stdout.println(result); 22

23 Unit Example Dictionary.java 23

24 Using the For-Each Loop in Collections ArrayList<String> list = new Arralist<String>(); list.add("arraylist"); list.add(" and "); list.add("for-each"); String result = ""; for (String element : list) { result += element; stdout.println(result); 24

25 Implementing Collection Class 25

26 Implement class Client import java.util.*; public class Client implements Iterable<BankAccount> { /* Name of client */ private String name; /* Collection of <code>bankaccounts</code> objects.*/ private ArrayList<BankAccount> accounts; 26

27 Implement class Client /** * Constructs a <code>client</code> object. * <p> * Creates an empty collection of bank accounts. * </p> * initialname the name of the client. */ public Client(String initialname) { this.name = initialname; this.accounts = new ArrayList<BankAccount>(); 27

28 Implement class Client /** * Adds a bank account to this client. * bankaccount the {@link BankAccount object. */ public void addaccount(bankaccount bankaccount) { this.accounts.add(bankaccount); 28

29 Implement class Client /** * Returns an iterator over the bank accounts of this client. * * return an {@link Iterator over the bank accounts of this * client. */ public Iterator<BankAccount> iterator() { return this.accounts.iterator(); 29

30 Implement class Client /** * Returns the number of bank account of this client. * the number of bank account of this client. */ public int getnumberofaccounts() { return this.accounts.size(); 30

31 TestClient.java public class TestClient { private static PrintWriter stdout = new PrintWriter(System.out, true); private static PrintWriter stderr = new PrintWriter(System.err, true); public static void main(string[] args) { BankAccount accountone = new BankAccount(); BankAccount accounttwo = new BankAccount(); BankAccount accountthree = new BankAccount(); accountone.deposit(1000.0); accounttwo.deposit(2000.0); accountthree.deposit(3000.0); Client client= new Client("John Smith"); client.addaccount(accountone); client.addaccount(accounttwo); client.addaccount(accountthree); 31

32 TestClient.java double totalbalance = 0.0; for (BankAccount account : client) { totalbalance += account.getbalance(); if (totalbalance!= ) { stderr.println("** Test failure"); stdout.println("done"); 32

33 Class Diagram 33

34 Class Catalog import java.util.*; import java.io.*; /** * Maintains the information of a library catalog. Contains a * collection of {@link CatalogItem objects. * author name CatalogItem */ public class Catalog { /* Collection of <code>catalogitem</code> objects.*/ private ArrayList<CatalogItem> items; 34

35 Class Catalog /** * Constructs an empty catalog. */ public Catalog() { this.items = new ArrayList<CatalogItem>(); 35

36 Class Catalog /** * Adds a {@link CatalogItem object to this catalog. * catalogitem the {@link CatalogItem object. */ public void additem(catalogitem catalogitem) { this.items.add(catalogitem); 36

37 Class Catalog /** * Returns an iterator over the items in this catalog. * * return an {@link Iterator */ public Iterator<CatalogItem> iterator() { return this.items.iterator(); 37

38 Class Catalog /** * Returns the {@link CatalogItem object with the specified * <code>code</code>. * code the code of an item. The {@link CatalogItem object with the specifed * code. Returns <code>null</code> if the object with * the code is not found. */ public CatalogItem getitem(string code) { for (CatalogItem catalogitem : this.items) { if (catalogitem.getcode().equals(code)) { return catalogitem; return null; 38

39 Class Catalog /** * Returns the number of items in the catalog. * the number of {@link CatalogItem objects in this * catalog */ public int getnumberofitems() { return this.items.size(); 39

40 Class Diagram 40

41 Class BorrowerItems import java.util.*; import java.text.*; /** * Maintains a collection of {@link CatalogItems * assigned to a borrower. * author name CatalogItem */ public class BorrowedItems implements Iterable<CatalogItem> { /* Catalog items assigned to a borrower.*/ private ArrayList<CatalogItem> items; 41

42 Class BorrowerItems /** * Sets the collection of {@link CatalogItems to empty. */ public BorrowedItems() { this.items = new ArrayList<CatalogItem>(); 42

43 Class BorrowerItems /** * Adds a {@link CatalogItem object to this collection and * sets the {@link CatalogItem object as not available. * item the {@link CatalogItem object. */ public void additem(catalogitem catalogitem) { this.items.add(catalogitem); catalogitem.setavailable(false); 43

44 Class BorrowerItems /** * Removes a {@link CatalogItem object from this collection * and sets the {@link CatalogItem object as available. * item the {@link CatalogItem object. */ public void removeitem(catalogitem catalogitem) { this.items.removeelement(catalogitem); catalogitem.setavailable(true); 44

45 Class BorrowerItems /** * Returns an iterator over the borrowed items in this * collection. * * return an {@link Iterator */ public Iterator<CatalogItem> iterator() { return this.items.iterator(); 45

46 Class BorrowerItems /** * Returns the {@link CatalogItem object with the specified * <code>code</code>. * code the code of an item. The {@link CatalogItem object with the specifed * code. Returns <code>null</code> if the object with * the code is not found. */ public CatalogItem getitem(string code) { for (CatalogItem catalogitem : this.items) { if (catalogitem.getcode().equals(code)) { return catalogitem; return null; 46

47 Class BorrowerItems /** * Returns the number of borrowed items. * the number of borrowed items. */ public int getnumberofitems() { return this.items.size(); 47

48 Class Diagram 48

49 Class BorrowerDatabase import java.util.*; import java.text.*; /** * Maintains a collection of {@link Borrower objects. * author name Borrower */ public class BorrowerDatabase implements Iterable<Borrower> { /* Collection of <code>borrower</code> objects.*/ private ArrayList<Borrower> borrowers; 49

50 Class BorrowerDatabase /** * Constructs an empty collection of {@link Borrower * objects. */ public BorrowerDatabase() { this.borrowers = new ArrayList<Borrower>(); 50

51 Class BorrowerDatabase /** * Adds a {@link Borrower object to this collection. * borrower the {@link Borrower object. */ public void addborrower(borrower borrower) { this.borrowers.add(borrower); 51

52 Class BorrowerDatabase /** * Returns an iterator over the borrowers in this database. * * return an {@link Iterator */ public Iterator<Borrower> iterator() { return this.borrowers.iterator(); 52

53 Class BorrowerDatabase /** * Returns the {@link Borrower object with the specified * <code>id</code>. * code the id of the borrower. The {@link Borrower object with the specifed id. * Returns <code>null</code> if the object with the * id is not found. */ public Borrower getborrower(string id) { for (Borrower borrower : this.borrowers) { if (borrower.getid().equals(id)) { return borrower; return null; 53

54 Class BorrowerDatabase /** * Returns the number of {@link Borrower objects in this * collection. * the number of {@link Borrower objects in this * collection. */ public int getnumberofborrowers() { return this.borrowers.size(); 54