solutions.txt

P6

*************************** interface typing
interface Tax{
	double compute(double amount);
}
public class Invoice {
	private Tax taxType;
	Tax getTaxType() {
		return taxType;
	}
	void setTaxType(Tax taxType) {
		this.taxType = taxType;
	}
	public double getTotal()
	{
		double amount = getSubtotal();
    amount += taxType.compute(amount);
		return amount;
	}
	double getSubtotal()
	{
		double subtotal = 0;
		...logic
		return subtotal;
	}
}
*************************** Duck typing

public class Invoice {
	private object taxType;
	
	void setTaxType(object taxType) {
		this.taxType = taxType;
	}
	public double getTotal()
	{
		double amount = getSubtotal();
    		amount += taxType.compute(amount);
		return amount;
	}
	double getSubtotal()
	{
		double subtotal = 0;
		...logic
		return subtotal;
	}
}



P6 -2
public class Invoice {
	private Lamda taxType;
	
	Invoice(Lamda taxType) {
		this.taxType = taxType;
	}
	public double getTotal(){
		double amount = getSubtotal();
		amount += taxType(amount);
		return amount;
	}
	double getSubtotal(){
		...
	}
}

Invoice inv = new Invoice(new Gst()); //GST should belong to Tax family
Invoice inv = new Invoice((amount)=> amount*0.05);
Invoice inv = new Invoice((amount)=> {
				Gst gst = new GST();
				return gst.compute(amount);
			});


P23

class Domain{
  fun(){
    ... logic
    if(cond)
      throw Ex;
    ... logic
  }
}

void DoJob()
{
	Domain domain = new Domain();
	domain.fun();
	domain.fun2(100);
	Repostory rep = new Repository();
	Emp emp = rep.get(1);
	...
}

P1

interface State{
  start();
  stop();
  pause();
  resume();
}
class Idle implement State{
  start(){ invoke logic }
  stop() { throw new InvalidState(); }
  pause() { throw }
  resume(){ throw }
}
class Running implement State{
  start(){ throw }
  stop() { invoke logic  }
  pause() { invoke logic }
  resume(){ throw }
}
class Suspended implement State{
  start(){ throw }
  stop() { invoke logic  }
  pause() { throw }
  resume(){ invoke logic }
}
public class StopWatch {
	State flag = new Idle();
	public void start(){ flag.start(); flag= new Running(); }
	public boolean stop(){ flag.stop(); flag= new Idle(); }
	public boolean pause(){ flag.pause(); flag= new Suspended(); }
	public boolean resume(){ flag.resume(); flag= new Running(); }
}

