處理多樣性關系

舒適的家庭生活會導致一個或更多 “小人兒” 降臨到這個家庭。但是，在增加小孩到家庭中之前，先確保 Person 真正有地方可住。給他們一個工作場所，或者還有一個很好的夏日度假屋。一個 Address 類型應該可以解決所有這三個地方。

清單 1. 添加一個 Address 類型到 Person 類中

package com.tedneward.model;

public class Address

{

public Address()

{

}

public Address(String street, String city, String state, String zip)

{

this.street = street; this.city = city;

this.state = state; this.zip = zip;

}

public String toString()

{

return "[Address: " +

"street=" + street + " " +

"city=" + city + " " +

"state=" + state + " " +

"zip=" + zip + "]";

}

public int hashCode()

{

return street.hashCode() & city.hashCode() &

state.hashCode() & zip.hashCode();

}

public boolean equals(Object obj)

{

if (obj == this)

return this;

if (obj instanceof Address)

{

Address rhs = (Address)obj;

return (this.street.equals(rhs.street) &&

this.city.equals(rhs.city) &&

this.state.equals(rhs.state) &&

this.zip.equals(rhs.zip));

}

else

return false;

}

public String getStreet() { return this.street; }

public void setStreet(String value) { this.street = value; }

public String getCity() { return this.city; }

public void setCity(String value) { this.city = value; }

public String getState() { return this.state; }

public void setState(String value) { this.state = value; }

public String getZip() { return this.zip; }

public void setZip(String value) { this.zip = value; }

private String street;

private String city;

private String state;

private String zip;

}

可以看到，Address 只是一個簡單的數據對象。將它添加到 Person 類中意味著 Person 將有一個名為 addresses 的 Address 數組作為字段。第一個地址是家庭住址，第二個是工作地址，第三個(如果不為 null 的話)是度假屋地址。當然，這些都被設置為 protected，以便將來通過方法來封裝。

完成這些設置后，現在可以增強 Person 類，使之支持小孩，所以為 Person 定義一個新字段：一個 Person ArrayList，它同樣也有一些相關的方法，以便進行適當的封裝。

接下來，由于大多數小孩都有父母，還將添加兩個字段來表示母親和父親，并增加適當的 accessor/mutator 方法。將為 Person 類增加一個新的方法，使之可以創建一個新的 Person，這個方法有一個貼切的名稱，即 haveBaby。此外還增加一些業務規則，以支持生小孩的生物學需求，并將這個新的小 Person 添加到為母親和父親字段創建的 children ArrayList 中。做完這些之后，再將這個嬰兒返回給調用者。

清單 2 顯示，新定義的 Person 類可以處理這種多樣性關系。

清單 2. 定義為多樣性關系的家庭生活

package com.tedneward.model;

import java.util.List;

import java.util.ArrayList;

import java.util.Iterator;

public class Person

{

public Person()

{ }

public Person(String firstName, String lastName, Gender gender, int age, Mood mood)

{

this.firstName = firstName;

this.lastName = lastName;

this.gender = gender;

this.age = age;

this.mood = mood;

}

public String getFirstName() { return firstName; }

public void setFirstName(String value) { firstName = value; }

public String getLastName() { return lastName; }

public void setLastName(String value) { lastName = value; }

public Gender getGender() { return gender; }

public int getAge() { return age; }

public void setAge(int value) { age = value; }

public Mood getMood() { return mood; }

public void setMood(Mood value) { mood = value; }

public Person getSpouse() { return spouse; }

public void setSpouse(Person value) {

// A few business rules

if (spouse != null)

throw new IllegalArgumentException("Already married!");

if (value.getSpouse() != null && value.getSpouse() != this)

throw new IllegalArgumentException("Already married!");

spouse = value;

// Highly sexist business rule

if (gender == Gender.FEMALE)

this.setLastName(value.getLastName());

// Make marriage reflexive, if its not already set that way

if (value.getSpouse() != this)

value.setSpouse(this);

}

public Address getHomeAddress() { return addresses[0]; }

public void setHomeAddress(Address value) { addresses[0] = value; }

public Address getWorkAddress() { return addresses[1]; }

public void setWorkAddress(Address value) { addresses[1] = value; }

public Address getVacationAddress() { return addresses[2]; }

public void setVacationAddress(Address value) { addresses[2] = value; }

public Iterator＜Person＞ getChildren() { return children.iterator(); }

public Person haveBaby(String name, Gender gender) {

// Business rule

if (this.gender.equals(Gender.MALE))

throw new UnsupportedOperationException("Biological impossibility!");

// Another highly objectionable business rule

if (getSpouse() == null)

throw new UnsupportedOperationException("Ethical impossibility!");

// Welcome to the world, little one!

Person child = new Person(name, this.lastName, gender, 0, Mood.CRANKY);

// Well, wouldnt YOU be cranky if youd just been pushed out of

// a nice warm place?!?

// These are your parents...

child.father = this.getSpouse();

child.mother = this;

// ... and youre their new baby.

// (Everybody say "Awwww....")

children.add(child);

this.getSpouse().children.add(child);

return child;

}

public String toString()

{

return

"[Person: " +

"firstName = " + firstName + " " +

"lastName = " + lastName + " " +

"gender = " + gender + " " +

"age = " + age + " " +

"mood = " + mood + " " +

(spouse != null ? "spouse = " + spouse.getFirstName() + " " : "") +

"]";

}

public boolean equals(Object rhs)

{

if (rhs == this)

return true;

if (!(rhs instanceof Person))

return false;

Person other = (Person)rhs;

return (this.firstName.equals(other.firstName) &&

this.lastName.equals(other.lastName) &&

this.gender.equals(other.gender) &&

this.age == other.age);

}

private String firstName;

private String lastName;

private Gender gender;

private int age;

private Mood mood;

private Person spouse;

private Address[] addresses = new Address[3];

private List＜Person＞ children = new ArrayList＜Person＞();

private Person mother;

private Person father;

}

即使包括所有這些代碼，清單 2 提供的家庭關系模型還是過于簡單。在這個層次結構中的某些地方，必須處理那些 null 值。但是，在 db4o 中，那個問題更應該在對象建模中解決，而不是在對象操作中解決。所以現在我可以放心地忽略它。

填充和測試對象模型

對于清單 2 中的 Person 類，需要重點注意的是，如果以關系的方式，使用父與子之間分層的、循環的引用來建模，那肯定會比較笨拙。通過一個實例化的對象模型可以更清楚地看到我所談到的復雜性，所以我將編寫一個探察測試來實例化 Person 類。注意，清單 3 中省略了 JUnit 支架(scaffolding)。

總結

以上是生活随笔為你收集整理的java db4o 教程_面向Java开发人员db4o指南：数组和集合 （1）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。