建模原语：四象图

class Computer {
	private String username;
	private String boughtTime;
	private String price;
	private String brand;
	private ComputerConfiguration cc;

	public Computer(String username, String boughtTime, String price,
			String brand, ComputerConfiguration cc) {
		super();
		this.username = username;
		this.boughtTime = boughtTime;
		this.price = price;
		this.brand = brand;
		this.cc = cc;
	}

	// getter/setter
}
<p class="indent">

class ComputerConfiguration {
	private String cpu;
	private String keyboard;
	private String hardDisk;
	private String memory;
	private String motherBoard;
	private String monitor;
	// getter/setter
}
<p class="indent">

class ComputerInRepairing {
	private String reason; // 哪里坏了
	private String orderNo; // 订单编号
	private Date startTime; // 送来修理的时间
	private Date endTime; // 修理完的时间
	private String chargedPrice;// 收费价格
	private String repairer; // 修理人
	private Computer computer;

	public ComputerInRepairing(Computer computer) {
		this.computer = computer;
		this.startTime = new Date();
	} // getter/setter
}
<p class="indent">

class ChargeStrategy {
	public String repairHardDisk() {
		return "50$";
	}

	public String repairMotherBoad() {
		return "20$";
	}
}
<p class="indent">

class RepairComputer {
    private ChargeStrategy strategy;  // 收费策略       

	public void repair(ComputerInRepairing c) {
            // repaire the computer
            // charge to customer
	}
}
<p class="indent">

public class Book {
	private String serialNo;
	private String name;	
	private BookCounter counter;	

	public Book(String name, String serialNo, BookCounter counter) {	
		this.name = name;
		this.serialNo = serialNo;
		this.counter = counter;
	}

	public String getSerialNo() {
		return serialNo;
	}
	
	public String getName() {
		return this.name;
	}

	public boolean hasStock() {
		return counter.hasStock();
	}

	public int getCount() {
		return counter.getCount();
	}
	
	public int incrementCount() {
		return counter.incrementCount();
	}

	public int decrementCount() {
		return counter.decrementCount();
	}
}
<p class="indent">

public class BookCounter {
	private int total; // total 
	private int count; // count in stock

	public BookCounter(int total) {
		this.total = total;
		this.count = total;
	}

	public int getTotal() {
		return total;
	} 
	
	public int getCount() {
		return count;
	}
	
	public boolean hasStock() {
		return count == 0 ? false : true;
	}

	public int incrementCount() {
		return count++;
	}

	public int decrementCount() {
		return count--;
	}
}
<p class="indent">

public class BorrowedBook {
	private String username;
	private Book book;	
	private Date borrowedTime;
	private Date returnedTime;

	public BorrowedBook(Book book) {
		this.book = book;			
	}
	
	public String getUsername() { return username;}
	public Book getBook() { return book; }
	public Date getBorrowedTime() { return borrowedTime; }
	public Date getReturnedTime() {	return returnedTime; }

	public void setUsername(String username) { this.username = username; }
	public void setBorrowedTime(Date borrowedTime) { this.borrowedTime = borrowedTime; }
	public void setReturnedTime(Date returnedTime) { this.returnedTime = returnedTime; }
}
<p class="indent">

public class Account {
	private String username;
	private AccountType accountType;
	private List<BorrowedBook> borrowedBooks;

	protected Account(String username) {
		this.username = username;
		this.borrowedBooks = new ArrayList<BorrowedBook>();
	}

	public BorrowedBook borrowBook(Book book) {
		BorrowedBook borrowedBook = new BorrowedBook(book);
		borrowedBook.setUsername(username);
		borrowedBook.setBorrowedTime(new Date());
		borrowedBooks.add(borrowedBook);
		return borrowedBook;
	}

	public Book returnBorrowedBook(BorrowedBook borrowedBook) {
		Book book = borrowedBook.getBook();
		borrowedBook.setReturnedTime(new Date());
		borrowedBooks.remove(borrowedBook);
		return book;
	}

	public List<BorrowedBook> borrowBooks(List<Book> books) {
		for (Book book : books) {
			borrowedBooks.add(borrowBook(book));
		}
		return borrowedBooks;
	}

