读《代码里的世界观》

void updatePersons(Array persons){
    // shareDB 是全局变量
    shareDB.open();
    foreach(Person person in persons){
        update(person);
    }
    shareDB.close();
}

void update(Person person){
    String sql = person.generateInsertSQL();
    shareDB.executeSql(sql);
}

// 修改 把数据库资源参数化
void update(Person person,DBConnection openedDB){
    String sql = person.generateInsertSQL();
    openedDB.executeSQL(sql);
}

// 调用 
// 好处1：多了DBConnection参数，对调用者是一种有用的约束；
// 好处2：openedDB是有效的调用提示，传进来的需要处于open状态
foreach(Person person in persons){
    update(person,sharedDB);
}

Person person = new Person();
person.readBook(book);

// readBook()
void readBook(Book book){
    // 
    wearGlasses(this.mGlasses);
    read(book);
}

// 属性注入
person.mClass = new Glasses();
person.readBook(book);

// 构造函数注入
// 缺点：但其他行为(函数如eat()不一定需要glases)
public Person(Glasses glasses){
    this.mClass = glasses;
}
// 普通注入
void readBook(Book book,Glasses glasses){
    wearClasses(glasses);
    read(book);
}
// 调用
// 但有点浪费，其实只需要一个glasses就够了
person.readBook(book,new Glasses());

// 封装注入,but may be null
person.readBook(book,person.mClass);
// =>
public Glasses MyGlasses{
    get{
        if(this.myGlasses == null){
            this.myGlasses = new Glasses();
            return this.myGlasses;
        }
    }
}
// back code
void readBook(Book book){
    wearGlasses(this.MyGlasses);
    readBook(book);
}
// client call success!
person.readBook(book);

public ConfigService{
    // singleton Code
}

public DBService(){
    // singleton Code
}

public NetworkService(){
    // singleton Code
}

// .....

// =>
Map<String,Object> container = new HashMap();
container.add("ConfigService",new ConfigService();
container.add("DBService",new DBService();
container.add("NetworkService",new NetworkService();

// => 
class ServiceKeys{
    public static String configService = "ConfigService";
    public static String dBService = "DBService";
    public static String networkService = "NetworkService";
}
// get service
ConfigService service = container[ServiceKeys.configService];
// set service
container.add(ServiceKeys.configService,new ConfigService());
// 其实Android中一些Service也是类似，也用了HashMap去实现singleton；

// example1
boolean isVaildFileType(String type){
    boolean isValid = true;
    if(type == "mp4"){
        isValid = true;
    }else if(type == "txt"){
        isValid = true;
    }else if(type == "ppt") || (type == "pptx"){
        isValid = true;
    }else if(type == "pdf"){
        isValid = true;
    }else if(type == "xls") || (type == "xlsx"){
        isValid = true;
    }else if(type == "doc") || (type == "docx"){
        isValid = true;
    }
    return isValid;
}
// => 
String[] validTypeArray = {
    "mp4","txt","ppt","pptx","pdf","xls","xlsx","doc","docx"
};
boolean isValidType(String type){
    return validTypeArray.contains(type);
}

// example2
if(number == "123"){
    doSth();
}

// =>
if(number == "123" || number == "456"){
    doSth();
}
// =>
Array expectionNumbers = {
    "123","456"
};
boolean isExceptionNumber(String number){
    return exceptionNumbers.contains(number);
}

// => 
if(isExceptionNumber(number)){
    doSth();
}

// example3
void btnClick(Object sender){
    BaseClass obj = new Class1();
}
if(selectItem == "Class1"){
    return new Class1();
}else if(selectItem == "Class2"){
    return new Class2();
}
// ...

// =>
{
    btn1_tag :"Class1",
    btn2_tag :"Class2",
    btn3_tag :"Class3",
    // ...
    btn20_tag :"Class20",
}

BaseClass generateClass(String btnTag){
    String className = dict[btnTag;
    Class<?> curClass = className.forName(className);
    return curClass.newInstance();
}

// client call
void DropDownListSelected(String selectedItem){
    BaseClass obj = generateClass(selectedItem);
}

// 对比组合和继承
interface ICalcuteSalary{
    double calcuteSalary(double baseSalary);
}

public class CalcJuniorSalary implements ICalcuteSalary{
    // ...
}

public class CalcSeniorSalary implements ICalcuteSalary{
    // ...
}

public class CalcManagerSalary implements ICalcuteSalary{
    // ...
}

public class Employee{
    // ...
    private ICalcuteSalary cs;
    public double calcuteSalary(){
        return cs.calcuteSalary(this.baseSalary);
    }
}

main{
    Employee employee = new Employee();
    employee.setCalSalary(new CalcJuniorSalary());
    sout(employee.calcuteSalary());
    // set other strategys
}

// 使用继承
public class JuniorEmployee{
    CalcJuniorSalary calcJuniorSalary;
    public double clacSalary(){
        return calcJuniorSalary(this.baseSalary);
    }
}

// ...
public class SeniorEmployee{
    // ...
}
public class ManagerEmployee{
    // ...
}

main{
    Employee employee = new JuniorEmployee();
    sout(employee.clacSalary());
    // new other employees
    
}

public class Shape{
    void draw(Window window);
}

public class MyWindow:Window{
    public void draw(Shape shape){
        shape.draw(this);
    }
}

// visitor patterns
public abstract class Shape{
    abstract void draw();
}

public class Rectangle extends Shape{}
public class Circle extends Shape{}
public class Line extends Shape{}

// 给子类扩展一个新的方法zoomIn()添加放大的逻辑
public class Rectangle extends Shape{
    // zoomIn code
}
public class Circle extends Shape{
    // zoomIn code
}
public class Line extends Shape{
    // zoomIn code
}

// but 这样编译不过
foreach(Shape shape in shapes){
    zoomIn(shape);
}
// 需要判断并转换类型
foreach(Shape shape in shapes){
    if(shape instanceOf Rectangle){
        zoomIn((Rectangle)shape);
    }else if(shape instanceOf Circle){
        zoomIn((Circle)shape);
    }(shape instanceOf Line){
        zoomIn((Line)shape);
    }
}
// 解决
public abstract class Shape{
    abstract void draw();
    abstract void acceptVisitor(IVisitor visitor);
}

interface IVisitor{
    void visit(Rectangle rect);
    void visit(Circle circle);
    void visit(Line line);
}

class ZoomInVisitor implements IVisitor{
    void visit(Rectangle rect){
        // ...
    }
    
    void visit(Circle circle){
        // ...
    }
    
    void visit(Line line){
        // ...
    }
}

class Rectangle extends Shape{
    public void draw(){
        // ...
    }
    
    public void acceptVisitor(IVisitor visitor){
        // 产生了双向依赖
        visitor.visit(this);
    }
}

// client call
main{
    IVisitor visitor = new ZoomInVisitor();
    foreach(Shape shape in shapes){
        shape.acceptVisitor(visitor);
    }
}
// visitor 和 double dispatch dynamic特性

interface Command{
    void execute();
}
class LightOnCommand implements Command{
    Light light;
    public void execute(){
        if(light != null){
            light.turnOn();
        }
    }
}

class User{
    ICommand[] commandList;
    ICommand currentCommand;
    // setCommand 
    public void triggerCmd(){
        currentCommand.execute();
        commandList.add(currentCommand);
    }
}

main{
    User user = new User();
    user.setCmd(new LightOnCommand());
    user.triggerCmd();
}