Composition and Aggregation are almost the same
composition the contained objects do not exist independently in case of the above example the Heart cannot exist without the person.
Aggregation the contained objects can exist independently like
Money exists without a person.
The Command Design Patterns main goal is to decouple the invoker from the Receiver.
The invoker is the one which invokes an action on the Receiver, and the receiver is the one on which the command is executed.
// The Receiver
package Command;
public class Movie {
public static void start() {
System.out.println("Start Movie");
}
public static void stop() {
System.out.println("Movie Stopped");
}
}
//Play Command
public class PlayMovieCommand implements CommandIntf {
public void execute() {
Movie.start();
}
}
//Stop Command
public class StopMovieCommand implements CommandIntf {
public void execute() {
Movie.stop();
}
}
//The Invoker
package Command;
public class MoviePlayer {
static CommandIntf play;
static CommandIntf stop;
public static void setPlayCmd(CommandIntf playMovCmd) {
play = playMovCmd;
}
public static void setStopCmd(CommandIntf stopMovCmd) {
stop = stopMovCmd;
}
public static void playMovie() {
play.execute();
}
public static void stopMovie() {
stop.execute();
}
}
package singleton; public class Singleton { private static Singleton aSingleton; private Singleton() { } static Singleton getInstance() { synchronized (Singleton.class) { if (Singleton.aSingleton == null) { Singleton.aSingleton = new Singleton(); } } return Singleton.aSingleton; } }
- only one instance of a class across threads
- global point of access
DrinkDecorator
public abstract class DrinkDecorator extends Drink {
public Drink drink;
}
Drink
public abstract class Drink {
String description; int cost;
abstract int getCost();
String getDesc() {
return this.description;
}
}
Vodka
public class Vodka extends Drink {
String description = " Vodka ";
int cost = 100;
@Override
int getCost() {
return this.cost;
}
}
public class OrangeJuice extends DrinkDecorator {
String description = " fresh orenge juice ";
int cost = 5;
public OrangeJuice(Drink myVodka) {
this.drink = myVodka;
}
@Override
int getCost() {
return this.cost + this.drink.getCost();
}
}
Client Code
//Make Vodka with orange
//make vodka
Drink myVodka = new Vodka();
//mix orenge and vodka
DrinkDecorator orengeVodka= new OrangeJuice(myVodka);
//mix lime juie in the orengeVodka
DrinkDecorator LimeOrengeVodka= new LimeJuice(orengeVodka);
//the cost of the final vodka should be that of lime
//orenge and vodka cost
System.out.println(LimeOrengeVodka.getCost());
This pattern is used in publisher-consumer kind of situations
This pattern is used where a change in data which is observable by one or many observers,The pattern is such that no matter what kind of Observers ATMObserver , OnlineAcObsever) come the Observable or the subject(BankAccount) has no impact.So tomorrow if there is a need to add MobileObserver for BankAccount, that can just be added without any changes and implementing AccountObserver.
The Subject or Observable concrete class,in this case a bank account which is observable.The Observers OnlineACObserver ATMACObserver register with this class and get updates about the bank account.
public class BankAccount implements SubjectObservable {
public ArrayList observers = new ArrayList();
String balance;
String account;
public void deregisterObserver(AccountObserver o) {
observers.remove(observers.indexOf(o));
}
public void notifyObservers() {
for (int i = 0; i < this.observers.size(); i++) {
AccountObserver observer = (AccountObserver) this.observers.get(i);
observer.update("ACCOUNTNUM", "BALANCE < 200");
}
}
public void registerObserver(AccountObserver o) {
observers.add(o);
}
public void setBalance(String balance) {
this.balance = balance;
this.notifyObservers();
}
The Concrete implementation of Observer take the case of ATMACObserver this observer registers with the BankAccount and gets invoked by the Subject when there is a change or update in the Subject.
public class ATMObserver implements AccountObserver {
String message;
SubjectObservable bankAccount;
public ATMObserver(SubjectObservable bankAccount) {
this.bankAccount = bankAccount;
this.bankAccount.registerObserver(this);
}
public void update(String accountNumber, String balance) {
{
this.message = "welcome to ATM " + accountNumber + " " + balance;
}
}
The client code can be as follows.
class Client {
public static void main(String[] args) {
// creating observable Bank Account
SubjectObservable bankAccount = new BankAccount();
// Observer 1 onlin
OnlineAcObserver online = new OnlineAcObserver(bankAccount);
// Observer 2 ATM
ATMObserver atm = new ATMObserver(bankAccount);
//update account values which updates the observer
online.getMessage();
Computer aComputer = ComputerFactoryIF.createComputer("apple"); System.out.println(aComputer.getName());
The ComputerFactoryIF the interface of all the concrete factories checks as to which type of Computer is to be created and delegates to the appropriate ComputerFactory in this case AppleComputerFac
public class ComputerFactoryIF { public static Computer createComputer(String string) { Computer aComp = null; if (string.equals("apple")) aComp = AppleComputerFac.createComputer(); else if (string.equals("dell")) aComp = DellComputerFac.createComputer(); return aComp; }
public class AppleComputerFac extends ComputerFactoryIF { public static Computer createComputer() { return new AppleComputer(); } }
public class AppleComputer extends Computer { AppleComputer() { this.name = "AppleComputer"; } }
Posts
All Comments