	public List<Book> returnBorrowedBooks(List<BorrowedBook> borrowedBooks) {
		List<Book> books = null;
		if (this.borrowedBooks.removeAll(borrowedBooks)) {
			books = new ArrayList<Book>();
			for (BorrowedBook borrowedBook : borrowedBooks) {
				books.add(returnBorrowedBook(borrowedBook));
			}
		}
		return books;
	}
	
	public AccountType getAccountType() {
		return accountType;
	}

	public List<BorrowedBook> getBorrowedBooks() {
		return borrowedBooks;
	}
}
<p class="indent">

public enum AccountType {
	TEARCHER, STUDENT;
}
<p class="indent">

public class AccountFactory {
	private static Map<String, Account> accounts = new HashMap<String, Account>();

	private AccountFactory() {
	}

	public static synchronized Account getAccount(String username) {
		if (!accounts.containsKey(username)) {
			accounts.put(username, new Account(username));
		}
		return accounts.get(username);
	}
}
<p class="indent">

public class Library {
	public static Map<String, Book> books = new HashMap<String, Book>();

	public static Map<String, Book> getBooks() {
		return books;
	}

	public static void setBooks(Map<String, Book> books) {
		Library.books = books;
	}

	public static Book takeBook(String serialNo) {
		Book book = books.get(serialNo);	
		if (book.hasStock()) {
			book.decrementCount();
			return book;
		} 
		return null;
	}

	public static void putBook(String serialNo) {
		Book book = books.get(serialNo);	
		book.incrementCount();
		books.put(serialNo, book);
	}
	
	public static int getCount(String bookName) {
		int count = 0;
		Collection<Book> _books = books.values();
		for (Book book : _books) {
			if (book.getName().equalsIgnoreCase(bookName)) {
				count = book.getCount();
				break;
			}
		}
		return count; 
	}	
}
<p class="indent">

public class BorrowBookContext {
	public List<BorrowedBook> borrowBooks(Account account, List<String> serialNos) {
		List<BorrowedBook> borrowedBooks = new ArrayList<BorrowedBook>();		
		for (String serialNo : serialNos) {
			borrowedBooks.add(borrowBook(account, serialNo));
		}
		return borrowedBooks;
	}

	public BorrowedBook borrowBook(Account account, String serialNo) {
		Book book = Library.takeBook(serialNo);
		return account.borrowBook(book);
	}
}
<p class="indent">

public class ReturnBookContext {
	public void returnBorrowedBooks(List<BorrowedBook> borrowedBooks) {
		for (BorrowedBook borrowedBook : borrowedBooks) {
			returnBorrowedBook(borrowedBook);
		}
	}

	public void returnBorrowedBook(BorrowedBook borrowedBook) {
		Account borrower = AccountFactory.getAccount(borrowedBook.getUsername());
		Book book = borrower.returnBorrowedBook(borrowedBook);
		Library.putBook(book.getSerialNo());
	}
}
<p class="indent">

public class BorrowingTerms {
	private static final int LIMIT_OF_BOOKS = 5;
	private static final long LIMIT_OF_DAYS = 30;
	private static final int LIMIT_OF_STOCK = 1;
	private static final double UNIT_OF_PENALTY = 0.1;

	// 账号是否借满书
	public static boolean checkAccount(Account account) {
		int borrowedBooks;
		borrowedBooks = account.getBorrowedBooks().size();
		return (borrowedBooks > LIMIT_OF_BOOKS) ? false : true;
	}

	// 书是否超期
	public static boolean checkBorrowedBook(BorrowedBook borrowedBook) {
		return (exceededDays(borrowedBook) == 0) ? true : false;
	}

	// 图书馆是否还有额外的库存
	public static boolean checkLibrary(String bookName) {
		int stockBooks  = Library.getCount(bookName);
		return (stockBooks > LIMIT_OF_STOCK) ? true : false;
	}

	// 超期的天数
	public static long exceededDays(BorrowedBook borrowedBook) {
		long borrowedDays, exceededDays;
		borrowedDays = (borrowedBook.getReturnedTime().getTime() - borrowedBook
				.getBorrowedTime().getTime())
				/ (24 * 60 * 60 * 1000);
		exceededDays = (borrowedDays - LIMIT_OF_DAYS);
		return (exceededDays > 0) ? exceededDays : 0;
	}

