Notes

//
package compositepattern;

import java.util.ArrayList;
import java.util.List;

interface FileSystemComponent {
public void displayDetails();
}

class File implements FileSystemComponent{

private String name;

public File(String name){
this.name = name;
}

@Override
public void displayDetails() {
System.out.println("File : " + name);
}
}

class Directory implements FileSystemComponent{

private String name;
private List<FileSystemComponent> children;

public Directory(String name){
this.name = name;
children = new ArrayList<>();
}

public void addComponent(FileSystemComponent component) {
children.add(component);
}

public void removeComponent(FileSystemComponent component) {
children.remove(component);
}

@Override
public void displayDetails() {
System.out.println("Directory: " + name);
System.out.println("Contents:");
for (FileSystemComponent component : children) {
component.displayDetails();
}
}

}

public class CompositePatternDemo {
public static void main(String[] args) {
File file1 = new File("Document.txt");
File file2 = new File("Image.jpg");
File file3 = new File("Spreadsheet.xlsx");

Directory directory1 = new Directory("Documents");
directory1.addComponent(file1);
directory1.addComponent(file3);

Directory directory2 = new Directory("Pictures");
directory2.addComponent(file2);

Directory rootDirectory = new Directory("Root");
rootDirectory.addComponent(directory1);
rootDirectory.addComponent(directory2);

rootDirectory.displayDetails();
}
}

//
FacadePatternDemo.java
package facadepattern;

public class FacadePatternDemo {
public static void main(String[] args) {
ShapeMaker shapeMaker = new ShapeMaker();

shapeMaker.drawCircle();
shapeMaker.drawRectangle();
shapeMaker.drawSquare();
}
}

interface Shape {
void draw();
}

class Circle implements Shape {

@Override
public void draw() {
System.out.println("Circle::draw()");
}
}

class Square implements Shape {

@Override
public void draw() {
System.out.println("Square::draw()");
}
}

class Rectangle implements Shape {

@Override
public void draw() {
System.out.println("Rectangle::draw()");
}
}

class ShapeMaker {
private Shape circle;
private Shape rectangle;
private Shape square;

public ShapeMaker() {
circle = new Circle();
rectangle = new Rectangle();
square = new Square();
}

public void drawCircle(){
circle.draw();
}
public void drawRectangle(){
rectangle.draw();
}
public void drawSquare(){
square.draw();
}
}

//

package iteratorpattern;

public class IteratorPatternDemo {

public static void main(String[] args) {
NameRepository namesRepository = new NameRepository();

for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
String name = (String)iter.next();
System.out.println("Name : " + name);
}
}
}

class NameRepository implements Container {
public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};

@Override
public Iterator getIterator() {
return new NameIterator();
}

private class NameIterator implements Iterator {

int index;

@Override
public boolean hasNext() {

if(index < names.length){
return true;
}
return false;
}

@Override
public Object next() {

if(this.hasNext()){
return names[index++];
}
return null;
}
}
}

interface Container {
public Iterator getIterator();
}
interface Iterator {
public boolean hasNext();
public Object next();
}
//




package commandpattern;
import java.util.ArrayList;
import java.util.List;

// Client code
public class RestaurantOrderSystem {
public static void main(String[] args) {
Chef chef = new Chef();

Command burgerCommand = new BurgerCommand(chef);
Command pizzaCommand = new PizzaCommand(chef);

Waiter waiter = new Waiter();
waiter.takeOrder(burgerCommand);
waiter.takeOrder(pizzaCommand);
waiter.submitOrders();
}
}

// Receiver: The chef who prepares the orders
class Chef {
public void makeBurger() {
System.out.println("Chef is making a burger.");
}
public void makePizza() {
System.out.println("Chef is making a pizza.");
}
}

// Command interface
interface Command {
void execute();
}

// Concrete Command for making a burger
class BurgerCommand implements Command {
private Chef chef;
public BurgerCommand(Chef chef) {
this.chef = chef;
}

@Override
public void execute() {
chef.makeBurger();
}
}

// Concrete Command for making a pizza
class PizzaCommand implements Command {
private Chef chef;
public PizzaCommand(Chef chef) {
this.chef = chef;
}

@Override
public void execute() {
chef.makePizza();
}
}

// Waiter or Invoker: Takes orders and sends commands to the chef
class Waiter {
private List<Command> orders = new ArrayList<>();
public void takeOrder(Command command) {
orders.add(command);
}

public void submitOrders() {
for (Command command : orders) {
command.execute();
}
orders.clear();
}
}
//



package observerpattern;
import java.util.ArrayList;
import java.util.List;

// Subject interface
interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(String post);
}

// Concrete Subject
class FacebookUser implements Subject {
private String username;
private List<Observer> followers;
private String latestPost;

public FacebookUser(String username) {
this.username = username;
this.followers = new ArrayList<>();
}

public void postUpdate(String post) {
latestPost = post;
notifyObservers(post);
}

@Override
public void registerObserver(Observer observer) {
followers.add(observer);
}

@Override
public void removeObserver(Observer observer) {
followers.remove(observer);
}

@Override
public void notifyObservers(String post) {
for (Observer follower : followers) {
follower.update(username, post);
}
}
}

// Observer interface
interface Observer {
void update(String username, String post);
}

// Concrete Observer
class FacebookFollower implements Observer {
private String followerName;

public FacebookFollower(String followerName) {
this.followerName = followerName;
}

@Override
public void update(String username, String post) {
System.out.println(followerName + " received an update from " + username + ":");
System.out.println(post);
System.out.println();
}
}

public class ObserverPatternDemo {
public static void main(String[] args) {
// Create Facebook users
FacebookUser alice = new FacebookUser("Alice");
FacebookUser bob = new FacebookUser("Bob");

// Create followers
FacebookFollower follower1 = new FacebookFollower("Follower 1");
FacebookFollower follower2 = new FacebookFollower("Follower 2");

// Register followers to users
alice.registerObserver(follower1);
alice.registerObserver(follower2);
bob.registerObserver(follower2);

// Users post updates
alice.postUpdate("Hello, everyone! This is my first post.");
bob.postUpdate("Feeling excited about the weekend!");

// Follower 1 decides to unfollow Alice
alice.removeObserver(follower1);

// Alice posts another update
alice.postUpdate("A beautiful sunset today!");

// Follower 1 doesn't receive the new update
}
}
//