P2
/*********************************************** flag

class AccountService
{
  Stack<Operation> stack = new Stack<Operation>();
  Account acc = new Account();
  
  public void withdraw(double amount){
    acc.withdraw(amount);
    Operation op = new Operation(1,amount);
    stack.push(op);
  }
  
  public void deposit(double amount){
    acc.deposit(amount);
    Operation op = new Operation(2,amount);
    stack.push(op)
  }
  
  public void undo(){
    Operation op = stack.pop();
    if(op.Type == 1)
      acc.deposit(op.amount);
    if(op.Type == 2)
      acc.withdraw(op.amount);
      
  }
  
}


/*********************************************** inteface


interface Operation{
  void undo(Account acc);
}
class DepositOperation{
  double amount;
  
  public DepositOperation( double amount){
    this.amount = amount;
  }
  public void undo(Account acc){
    acc.withdraw(amount);
  }
}
class WithdrawOperation{
  double amount;
  public WithdrawOperation( double amount){
    this.amount = amount;
  }
  public void undo(Account acc){
    acc.deposit(amount);
  }
}
class AccountService
{
  Stack<Operation> stack = new Stack<Operation>();
  Account acc = new Account();
  
  public void withdraw(double amount){
    acc.withdraw(amount);
    Operation op = new WithdrawOperation(amount);
    stack.push(op);
  }
  public void deposit(double amount){
    acc.deposit(amount);
    Operation op = new DepositOperation(amount);
    stack.push(op)
  }
  public void undo(){
    Operation op = stack.pop();
    op.undo(acc);
  }
}

/*********************************************** lambda
class AccountService
{
  Stack<Lamda> stack = new Stack<Lamda>();
  Account acc = new Account();
  
  public void withdraw(double amount){
    acc.withdraw(amount);
    stack.push((acc)=> acc.deposit(amount));
  }
  public void deposit(double amount){
    acc.deposit(amount);
    stack.push((acc)=> acc.withdraw(amount));
  }
  public void undo(){
    Lamda op = stack.pop();
    op(acc);
  }
}

P21

interface Encryption{ 
String encrypt(String message); 
String decrypt(String message); 
} 

class AESEncrption implements Encryption{ 
String encrypt(String message){ 
//logic 
} 
String decrypt(String message){ 
//logic 
} 
} 

class BlowFishEncrption implements Encryption{ 
String encrypt(String message){ 
//logic 
} 
String decrypt(String message){ 
//logic 
} 
} 

public class Message { 
private Encryption algorithmName; 
private String text; 
public Message(Encryption algorithmName){ 
this.algorithmName=algorithmName; 
} 
public string getText(){ 
return algorithmName.decrypt(text); 
} 
public void setText(String text){ 
text = algorithmName.encrypt(text); 
} 
}

P22

for(Vehicle vehicle : vehicles) { 
vehicle.action(); 
vehicle.stop(); 
} 


Interface Vehicle { 
action(); 
stop(); 
} 

Class CAR implements Vehicle { 
action(){ 
lock(); 
go(); 
} 
} 

Class SHIP implements Vehicle { 
action() { 
balance(); 
swim(); 
} 
} 

Class AIRPLANE implements Vehicle { 
action(){ 
go(); 
fly(); 
} 
} 

Class TANK implements Vehicle { 
action() { 
move(); 
stop(); 
fire(); 
} 
}


P24

interface IX
{
          void f1();
          void f2();
}
public class CA implements IX
{
    public void f1() {}
    public void f2() {}
}
class IXFactory
{
    public IX getInsatnce(){
           return new CA(); 
    }
}
//*******************************
class Client
{
      public static void main()
      {
          IXFactory factory = new IXFactory();  
          IX obj = factory.getInsatnce();
          obj.f1();
          obj.f2();
      }
}


P11

public class Stock { 
double rate; 

public void changeRate(double newRate, Broker broker) { 
rate = newRate; 
//if(condition) 
broker.trade(); 
} 
} 

interface Broker { 
void trade(); 
}


P3
package problem3;

public class Workflow{
	public void execute(Factory factory){
		Connection connection = factory.getConnection();
		connection.open("mydb;scott;tiger");
		Transaction transaction = factory.getTransaction();
		transaction.begin(connection);	
		Command cmd1 = factory.getCommand();
		cmd1.execute(transaction, "insert into emp values(10,'jack',2500')");
		Command cmd2 = factory.getCommand();
		cmd2.execute(transaction, "insert into emp values(20,'jill',4300')");		
		transaction.commit();
		connection.close();
	}
}
public class Entry {
	public static void main() {
		Workflow wf = new Workflow();
		wf.execute(new SqlFactory());			
	}
}


P3 - 2
interface Connection{
	open();
	close();
}
class PostConnection{
	connect();
	disconnect();
}
class PostConnectionAdapter  implements Connection{
	PostConnection connection = new PostConnection();
	open(){
		connection.connect();	
	}
	close();
}
class SqlConnection implements Connection{
	open();
	close();
}
class OraConnection implements Connection{
	open();
	close();
}

P25


class SurveyDataType:
    public void SurveyDataType(string baseFileName,  bool hideDataFile){
        this.baseFileName = baseFileName;
        this.hideDataFile = "c:/application/data/" + baseFileName + ".dat";
    }
    static SurveyDataType rawDataType = SurveyDataType("raw", True);
    static SurveyDataType cleanedUpDataType = SurveyDataType("cleanedUp", True);
    static SurveyDataType processedDataType = SurveyDataType("processed", True);
    static SurveyDataType publicationDataType = SurveyDataType("publication", False);
}

v1 = SurveyDataType.processedDataType.baseFileName;
v2 = SurveyDataType.processedDataType.hideDataFile;


P20

interface Account {
     void withdraw(double amount);
     void deposit(double amount);
}
interface AccountDAO{
     void persisit();
}
class AccountService{
     void doTransaction(Account acc,AccountDAO dao)
     {
          acc.withdraw(3434);
          acc.deposit(34);
          ...
          dao.persist(acc);
          ...
     }
}

abstarct class Account
{
     public abstract withdraw(double amount);
     public abstract deposit(double amount);
     protected abstarct persisit();
     
     public void Save()
     {
          ... logic 1 
          persisit();
          ... logic 2         
     }
}

P8

class Collection{
  ... common code ...
  public void add(index, item) {}
}
class Stack extends Collection{}
class Queue extends Collection{}
class List extends Collection{}

class Stack  {
  Collection ref = new Collection();
}
class Queue{
  Collection ref = new Collection();
}
class List {
  Collection ref = new Collection();
}

p7
interface AccountType {
	boolean withDraw(double amount);
}
interface AccountPriv {
	boolean withDraw(double amount);
}
class SavingAccount implements AccountType{
	boolean withDraw(double amount){
		if((balance - amount) < 5000){
			return false;
		}
	}
}
class CurrentAccount implements AccountType{
	boolean withDraw(double amount){
		if((balance - amount) < 100000){
			return false;
		}
	}
}
class SilverAccount implements AccountPriv{
	boolean withDraw(double amount){
		if(amount > 10000){
			return false; 
		}
	}
}
class PlatinumAccount implements AccountPriv{
	boolean withDraw(double amount){
		if(amount > 20000){
			return false; 
		}
	}
}
class AccountService{
	AccountType type;
	AccountPriv priv;
	
	public AccountService( AccountType type,AccountPriv priv){
		this.type = type;
		this.priv = priv;
	}
	boolean withDraw(double amount){
		if(!type.withdraw(amount))
			return false;
		if(!priv.withdraw(amount))
			return false;
	}
}

P4
package problem4;
interface Step { 
	void invoke(Plugin p); 
} 
Start implements Step { 
	void invoke(Plugin p) { 
		p.do(this); 
	} 
}
interface Plugin{
	void do (Start); 
	void do (Action); 
	void do (Branch); 
	void do (Stop); 
}
Class TreeSerializer implements Plugin { 
	void do (Start start){
		...logic...
		start.next.invoke(this);
	} 
	void do (Action action){
		... logic ...
		action.next.invoke(this);
	} 
	void do (Branch branch){
		... logic ...
		branch.left.invoke(this);
		... logic ...
		branch.right.invoke(this);
	}
	void do (Stop stop){
		... logic ...
	} 
} 
Class TreePrinter implements Plugin { 
	void do (Start start){
		System.out.println("start");
		start.next.invoke(this);
	} 
	void do (Action action){
		System.out.println("Action");
		action.next.invoke(this);
	} 
	void do (Branch branch){
		System.out.println("Branch");
		System.out.println("--> left");
		branch.left.invoke(this);
		System.out.println("--> rigth");
		branch.right.invoke(this);
	}
	void do (Stop stop){
		System.out.println("stop");
	} 
} 
public class Entry {
	public static void main(String[] args) {
		Factory factory = new Factory();
		Step root = factory.Load("flow1");
		TreePrinter treePrinter = new TreePrinter();
		root.invoke(treePrinter);
		TreeSerializer treeSerializer = new TreeSerializer();
		root.invoke(treeSerializer);
	}
}

P13
lookup
//************** s3 ********************************
interface Handler{
     void collide(GO o1,GO o2);
}
class ShipStation implments Handler{
}
class ShipCommet implments Handler{
}
...
class HandlerFactory{
     Dictionary<string,Handler> lookup = new Dictionary<string,Handler>();
     
     public HandlerFactory(){
          lookup.add("ShipStation",new ShipStation());
          ....
     }
     public Handler Get(GO o1,GO o2){
          return lookup[o1.getName() + o2.getName()];
     }
}
 public void Collide(GameObject go1,GameObject go2)
 {
      HandlerFactory factory = new HandlerFactory();
      Handler handler = factory.Get(go1,go2);
      handler.collide(go1,go2);
 }

lhs -> poly, rhs -> if
//************** s2 ********************************
interface GO{
     void collide(Ship); 
     void collide(Station); 
     void collide(Commet); 
     void collide (Aestroid); 
}
class Ship implements GO{
     void collide(Ship) {} //ship - ship
     void collide(Station) {} // ship - station
     void collide(Commet){} // ship - commet
     void collide (Aestroid){} // ship - Aestroid
}
class Handler
{
     public void Collide(GameObject go1,GameObject go2)
     {
          if(type(go2) == type(Ship))
               go1.collide((Ship) go2);
          if(type(go2) == type(Station))
               go1.collide((Station) go2);
          if(type(go2) == type(Commet))
               go1.collide((Commet) go2);
          if(type(go2) == type(Aestroid))
               go1.collide((Aestroid) go2);
     }
}
lhs -> if, rhs -> if
//************** s1 ********************************
class Handler
{
     public void Collide(GameObject go1,GameObject go2)
     {
          if(type(o1)==type(Ship) && type(o2)==type(Station))
          {
            //logic1
          }
           if(type(o1)==type(Station) && type(o2)==type(Aestroid))
          {
            //logic2
          }
           if(type(o1)==type(Ship) && type(o2)==type(Commet))
          {
            //logic3
          }
     }
}


P5

interface Rule
{
  bool eval(HashMap<string,string> obj);
}
class GreaterRule implements Rule{
  string property;
  double value;
  public GreaterRule(string property,double value){
    this.property = property;
    this.value = value;
  }
  bool eval(HashMap<string,object> obj){
    cur_value = obj.get(property);
    if(double.parse(cur_value) > value)
      return true;
    else
      return false;
  }
}
class LesserRule implements Rule{
  string property;
  double value;
  public LesserRule(string property,double value){
    this.property = property;
    this.value = value;
  }
  bool eval(HashMap<string,object> obj){
    cur_value = obj.get(property);
    if(double.parse(cur_value) < value)
      return true;
    else
      return false;
  }
}
class EqualStringRule implements Rule{
  string property;
  string value;
  public EqualStringRule(string property,string value){
    this.property = property;
    this.value = value;
  }
  bool eval(HashMap<string,object> obj){
    cur_value = obj.get(property);
    if(cur_value.equals(value))
      return true;
    else
      return false;
  }
}
class AndRule implements Rule{
  Rule lhs;
  Rule rhs;
  public AndRule(Rule lhs,Rule rhs){
    this.lhs = lhs;
    this.rhs = rhs;
  }
  bool eval(HashMap<string,object> obj){
    return lhs.eval(obj) && rhs.eval(obj);
  }
}


HashMap<string,string> object = new HashMap<>(); 
        object.put("Salary", 3500);
        object.put("Age", 45);
        object.put("Department", "Sales");
        
        //Composite Pattern
        Rule r1 = new GreaterRule("Salary",5000.00);
	Rule r2 = new LesserRule("Age",50);
	Rule r3 = new EqualStringRule("Department","Purchase");
	Rule r4 = new AndRule(r1,r2);
	Rule r5 = new OrRule(r4,r3);    
	    
	res = r5.eval(object);	
	//"((Salary > 5000 && Age < 50) || (Department == 'Purchase'))"    
        System.out.print(res);   

P10

interface Account{
	void withDraw(double Amount);
}
class SA implements Account{
	public void withDraw(double Amount){
		balance-=amount;
	}
}
class Otp implements Account{
	Account a;
	public Otp(Account a){
		this.a = a;
	}
	public void withDraw(double Amount){
		... pre otp logic ..
		a.withdraw(amount);
		... post otp logic ..
	}
}
Account a = new Sms(new Otp(new SA()));
a.withdraw(340);