	// 一本书超期的罚款金额，1本书1天0.1元
	public static double getPenalty(BorrowedBook borrowedBook) {
		return exceededDays(borrowedBook) * UNIT_OF_PENALTY;
	}
	
	// 多本书超期的罚款金额
	public double getPenalty(List<BorrowedBook> borrowedBooks) {		
		double penalty = 0;
		for (BorrowedBook borrowedBook : borrowedBooks) {
			if (BorrowingTerms.checkBorrowedBook(borrowedBook)) {
				penalty += BorrowingTerms.getPenalty(borrowedBook);
			}
		}
		return penalty;
	}
	
	// 此账号是否可以借此书	
	public static boolean canBorrowBook(Account account, String bookName) {	
		if (!BorrowingTerms.checkAccount(account))
			return false;
		if (!BorrowingTerms.checkLibrary(bookName))
			return false;
		for (BorrowedBook borrowedBook : account.getBorrowedBooks()) {
			if (!BorrowingTerms.checkBorrowedBook(borrowedBook))
				return false;
		}
		return true;
	}
}
<p class="indent">

public class UseCase {
	public static void showLibarayInfo() {
		Collection<Book> books = Library.getBooks().values();
		System.out.println("----------- Libaray----------------");
		for (Book book : books) {
			System.out.println("{" + book.getName() + ": " + book.getCount() +"}");
		}
		System.out.println("-----------------------------------");
	}
	
	public static void showAccountInfo(Account account) {
		List<BorrowedBook> books = account.getBorrowedBooks();
		System.out.println("----------- Account----------------");
		for (BorrowedBook book: books) {
			System.out.println("{"+book.getBook().getName()+"}");
		}
		System.out.println("-----------------------------------");
	}
	
	public static void initLibaray() {
		Map<String, Book> books = new HashMap<String, Book>();
		books.put("001", new Book("Jdon Framework", "001", new BookCounter(10)));
		books.put("002", new Book("Spring Framework", "002", new BookCounter(20)));
		books.put("003", new Book("Guice Framework", "003", new BookCounter(30)));
		Library.setBooks(books);
	}
	
	public static void main(String[] args) {		
		initLibaray();	
		
		// 0 图书馆里找书
		List<String> serialNos = new ArrayList<String>();
		serialNos.add("001");
		serialNos.add("002");
		serialNos.add("003");
		
		// 1 持卡借书
		Account jobs = AccountFactory.getAccount("Steve Jobs");
		
		// 1.1） 借书之前
		System.out.println("【0】 Before Borrowing Books");
		showLibarayInfo();
		showAccountInfo(jobs);
		
		// 1.2）借书
		BorrowBookContext borrowService = new BorrowBookContext();		
		List<BorrowedBook> borrowedBooks = borrowService.borrowBooks(jobs, serialNos);
		// 1.2）借书之后
		System.out.println("【1】After Borrowing Books");
		showLibarayInfo();
		showAccountInfo(jobs);
		
		// 2  阅读借来的书，读完时就该还书了。
		System.out.println("\n【2】 ******** Steve Jobs is reading books! ********\n" );
		
		// 3 无卡还书
		// 3.1) 还书之前
		System.out.println("【3】 Before Returning Books");
		showLibarayInfo();
		showAccountInfo(jobs);
		
		// 3.2) 还书, 
		ReturnBookContext returnService = new ReturnBookContext();			
		returnService.returnBorrowedBooks(borrowedBooks);		
		
		// 3.3) 还书之后
		System.out.println("【4】After Returning Books");
		showLibarayInfo();
		showAccountInfo(jobs);
	}
}
<p class="indent">

class Human
  attr_accessor :address
end

class Address
  def to_s
    "City: #{@city}"
  end
 
  private

  def initialize(city)
    @city = city
  end
end

module Policeman
  def check_address(address)
    # do some stuff
  end
end

module Thief
end

module FakeAddress
  def to_s
    "City: LA"
  end
end

class ArrestContext
  def execute
    @policeman.check_address @thief.address.to_s
  end

  private
  
  def initialize(policeman, thief)
    @policeman = policeman
    @policeman.extend Policeman

    @thief = thief
    @thief.extend Thief
    @thief.address.extend FakeAddress
  end
end

policeman, thief = Human.new, Human.new
thief.address = Address.new 'NY'

context = ArrestContext.new policeman, thief
context.execute
<p class="indent">