added lab16 ex3

src/lab11_flyweight/ex1/Brush.java

@@ -0,0 +1,16 @@
+package lab11_flyweight.ex1;
+
+public class Brush implements DrawingTool {
+    private final Props props;
+
+    public Brush(Props props) {
+        this.props = props;
+    }
+
+    @Override
+    public void draw(String text) {
+        System.out.println("Drawing '" + text + "' in " + props.size + ", color:" + props.color);
+    }
+
+    public record Props(Size size, Color color) {}
+}

src/lab11_flyweight/ex1/BrushFactory.java

@@ -0,0 +1,17 @@
+package lab11_flyweight.ex1;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class BrushFactory {
+    private final Map<Brush.Props, Brush> brushes = new HashMap<>();
+
+    public Brush getBrush(Brush.Props props) {
+        Brush brush = brushes.get(props);
+        if (brush == null) {
+            brush = new Brush(props);
+            brushes.put(props, brush);
+        }
+        return brush;
+    }
+}

src/lab11_flyweight/ex1/Color.java

@@ -0,0 +1,6 @@
+package lab11_flyweight.ex1;
+
+public enum Color {
+    BLUE,
+    RED
+}

src/lab11_flyweight/ex1/DrawingTool.java

@@ -0,0 +1,5 @@
+package lab11_flyweight.ex1;
+
+public interface DrawingTool {
+    void draw(String text);
+}

src/lab11_flyweight/ex1/Main.java

@@ -0,0 +1,31 @@
+package lab11_flyweight.ex1;
+
+public class Main {
+    public static void main(String[] args) {
+        BrushFactory factory = new BrushFactory();
+        Brush.Props props1 = new Brush.Props(Size.THICK, Color.RED);
+        Brush.Props props2 = new Brush.Props(Size.THIN, Color.BLUE);
+        DrawingTool brush1 = factory.getBrush(props1);
+        DrawingTool brush2 = factory.getBrush(props1);
+
+        brush1.draw("I am drawing with my first thick red brush");
+        brush2.draw("I am drawing with my second thick red brush");
+        System.out.println("first thick red brush hashcode: " + brush1.hashCode());
+        System.out.println("second thick red brush hashcode: " + brush2.hashCode());
+
+        System.out.println();
+        DrawingTool pencil = new Pencil();
+        pencil.draw("Bonjour");
+        System.out.println();
+
+        DrawingTool brush3 = factory.getBrush(props2);
+        DrawingTool brush4 = factory.getBrush(props2);
+
+        brush3.draw("I am drawing with my first thin blue brush");
+        brush4.draw("I am drawing with my second thin blue brush");
+        System.out.println("first thin blue brush hashcode: " + brush3.hashCode());
+        System.out.println("second thin blue brush hashcode: " + brush4.hashCode());
+
+
+    }
+}

src/lab11_flyweight/ex1/Pencil.java

@@ -0,0 +1,8 @@
+package lab11_flyweight.ex1;
+
+public class Pencil implements DrawingTool {
+    @Override
+    public void draw(String text) {
+        System.out.println("Pencil writes some content: " + text);
+    }
+}

src/lab11_flyweight/ex1/Size.java

@@ -0,0 +1,6 @@
+package lab11_flyweight.ex1;
+
+public enum Size {
+    THIN,
+    THICK
+}

src/lab12_singleton/ex1/CarSensorSingletonLauncher.java

@@ -0,0 +1,29 @@
+package lab12_singleton.ex1;
+
+import lab12_singleton.ex1.sensors.*;
+import lab12_singleton.ex1.managers.*;
+
+public class CarSensorSingletonLauncher {
+    public CarSensorSingletonLauncher() {
+
+    }
+
+    public static void main(String[] args) {
+        CarSensorSingletonLauncher launcher = new CarSensorSingletonLauncher();
+        launcher.launch();
+    }
+
+    public void launch() {
+        this.test(SimpleSingletonSensorsManager.getInstance());
+        this.test(SynchSingletonSensorsManager.getInstance());
+        this.test(EagerSingletonSensorsManager.getInstance());
+        this.test(DbleCheckedSingletonSensorsManager.getInstance());
+    }
+
+    private void test(SingletonSensorManager manager) {
+        manager.addSensor(new TemperatureSensor());
+        manager.addSensor(new SpeedSensor());
+        manager.addSensor(new RoadConditionSensor());
+        manager.printState();
+    }
+}

src/lab12_singleton/ex1/Sensor.java

@@ -0,0 +1,15 @@
+package lab12_singleton.ex1;
+
+public abstract class Sensor {
+    private boolean ok = true;
+
+    public abstract String getName();
+    public void setOk(boolean ok) {
+        this.ok = ok;
+    }
+
+    @Override
+    public String toString() {
+        return getName() + ": " + (ok ? "Ok" : "Warning");
+    }
+}

src/lab12_singleton/ex1/SingletonSensorManager.java

@@ -0,0 +1,17 @@
+package lab12_singleton.ex1;
+
+import java.util.ArrayList;
+
+public abstract class SingletonSensorManager {
+    private final ArrayList<Sensor> sensors = new ArrayList<>();
+
+    protected SingletonSensorManager() {}
+
+    public void addSensor(Sensor sensor) {
+        sensors.add(sensor);
+    }
+
+    public void printState() {
+        System.out.println("<" + this.getClass().getSimpleName() + ": " + sensors.toString() + ">");
+    }
+}

src/lab12_singleton/ex1/managers/DbleCheckedSingletonSensorsManager.java

@@ -0,0 +1,18 @@
+package lab12_singleton.ex1.managers;
+
+import lab12_singleton.ex1.SingletonSensorManager;
+
+public class DbleCheckedSingletonSensorsManager extends SingletonSensorManager {
+    private static DbleCheckedSingletonSensorsManager instance;
+
+    public static DbleCheckedSingletonSensorsManager getInstance() {
+        if (instance == null) {
+            synchronized (DbleCheckedSingletonSensorsManager.class) {
+                if (instance == null) {
+                    instance = new DbleCheckedSingletonSensorsManager();
+                }
+            }
+        }
+        return instance;
+    }
+}

src/lab12_singleton/ex1/managers/EagerSingletonSensorsManager.java

@@ -0,0 +1,11 @@
+package lab12_singleton.ex1.managers;
+
+import lab12_singleton.ex1.SingletonSensorManager;
+
+public class EagerSingletonSensorsManager extends SingletonSensorManager {
+    private static final EagerSingletonSensorsManager instance = new EagerSingletonSensorsManager();
+
+    public static EagerSingletonSensorsManager getInstance() {
+        return instance;
+    }
+}

src/lab12_singleton/ex1/managers/SimpleSingletonSensorsManager.java

@@ -0,0 +1,14 @@
+package lab12_singleton.ex1.managers;
+
+import lab12_singleton.ex1.SingletonSensorManager;
+
+public class SimpleSingletonSensorsManager extends SingletonSensorManager {
+    private static SimpleSingletonSensorsManager instance;
+
+    public static SingletonSensorManager getInstance() {
+        if (instance == null) {
+            instance = new SimpleSingletonSensorsManager();
+        }
+        return instance;
+    }
+}

src/lab12_singleton/ex1/managers/SynchSingletonSensorsManager.java

@@ -0,0 +1,14 @@
+package lab12_singleton.ex1.managers;
+
+import lab12_singleton.ex1.SingletonSensorManager;
+
+public class SynchSingletonSensorsManager extends SingletonSensorManager {
+    private static SynchSingletonSensorsManager instance;
+
+    public static synchronized SynchSingletonSensorsManager getInstance() {
+        if (instance == null) {
+            instance = new SynchSingletonSensorsManager();
+        }
+        return instance;
+    }
+}

src/lab12_singleton/ex1/sensors/RoadConditionSensor.java

@@ -0,0 +1,10 @@
+package lab12_singleton.ex1.sensors;
+
+import lab12_singleton.ex1.Sensor;
+
+public class RoadConditionSensor extends Sensor {
+    @Override
+    public String getName() {
+        return "Road Condition";
+    }
+}

src/lab12_singleton/ex1/sensors/SpeedSensor.java

@@ -0,0 +1,10 @@
+package lab12_singleton.ex1.sensors;
+
+import lab12_singleton.ex1.Sensor;
+
+public class SpeedSensor extends Sensor {
+    @Override
+    public String getName() {
+        return "Speed";
+    }
+}

src/lab12_singleton/ex1/sensors/TemperatureSensor.java

@@ -0,0 +1,10 @@
+package lab12_singleton.ex1.sensors;
+
+import lab12_singleton.ex1.Sensor;
+
+public class TemperatureSensor extends Sensor {
+    @Override
+    public String getName() {
+        return "Temperature";
+    }
+}

src/lab13_proxy/ex1/Image.java

@@ -0,0 +1,27 @@
+package lab13_proxy.ex1;
+
+public class Image {
+    protected final String path;
+    protected final String resolution;
+    protected boolean loaded = false;
+
+    public Image(String path, String resolution) {
+        this.path = path;
+        this.resolution = resolution;
+    }
+
+    public void load() {
+        if (!loaded) {
+            System.out.println("Image " + path + " is loaded in " + resolution + " resolution");
+            loaded = true;
+        }
+    }
+
+    public boolean isLoaded() {
+        return loaded;
+    }
+
+    public void showImage(User user) {
+        System.out.println("Image " + path + " is shown in " + resolution + " resolution for user " + user.getName());
+    }
+}

src/lab13_proxy/ex1/ImageProxy.java

@@ -0,0 +1,24 @@
+package lab13_proxy.ex1;
+
+public class ImageProxy extends Image {
+    private final Image lowResImage;
+    private final Image highResImage;
+
+    public ImageProxy(String path) {
+        super(path, "high");
+        lowResImage = new Image(path, "low");
+        highResImage = new Image(path, "high");
+    }
+
+    public void showImage(User user) {
+        System.out.println(user.getName() + " selects preview image " + path + " and wants to see its full resolution.");
+        if (RegistrationService.isRegistered(user)) {
+            highResImage.load();
+            highResImage.showImage(user);
+        } else {
+            System.out.println("User " + user.getName() + " is not registered. Showing preview image in low resolution");
+            lowResImage.load();
+            lowResImage.showImage(user);
+        }
+    }
+}

src/lab13_proxy/ex1/Main.java

@@ -0,0 +1,19 @@
+package lab13_proxy.ex1;
+
+public class Main {
+    public static void main(String[] args) {
+        User jean = new User("Jean");
+        User paul = new User("Paul");
+        User pierre = new User("Pierre");
+
+        RegistrationService.register(paul);
+
+        Image highResolutionImage1 = new ImageProxy("sample/veryHighResPhoto1.jpeg");
+        Image highResolutionImage2 = new ImageProxy("sample/veryHighResPhoto2.jpeg");
+        Image highResolutionImage3 = new ImageProxy("sample/veryHighResPhoto3.jpeg");
+
+        highResolutionImage1.showImage(jean);
+        highResolutionImage2.showImage(paul);
+        highResolutionImage3.showImage(pierre);
+    }
+}

src/lab13_proxy/ex1/RegistrationService.java

@@ -0,0 +1,15 @@
+package lab13_proxy.ex1;
+
+import java.util.ArrayList;
+
+public class RegistrationService {
+    private static final ArrayList<User> users = new ArrayList<>();
+    public static void register(User user) {
+        System.out.println(user.getName() + " is now registered");
+        users.add(user);
+    }
+
+    public static boolean isRegistered(User user) {
+        return users.contains(user);
+    }
+}

src/lab13_proxy/ex1/User.java

@@ -0,0 +1,13 @@
+package lab13_proxy.ex1;
+
+public class User {
+    private final String name;
+
+    public User(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/lab13_proxy/ex2/Account.java

@@ -0,0 +1,36 @@
+package lab13_proxy.ex2;
+
+import java.util.Random;
+
+public class Account {
+    private int balance;
+    private int accountNumber;
+    private String owner;
+
+    public Account(String owner, int startBalance) {
+        this.owner = owner;
+        this.balance = startBalance;
+        this.accountNumber = new Random().hashCode();
+    }
+
+    public void deposit(int amount) {
+        balance += amount;
+    }
+
+    public void withdraw(int amount) {
+        balance -= amount;
+    }
+
+    public String getOwner() {
+        return owner;
+    }
+
+    public int getBalance() {
+        return balance;
+    }
+
+    @Override
+    public String toString() {
+        return "account " + this.accountNumber + " belonging to " + this.owner;
+    }
+}

src/lab13_proxy/ex2/Bank.java

@@ -0,0 +1,52 @@
+package lab13_proxy.ex2;
+
+import java.util.ArrayList;
+
+public class Bank {
+    private final ArrayList<String> blacklistedClients = new ArrayList<>();
+
+    public void blacklist(String client) {
+        blacklistedClients.add(client);
+    }
+    public boolean isBlacklisted(String client) {
+        return blacklistedClients.contains(client);
+    }
+
+    public void deposit(String client, Account account, int amount) {
+        if (amount < 0) {
+            System.out.println("Cannot deposit a negative amount");
+            return;
+        }
+        if (isBlacklisted(client)) {
+            System.out.println(client + " is on a blacklist and does not have the right to DEPOSIT money into " + account);
+            return;
+        }
+
+        account.deposit(amount);
+        System.out.println(client + " has deposited " + amount + " on " + account + ". New balance is " + account.getBalance());
+    }
+
+    public void withdraw(String client, Account account, int amount) {
+        if (amount < 0) {
+            System.out.println("Cannot withdraw a negative amount");
+            return;
+        }
+        if (isBlacklisted(client)) {
+            System.out.println(client + " is on a blacklist and does not have the right to WITHDRAW money from " + account);
+            return;
+        }
+
+        if (!account.getOwner().equals(client)) {
+            System.out.println(client + " cannot WITHDRAW money from " + account + " because they are not the owner");
+            return;
+        }
+
+        if (account.getBalance() < amount) {
+            System.out.println(client + " cannot WITHDRAW money from " + account + " because there is not enough money on the account.");
+            return;
+        }
+
+        account.withdraw(amount);
+        System.out.println(client + " has withdrawn " + amount + " from " + account + ". New balance is " + account.getBalance());
+    }
+}

src/lab13_proxy/ex2/Main.java

@@ -0,0 +1,18 @@
+package lab13_proxy.ex2;
+
+public class Main {
+    public static void main(String[] args) {
+        Account account = new Account("Pascale", 16000);
+
+        Bank bank = new Bank();
+        bank.blacklist("Jean");
+        bank.blacklist("Pierre");
+
+        bank.deposit("Marcel", account, 1000);
+        bank.deposit("Jean", account, 1000);
+        bank.withdraw("Marcel", account, 1000);
+        bank.withdraw("Pascale", account, 1000000);
+        bank.withdraw("Pascale", account, 1000);
+        bank.withdraw("Pierre", account, 1000);
+    }
+}

src/lab14_strategy/ex1/AxeBehavior.java

@@ -0,0 +1,8 @@
+package lab14_strategy.ex1;
+
+public class AxeBehavior implements WeaponBehavior {
+    @Override
+    public String useWeapon() {
+        return "chops with an axe";
+    }
+}

src/lab14_strategy/ex1/Character.java

@@ -0,0 +1,19 @@
+package lab14_strategy.ex1;
+
+public abstract class Character {
+    private WeaponBehavior weapon;
+
+    public Character(WeaponBehavior weapon) {
+        this.weapon = weapon;
+    }
+
+    public void setWeapon(WeaponBehavior weapon) {
+        this.weapon = weapon;
+    }
+
+    public abstract String getName();
+
+    public void fight() {
+        System.out.println(getName() + " " + weapon.useWeapon());
+    }
+}

src/lab14_strategy/ex1/Game.java

@@ -0,0 +1,25 @@
+package lab14_strategy.ex1;
+
+import lab14_strategy.ex1.characters.King;
+import lab14_strategy.ex1.characters.Knight;
+import lab14_strategy.ex1.characters.Troll;
+import lab14_strategy.ex1.characters.Queen;
+import lab14_strategy.ex1.weapons.BowAndArrowBehavior;
+import lab14_strategy.ex1.weapons.KnifeBehavior;
+
+public class Game {
+    public static void main(String[] args) {
+        Character king = new King(new KnifeBehavior());
+        Character queen = new Queen(new BowAndArrowBehavior());
+        Character knight = new Knight(new SwordBehavior());
+        Character troll = new Troll(new AxeBehavior());
+
+        king.fight();
+        queen.fight();
+        knight.fight();
+        troll.fight();
+
+        king.setWeapon(new SwordBehavior());
+        king.fight();
+    }
+}

src/lab14_strategy/ex1/SwordBehavior.java

@@ -0,0 +1,8 @@
+package lab14_strategy.ex1;
+
+public class SwordBehavior implements WeaponBehavior {
+    @Override
+    public String useWeapon() {
+        return "swings a sword";
+    }
+}

src/lab14_strategy/ex1/WeaponBehavior.java

@@ -0,0 +1,5 @@
+package lab14_strategy.ex1;
+
+public interface WeaponBehavior {
+    String useWeapon();
+}

src/lab14_strategy/ex1/characters/King.java

@@ -0,0 +1,15 @@
+package lab14_strategy.ex1.characters;
+
+import lab14_strategy.ex1.Character;
+import lab14_strategy.ex1.WeaponBehavior;
+
+public class King extends Character {
+    public King(WeaponBehavior weapon) {
+        super(weapon);
+    }
+
+    @Override
+    public String getName() {
+        return "King";
+    }
+}

src/lab14_strategy/ex1/characters/Knight.java

@@ -0,0 +1,15 @@
+package lab14_strategy.ex1.characters;
+
+import lab14_strategy.ex1.Character;
+import lab14_strategy.ex1.WeaponBehavior;
+
+public class Knight extends Character {
+    public Knight(WeaponBehavior weapon) {
+        super(weapon);
+    }
+
+    @Override
+    public String getName() {
+        return "Knight";
+    }
+}

src/lab14_strategy/ex1/characters/Queen.java

@@ -0,0 +1,15 @@
+package lab14_strategy.ex1.characters;
+
+import lab14_strategy.ex1.Character;
+import lab14_strategy.ex1.WeaponBehavior;
+
+public class Queen extends Character {
+    public Queen(WeaponBehavior weapon) {
+        super(weapon);
+    }
+
+    @Override
+    public String getName() {
+        return "Queen";
+    }
+}

src/lab14_strategy/ex1/characters/Troll.java

@@ -0,0 +1,15 @@
+package lab14_strategy.ex1.characters;
+
+import lab14_strategy.ex1.Character;
+import lab14_strategy.ex1.WeaponBehavior;
+
+public class Troll extends Character {
+    public Troll(WeaponBehavior weapon) {
+        super(weapon);
+    }
+
+    @Override
+    public String getName() {
+        return "Troll";
+    }
+}

src/lab14_strategy/ex1/weapons/BowAndArrowBehavior.java

@@ -0,0 +1,10 @@
+package lab14_strategy.ex1.weapons;
+
+import lab14_strategy.ex1.WeaponBehavior;
+
+public class BowAndArrowBehavior implements WeaponBehavior {
+    @Override
+    public String useWeapon() {
+        return "shoots an arrow with a bow";
+    }
+}

src/lab14_strategy/ex1/weapons/KnifeBehavior.java

@@ -0,0 +1,10 @@
+package lab14_strategy.ex1.weapons;
+
+import lab14_strategy.ex1.WeaponBehavior;
+
+public class KnifeBehavior implements WeaponBehavior {
+    @Override
+    public String useWeapon() {
+        return "cuts with a knife";
+    }
+}

src/lab14_strategy/ex2/SortAlgorithm.java

@@ -0,0 +1,5 @@
+package lab14_strategy.ex2;
+
+public interface SortAlgorithm {
+    void sort(int[] vector);
+}

src/lab14_strategy/ex2/Sorter.java

@@ -0,0 +1,21 @@
+package lab14_strategy.ex2;
+
+public class Sorter {
+    private SortAlgorithm algorithm;
+    public void sort(int[] vector) {
+        algorithm.sort(vector);
+    }
+
+    public void setAlgorithm(SortAlgorithm algorithm) {
+        this.algorithm = algorithm;
+    }
+
+    public void showVectorData(int[] vector) {
+        StringBuilder sb = new StringBuilder();
+
+        for (int j : vector) {
+            sb.append(j).append("\t");
+        }
+        System.out.println(sb);
+    }
+}

src/lab14_strategy/ex2/StrategySortLauncher.java

@@ -0,0 +1,35 @@
+package lab14_strategy.ex2;
+
+import lab14_strategy.ex2.algorithms.BubbleSort;
+import lab14_strategy.ex2.algorithms.InsertionSort;
+import lab14_strategy.ex2.algorithms.SelectionSort;
+
+public class StrategySortLauncher {
+    public static void main(String[] args) {
+        StrategySortLauncher launcher = new StrategySortLauncher();
+        launcher.test();
+    }
+
+    public void test() {
+        int[] tab1 = { 99, 11, 2, 33, 12, 1, 0, 99, 34, 35 };
+        int[] tab2 = { 99, 11, 2, 33, 12, 1, 0, 99, 34, 35 };
+        int[] tab3 = { 99, 11, 2, 33, 12, 1, 0, 99, 34, 35 };
+
+        Sorter sorter = new Sorter();
+
+        System.out.println("test bubble sort");
+        sorter.setAlgorithm(new BubbleSort());
+        sorter.sort(tab1);
+        sorter.showVectorData(tab1);
+
+        System.out.println("test insert sort");
+        sorter.setAlgorithm(new InsertionSort());
+        sorter.sort(tab2);
+        sorter.showVectorData(tab2);
+
+        System.out.println("test selection sort");
+        sorter.setAlgorithm(new SelectionSort());
+        sorter.sort(tab3);
+        sorter.showVectorData(tab3);
+    }
+}

src/lab14_strategy/ex2/algorithms/BubbleSort.java

@@ -0,0 +1,23 @@
+package lab14_strategy.ex2.algorithms;
+
+import lab14_strategy.ex2.SortAlgorithm;
+
+public class BubbleSort implements SortAlgorithm {
+    @Override
+    public void sort(int[] vector) {
+        int temp;
+        int nbrePermutation = -1;
+        int nbreIteration = 0;
+        while (nbrePermutation != 0) {
+            nbrePermutation = 0;
+            for (int i=0; i<vector.length - nbreIteration - 1; i++) {
+                if (vector[i] > vector[i + 1]) {
+                    nbrePermutation++;
+                    temp = vector[i + 1];
+                    vector[i + 1] = vector[i];
+                    vector[i] = temp;
+                }
+            }
+        }
+    }
+}

src/lab14_strategy/ex2/algorithms/InsertionSort.java

@@ -0,0 +1,22 @@
+package lab14_strategy.ex2.algorithms;
+
+import lab14_strategy.ex2.SortAlgorithm;
+
+public class InsertionSort implements SortAlgorithm {
+    @Override
+    public void sort(int[] vector) {
+        int temp;
+        for (int i=1; i<vector.length; i++) {
+            temp = vector[i];
+            for (int j = i - 1; j >= 0; j--) {
+                if (vector[j] > temp) {
+                    vector[j + 1] = vector[j];
+                    vector[j] = temp;
+                } else {
+                    vector[j + 1] = temp;
+                    break;
+                }
+            }
+        }
+    }
+}

src/lab14_strategy/ex2/algorithms/SelectionSort.java

@@ -0,0 +1,22 @@
+package lab14_strategy.ex2.algorithms;
+
+import lab14_strategy.ex2.SortAlgorithm;
+
+public class SelectionSort implements SortAlgorithm {
+    @Override
+    public void sort(int[] vector) {
+        int temp, cursor = 0;
+        for (int i=0; i<vector.length; i++) {
+            temp = vector[i];
+            cursor = i;
+            for (int j = i; j < vector.length; j++) {
+                if (vector[j] < temp) {
+                    temp = vector[j];
+                    cursor = j;
+                }
+            }
+            vector[cursor] = vector[i];
+            vector[i] = temp;
+        }
+    }
+}

src/lab15_observer/ex1/Main.java

@@ -0,0 +1,24 @@
+package lab15_observer.ex1;
+
+public class Main {
+    public static void main(String[] args) {
+        PatientMonitoring pm = new PatientMonitoring(1, 140, 85);
+
+        MedicalEmployee jean = new MedicalEmployee("Jean", pm);
+        MedicalEmployee pauline = new MedicalEmployee("Pauline", pm);
+        MedicalEmployee matthieu = new MedicalEmployee("Matthieu", pm);
+        MedicalEmployee symeon = new MedicalEmployee("Symeon", pm);
+
+        pm.setBloodPressure(110);
+        pm.setPosition(3);
+
+        pm.setPulseOximetry(90);
+        pm.setPulseOximetry(70);
+        pm.setPosition(7);
+        pm.setBloodPressure(150);
+
+        pm.removeObserver(matthieu);
+        pm.setBloodPressure(145);
+        pm.setPosition(9);
+    }
+}

src/lab15_observer/ex1/MedicalEmployee.java

@@ -0,0 +1,19 @@
+package lab15_observer.ex1;
+
+public class MedicalEmployee implements PatientObserver {
+    private final String name;
+
+    public MedicalEmployee(String name, PatientMonitoring pm) {
+        this.name = name;
+        pm.registerObserver(this);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void update(Problem problem, PatientMonitoring pm) {
+        System.out.println(getName() + " has been notified of " + problem + " for patient " + pm);
+    }
+}

src/lab15_observer/ex1/PatientMonitoring.java

@@ -0,0 +1,70 @@
+package lab15_observer.ex1;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PatientMonitoring {
+    private final List<PatientObserver> observers = new ArrayList<>();
+
+    private int position;
+    private int bloodPressure;
+    private int pulseOximetry;
+
+    public PatientMonitoring(int position, int bloodPressure, int pulseOximetry) {
+        this.position = position;
+        this.bloodPressure = bloodPressure;
+        this.pulseOximetry = pulseOximetry;
+    }
+
+    public void registerObserver(PatientObserver o) {
+        observers.add(o);
+    }
+
+    public void removeObserver(PatientObserver o) {
+        observers.remove(o);
+    }
+
+    private void notifyObservers(Problem problem) {
+        for (PatientObserver o : observers) {
+            o.update(problem, this);
+        }
+    }
+
+    public int getPosition() {
+        return position;
+    }
+    public int getBloodPressure() {
+        return bloodPressure;
+    }
+    public int getPulseOximetry() {
+        return pulseOximetry;
+    }
+
+    public void setPosition(int position) {
+        this.position = position;
+        notifyObservers(Problem.NO_PROBLEM);
+    }
+
+    public void setBloodPressure(int bloodPressure) {
+        this.bloodPressure = bloodPressure;
+        if (getBloodPressure() > 145) {
+            notifyObservers(Problem.BLOOD_PRESSURE);
+        } else {
+            notifyObservers(Problem.NO_PROBLEM);
+        }
+    }
+
+    public void setPulseOximetry(int pulseOximetry) {
+        this.pulseOximetry = pulseOximetry;
+        if (getPulseOximetry() > 85) {
+            notifyObservers(Problem.OXIMETRY);
+        } else {
+            notifyObservers(Problem.NO_PROBLEM);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "<Patient Position: " + position + ", BP: " + bloodPressure + ", PO: " + pulseOximetry + ">";
+    }
+}

src/lab15_observer/ex1/PatientObserver.java

@@ -0,0 +1,5 @@
+package lab15_observer.ex1;
+
+public interface PatientObserver {
+    void update(Problem problem, PatientMonitoring pm);
+}

src/lab15_observer/ex1/Problem.java

@@ -0,0 +1,7 @@
+package lab15_observer.ex1;
+
+public enum Problem {
+    NO_PROBLEM,
+    BLOOD_PRESSURE,
+    OXIMETRY
+}

src/lab15_observer/ex2/AnalogTimer.java

@@ -0,0 +1,103 @@
+package lab15_observer.ex2;
+
+public class AnalogTimer implements TimerObserver {
+    private final MyTimer timer;
+    private static final String[][] digits = {
+        {
+            "┌─┐",
+            "│ │",
+            "└─┘"
+        },
+        {
+            "  ╷",
+            "  │",
+            "  ╵"
+        },
+        {
+            "╶─┐",
+            "┌─┘",
+            "└─╴"
+        },
+        {
+            "╶─┐",
+            " ─┤",
+            "╶─┘"
+        },
+        {
+            "╷ ╷",
+            "└─┤",
+            "  ╵"
+        },
+        {
+            "┌─╴",
+            "└─┐",
+            "╶─┘"
+        },
+        {
+            "┌─╴",
+            "├─┐",
+            "└─┘"
+        },
+        {
+            "╶─┐",
+            "  │",
+            "  ╵"
+        },
+        {
+            "┌─┐",
+            "├─┤",
+            "└─┘"
+        },
+        {
+            "┌─┐",
+            "└─┤",
+            "╶─┘"
+        },
+    };
+
+    public AnalogTimer(MyTimer timer) {
+        this.timer = timer;
+        timer.registerObserver(this);
+    }
+
+    public void update(int hours, int minutes, int seconds) {
+        String[] lines = {"", "", ""};
+
+        addDigit(lines, hours / 10);
+        addSpace(lines);
+        addDigit(lines, hours % 10);
+
+        addSep(lines);
+
+        addDigit(lines, minutes / 10);
+        addSpace(lines);
+        addDigit(lines, minutes % 10);
+
+        addSep(lines);
+
+        addDigit(lines, seconds / 10);
+        addSpace(lines);
+        addDigit(lines, seconds % 10);
+
+        System.out.println(lines[0]);
+        System.out.println(lines[1]);
+        System.out.println(lines[2]);
+    }
+
+    private void addDigit(String[] lines, int digit) {
+        String[] parts = digits[digit];
+        for (int i = 0; i < 3; i++) {
+            lines[i] += parts[i];
+        }
+    }
+    private void addSpace(String[] lines) {
+        lines[0] += " ";
+        lines[1] += " ";
+        lines[2] += " ";
+    }
+    private void addSep(String[] lines) {
+        lines[0] += " o ";
+        lines[1] += "   ";
+        lines[2] += " o ";
+    }
+}

src/lab15_observer/ex2/ClockTimer.java

@@ -0,0 +1,8 @@
+package lab15_observer.ex2;
+
+public interface ClockTimer {
+    int getHour();
+    int getMinute();
+    int getSecond();
+    void tick();
+}

src/lab15_observer/ex2/DigitalTimer.java

@@ -0,0 +1,15 @@
+package lab15_observer.ex2;
+
+public class DigitalTimer implements TimerObserver {
+    private final MyTimer timer;
+
+    public DigitalTimer(MyTimer timer) {
+        this.timer = timer;
+        timer.registerObserver(this);
+    }
+
+    @Override
+    public void update(int hours, int minutes, int seconds) {
+        System.out.printf("Time: %02d:%02d:%02d%n", hours, minutes, seconds);
+    }
+}

src/lab15_observer/ex2/Main.java

@@ -0,0 +1,10 @@
+package lab15_observer.ex2;
+
+public class Main {
+    public static void main(String[] args) {
+        MyTimer clockTimer = new MyTimer();
+
+        new AnalogTimer(clockTimer);
+        new DigitalTimer(clockTimer);
+    }
+}

src/lab15_observer/ex2/MyTimer.java

@@ -0,0 +1,53 @@
+package lab15_observer.ex2;
+
+import java.util.*;
+
+public class MyTimer implements ClockTimer {
+    private final List<TimerObserver> observers = new ArrayList<>();
+    private Calendar cal;
+    private Timer timer;
+
+    public MyTimer() {
+        cal = Calendar.getInstance();
+        timer = new Timer();
+        timer.schedule(new TimerAction(), 0, 1000);
+    }
+
+    class TimerAction extends TimerTask {
+        @Override
+        public void run() {
+            cal = Calendar.getInstance();
+            tick();
+        }
+    }
+
+    @Override
+    public int getHour() {
+        return cal.get(Calendar.HOUR_OF_DAY);
+    }
+
+    @Override
+    public int getMinute() {
+        return cal.get(Calendar.MINUTE);
+    }
+
+    @Override
+    public int getSecond() {
+        return cal.get(Calendar.SECOND);
+    }
+
+    @Override
+    public void tick() {
+        for (TimerObserver o : observers) {
+            o.update(getHour(), getMinute(), getSecond());
+        }
+    }
+
+    public void registerObserver(TimerObserver o) {
+        observers.add(o);
+    }
+
+    public void removeObserver(TimerObserver o) {
+        observers.remove(o);
+    }
+}

src/lab15_observer/ex2/TimerObserver.java

@@ -0,0 +1,5 @@
+package lab15_observer.ex2;
+
+public interface TimerObserver{
+    void update(int hours, int minutes, int seconds);
+}

src/lab16_composite/ex1/Entity.java

@@ -0,0 +1,8 @@
+package lab16_composite.ex1;
+
+public interface Entity {
+    void cry();
+    void simulateInjury();
+    void enterField();
+    void shoot();
+}

src/lab16_composite/ex1/Game.java

@@ -0,0 +1,33 @@
+package lab16_composite.ex1;
+
+public class Game {
+    public static void main(String[] args) {
+        Player jo = new Player(1);
+        Player jean = new Player(2);
+        Player paul = new Player(3);
+        jo.cry();
+        jean.cry();
+        jo.enterField();
+        Team team1 = new Team();
+        team1.add(jo);
+        team1.add(jean);
+        team1.add(paul);
+        team1.enterField();
+        team1.cry();
+        team1.simulateInjury();
+        Player martine = new Player(3);
+        Player isabelle = new Player(4);
+        Player mariePaule = new Player(5);
+
+        Team team2 = new Team();
+        team2.add(martine);
+        team2.add(isabelle);
+        team2.add(mariePaule);
+        team2.add(team1);
+        team2.enterField();
+        team2.cry();
+        team2.simulateInjury();
+        team2.remove(team1);
+        team2.simulateInjury();
+    }
+}

src/lab16_composite/ex1/Player.java

@@ -0,0 +1,30 @@
+package lab16_composite.ex1;
+
+public class Player implements Entity {
+    private int number;
+
+    public Player(int number) {
+        this.number = number;
+    }
+
+    @Override
+    public String toString() {
+        return "[Player " + number + "]";
+    }
+
+    public void cry() {
+        System.out.println(this + " ouin ouin");
+    }
+
+    public void enterField() {
+        System.out.println(this + " let's go !");
+    }
+
+    public void simulateInjury() {
+        System.out.println(this + " ouch !");
+    }
+
+    public void shoot() {
+        System.out.println(this + " encara Messi...");
+    }
+}

src/lab16_composite/ex1/Team.java

@@ -0,0 +1,44 @@
+package lab16_composite.ex1;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Team implements Entity {
+    private List<Entity> entities = new ArrayList<>();
+
+    public void add(Entity entity) {
+        entities.add(entity);
+    }
+
+    public void remove(Entity entity) {
+        entities.remove(entity);
+    }
+
+    @Override
+    public void cry() {
+        for (Entity entity : entities) {
+            entity.cry();
+        }
+    }
+
+    @Override
+    public void simulateInjury() {
+        for (Entity entity : entities) {
+            entity.simulateInjury();
+        }
+    }
+
+    @Override
+    public void enterField() {
+        for (Entity entity : entities) {
+            entity.enterField();
+        }
+    }
+
+    @Override
+    public void shoot() {
+        for (Entity entity : entities) {
+            entity.shoot();
+        }
+    }
+}

src/lab16_composite/ex3/TestTraversalAlgorithms.java

@@ -0,0 +1,74 @@
+package lab16_composite.ex3;
+
+import lab16_composite.ex3.algorithm.BFSSearch;
+import lab16_composite.ex3.algorithm.DFSSearch;
+import lab16_composite.ex3.algorithm.TraversalAlgorithm;
+import lab16_composite.ex3.component.Component;
+import lab16_composite.ex3.composite.Composite;
+import lab16_composite.ex3.leaf.Leaf;
+
+public class TestTraversalAlgorithms {
+    public static void main(String[] args) {
+        TestTraversalAlgorithms launcher = new TestTraversalAlgorithms();
+        launcher.launch();
+    }
+
+    public void launch() {
+
+        Component treeRoot = this.createTreeStruct();
+
+        //Instanciating one searchAlgoritm of each type.
+        TraversalAlgorithm dfs = new DFSSearch();
+        TraversalAlgorithm bfs = new BFSSearch();
+
+        //Launching DFS search for one existing element.
+        Component result = dfs.search(treeRoot, "Leaf 5");
+        System.out.println("1 element found by DFS: " + result);
+
+        //Launching BFS search for one existing element.
+        result = bfs.search(treeRoot, "Leaf 5");
+        System.out.println("1 element found by BFS : " + result);
+    }
+
+    //1. We create the tree.
+    //         node1
+    //         /    \
+    //		node2	node3
+    //		/  \	/   \
+    //	   l1  n4  n5   n6
+    //		   /\   \   / \
+    //       l2 l3  l4 l5 l6
+    //
+    //Creating the leafs.
+    private Component createTreeStruct() {
+        Leaf l1 = new Leaf("Leaf 1");
+        Leaf l2 = new Leaf("Leaf 2");
+        Leaf l3 = new Leaf("Leaf 3");
+        Leaf l4 = new Leaf("Leaf 4");
+        Leaf l5 = new Leaf("Leaf 5");
+        Leaf l6 = new Leaf("Leaf 6");
+
+        //Creating the nodes
+        Composite n1 = new Composite("Node 1");
+        Composite n2 = new Composite("Node 2");
+        Composite n3 = new Composite("Node 3");
+        Composite n4 = new Composite("Node 4");
+        Composite n5 = new Composite("Node 5");
+        Composite n6 = new Composite("Node 6");
+
+        //Assigning leaf and nodes to parents (nodes).
+        n6.add(l5);
+        n6.add(l6);
+        n5.add(l4);
+        n4.add(l2);
+        n4.add(l3);
+        n3.add(n5);
+        n3.add(n6);
+        n2.add(l1);
+        n2.add(n4);
+        n1.add(n2);
+        n1.add(n3);
+
+        return n1;
+    }
+}

src/lab16_composite/ex3/algorithm/BFSSearch.java

@@ -0,0 +1,13 @@
+package lab16_composite.ex3.algorithm;
+
+import lab16_composite.ex3.component.Component;
+
+import java.util.ArrayList;
+
+public class BFSSearch extends TraversalAlgorithm {
+
+    @Override
+    protected void addSuccessor(ArrayList<Component> newSuccessors) {
+        successors.addAll(newSuccessors);
+    }
+}

src/lab16_composite/ex3/algorithm/DFSSearch.java

@@ -0,0 +1,12 @@
+package lab16_composite.ex3.algorithm;
+
+import lab16_composite.ex3.component.Component;
+
+import java.util.ArrayList;
+
+public class DFSSearch extends TraversalAlgorithm {
+    @Override
+    protected void addSuccessor(ArrayList<Component> newSuccessors) {
+        successors.addAll(0, newSuccessors);
+    }
+}

src/lab16_composite/ex3/algorithm/TraversalAlgorithm.java

@@ -0,0 +1,27 @@
+package lab16_composite.ex3.algorithm;
+
+import lab16_composite.ex3.component.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class TraversalAlgorithm {
+    protected List<Component> successors = new ArrayList<>();
+
+    public Component search(Component root, String target) {
+        successors = new ArrayList<>();
+        successors.add(root);
+        while (true) {
+            if (successors.isEmpty()) {
+                return null;
+            }
+            Component component = successors.removeFirst();
+            if (component.getName().equals(target)) {
+                return component;
+            }
+            addSuccessor(component.getChildren());
+        }
+    }
+
+    protected abstract void addSuccessor(ArrayList<Component> newSuccessors);
+}

src/lab16_composite/ex3/component/Component.java

@@ -0,0 +1,23 @@
+package lab16_composite.ex3.component;
+
+import java.util.ArrayList;
+
+public abstract class Component {
+    public abstract String getName();
+
+    public void add(Component c) {
+        throw new UnsupportedOperationException();
+    }
+
+    public void remove(Component c) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Component getChild(int i) {
+        throw new UnsupportedOperationException();
+    }
+
+    public ArrayList<Component> getChildren() {
+        throw new UnsupportedOperationException();
+    }
+}

src/lab16_composite/ex3/composite/Composite.java

@@ -0,0 +1,52 @@
+package lab16_composite.ex3.composite;
+
+import lab16_composite.ex3.component.Component;
+
+import java.util.ArrayList;
+
+public class Composite extends Component {
+    private String name;
+    private final ArrayList<Component> children;
+
+    public Composite(String n) {
+        name = n;
+        children = new ArrayList<Component>();
+    }
+
+    public void setName(String n) {
+        name = n;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void add(Component c) {
+        children.add(c);
+    }
+
+    @Override
+    public void remove(Component c) {
+        children.remove(c);
+    }
+
+    @Override
+    public Component getChild(int i) {
+        return children.get(i);
+    }
+
+    @Override
+    public ArrayList<Component> getChildren() {
+        return children;
+    }
+
+    @Override
+    public String toString() {
+        String temp = "Composite " + name;
+        for (Component n : this.children) {
+            temp = temp + n.toString();
+        }
+        return temp;
+    }
+}

src/lab16_composite/ex3/leaf/Leaf.java

@@ -0,0 +1,30 @@
+package lab16_composite.ex3.leaf;
+
+import lab16_composite.ex3.component.Component;
+
+import java.util.ArrayList;
+
+public class Leaf extends Component {
+    //Attributes
+
+    private final String name;
+
+    //Constructor
+    public Leaf(String n) {
+        name = n;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return "Leaf " + name;
+    }
+
+    @Override
+    public ArrayList<Component> getChildren() {
+        return new ArrayList<Component>();
+    }
+}

src/lab8_builder/ex1/Car.java

@@ -0,0 +1,70 @@
+package lab8_builder.ex1;
+
+public class Car {
+    private String power;
+    private String engine;
+    private String breaks;
+    private String seats;
+    private String windows;
+    private String fuelType;
+    private final String carType;
+    public Car (String carType){
+        this.carType = carType;
+    }
+    public String getPower() {
+        return power;
+    }
+    public void setPower(String power) {
+        this.power = power;
+    }
+    public String getEngine() {
+        return engine;
+    }
+    public void setEngine(String engine) {
+        this.engine = engine;
+    }
+    public String getBreaks() {
+        return breaks;
+    }
+    public void setBreaks(String breaks) {
+        this.breaks = breaks;
+    }
+    public String getSeats() {
+        return seats;
+    }
+    public void setSeats(String seats) {
+        this.seats = seats;
+    }
+    public String getWindows() {
+        return windows;
+    }
+    public void setWindows(String windows) {
+        this.windows = windows;
+    }
+    public String getFuelType() {
+        return fuelType;
+    }
+    public void setFuelType(String fuelType) {
+        this.fuelType = fuelType;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("--------------"+carType+"--------------------- \n");
+        sb.append("\n Power: ");
+        sb.append(power);
+        sb.append("\n Engine: ");
+        sb.append(engine);
+        sb.append("\n Breaks: ");
+        sb.append(breaks);
+        sb.append("\n Seats: ");
+        sb.append(seats);
+        sb.append("\n Windows: ");
+        sb.append(windows);
+        sb.append("\n Fuel Type: ");
+        sb.append(fuelType);
+
+        return sb.toString();
+    }
+}

src/lab8_builder/ex1/CarBuilder.java

@@ -0,0 +1,20 @@
+package lab8_builder.ex1;
+
+public abstract class CarBuilder {
+    protected Car car;
+
+    protected abstract String getCarType();
+
+    public Car getCar() {
+        return car;
+    }
+
+    public void setCar(Car car) {
+        this.car = car;
+    }
+
+    public abstract void buildEngine();
+    public abstract void buildBreaks();
+    public abstract void buildSeats();
+    public abstract void buildWindows();
+}

src/lab8_builder/ex1/CarFactory.java

@@ -0,0 +1,20 @@
+package lab8_builder.ex1;
+
+public class CarFactory {
+    private CarBuilder builder;
+    private Car car;
+
+    public void setBuilder(CarBuilder builder) {
+        this.builder = builder;
+    }
+
+    public Car construct() {
+        car = new Car(builder.getCarType());
+        builder.setCar(car);
+        builder.buildEngine();
+        builder.buildBreaks();
+        builder.buildSeats();
+        builder.buildWindows();
+        return builder.getCar();
+    }
+}

src/lab8_builder/ex1/Main.java

@@ -0,0 +1,22 @@
+package lab8_builder.ex1;
+
+import lab8_builder.ex1.builders.BerlinBuilder;
+import lab8_builder.ex1.builders.SportBuilder;
+
+public class Main {
+    public static void main(String[] args) {
+        CarFactory factory = new CarFactory();
+
+        CarBuilder builder1 = new BerlinBuilder();
+        CarBuilder builder2 = new SportBuilder();
+
+        factory.setBuilder(builder1);
+        Car car1 = factory.construct();
+
+        factory.setBuilder(builder2);
+        Car car2 = factory.construct();
+
+        System.out.println(car1);
+        System.out.println(car2);
+    }
+}

src/lab8_builder/ex1/builders/BerlinBuilder.java

@@ -0,0 +1,32 @@
+package lab8_builder.ex1.builders;
+
+import lab8_builder.ex1.CarBuilder;
+
+public class BerlinBuilder extends CarBuilder {
+    @Override
+    protected String getCarType() {
+        return "Berlin";
+    }
+
+    @Override
+    public void buildEngine() {
+        car.setEngine("V12");
+        car.setFuelType("Diesel");
+        car.setPower("12'000 Horses");
+    }
+
+    @Override
+    public void buildBreaks() {
+        car.setBreaks("Premium Double Tungsten-Platinum Alloy");
+    }
+
+    @Override
+    public void buildSeats() {
+        car.setSeats("5");
+    }
+
+    @Override
+    public void buildWindows() {
+        car.setWindows("Tinted bullet-proof");
+    }
+}

src/lab8_builder/ex1/builders/SportBuilder.java

@@ -0,0 +1,32 @@
+package lab8_builder.ex1.builders;
+
+import lab8_builder.ex1.CarBuilder;
+
+public class SportBuilder extends CarBuilder {
+    @Override
+    protected String getCarType() {
+        return "Sports";
+    }
+
+    @Override
+    public void buildEngine() {
+        car.setEngine("V8");
+        car.setFuelType("Unleaded 95");
+        car.setPower("7'000 horses");
+    }
+
+    @Override
+    public void buildBreaks() {
+        car.setBreaks("Holo-magnetic and semi-cyclonic");
+    }
+
+    @Override
+    public void buildSeats() {
+        car.setSeats("2");
+    }
+
+    @Override
+    public void buildWindows() {
+        car.setWindows("Standard");
+    }
+}

src/learn/simple_composite/Component.java

@@ -0,0 +1,5 @@
+package learn.simple_composite;
+
+public interface Component {
+    void operation();
+}

src/learn/simple_composite/Composite.java

@@ -0,0 +1,27 @@
+package learn.simple_composite;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Composite implements Component {
+    private List<Component> children = new ArrayList<>();
+
+    @Override
+    public void operation() {
+        for (Component component : children) {
+            component.operation();
+        }
+    }
+
+    public void add(Component component) {
+        children.add(component);
+    }
+
+    public void remove(Component component) {
+        children.remove(component);
+    }
+
+    public Component getChild(int index) {
+        return children.get(index);
+    }
+}

src/learn/simple_composite/Leaf.java

@@ -0,0 +1,8 @@
+package learn.simple_composite;
+
+public class Leaf implements Component {
+    @Override
+    public void operation() {
+        System.out.println("Leaf operation" + this);
+    }
+}

src/learn/simple_composite/Main.java

@@ -0,0 +1,18 @@
+package learn.simple_composite;
+
+public class Main {
+    public static void main(String[] args) {
+        Composite root = new Composite();
+        Composite node1 = new Composite();
+        Composite node2 = new Composite();
+        Leaf l1 = new Leaf();
+        Leaf l2 = new Leaf();
+
+        root.add(node1);
+        node1.add(node2);
+        node2.add(l1);
+        node2.add(l2);
+
+        root.operation();
+    }
+}

src/learn/simple_flyweight/ConcreteFlyweight.java

@@ -0,0 +1,15 @@
+package learn.simple_flyweight;
+
+public class ConcreteFlyweight extends Flyweight {
+    private long intrinsicState;
+
+    public ConcreteFlyweight(long intrinsicState) {
+        super();
+        this.intrinsicState = intrinsicState;
+    }
+
+    @Override
+    public void operation(long extrinsicState) {
+        System.out.println("Flyweight " + intrinsicState + " calling operation with extrinsic state " + extrinsicState);
+    }
+}

src/learn/simple_flyweight/Flyweight.java

@@ -0,0 +1,13 @@
+package learn.simple_flyweight;
+
+import java.util.Arrays;
+
+public abstract class Flyweight {
+    private long[] internalStorage = new long[1000000];
+
+    public Flyweight() {
+        Arrays.fill(internalStorage, 1);
+    }
+
+    public abstract void operation(long extrinsicState);
+}

src/learn/simple_flyweight/FlyweightFactory.java

@@ -0,0 +1,17 @@
+package learn.simple_flyweight;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FlyweightFactory {
+    private static final Map<Integer, Flyweight> flyweights = new HashMap<>();
+
+    public Flyweight getFlyweight(Integer key) {
+        Flyweight flyweight = flyweights.get(key);
+        if (flyweight == null) {
+            flyweight = new ConcreteFlyweight(key);
+            flyweights.put(key, flyweight);
+        }
+        return flyweight;
+    }
+}

src/learn/simple_flyweight/Main.java

@@ -0,0 +1,40 @@
+package learn.simple_flyweight;
+
+import java.util.Random;
+
+public class Main {
+    private static final Random rand = new Random();
+
+    public static void main(String[] args) {
+        int rounds = 100;
+
+        debugMemory();
+        testFlyweight(rounds);
+        debugMemory();
+        testUnsharedFlyweight(rounds);
+        debugMemory();
+    }
+
+    private static void debugMemory() {
+        long totalMemory = Runtime.getRuntime().totalMemory();
+        long freeMemory = Runtime.getRuntime().freeMemory();
+        long usedMemory = totalMemory - freeMemory;
+        System.out.printf("Memory: %d%n", usedMemory);
+    }
+
+    private static void testFlyweight(int rounds) {
+        FlyweightFactory factory = new FlyweightFactory();
+
+        for (int i = 0; i < rounds; i++) {
+            Flyweight flyweight = factory.getFlyweight(rand.nextInt(10));
+            flyweight.operation(i);
+        }
+    }
+
+    private static void testUnsharedFlyweight(int rounds) {
+        for (int i = 0; i < rounds; i++) {
+            Flyweight flyweight = new UnsharedConcreteFlyweight(rand.nextInt(10));
+            flyweight.operation(i);
+        }
+    }
+}

src/learn/simple_flyweight/UnsharedConcreteFlyweight.java

@@ -0,0 +1,15 @@
+package learn.simple_flyweight;
+
+public class UnsharedConcreteFlyweight extends Flyweight {
+    private long allState;
+
+    public UnsharedConcreteFlyweight(long allState) {
+        super();
+        this.allState = allState;
+    }
+
+    @Override
+    public void operation(long extrinsicState) {
+        System.out.println("Unshared Flyweight " + allState + " calling operation with extrinsic state " + extrinsicState);
+    }
+}

src/learn/simple_observer/ConcreteObserver.java

@@ -0,0 +1,15 @@
+package learn.simple_observer;
+
+public class ConcreteObserver implements Observer {
+    private ConcreteSubject subject;
+
+    public ConcreteObserver(ConcreteSubject subject) {
+        this.subject = subject;
+        subject.registerObserver(this);
+    }
+
+    @Override
+    public void update() {
+        System.out.println("Observer was notified: subject has new state: " + subject.getState());
+    }
+}

src/learn/simple_observer/ConcreteSubject.java

@@ -0,0 +1,37 @@
+package learn.simple_observer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConcreteSubject implements Subject {
+    private List<Observer> observers = new ArrayList<>();
+    int state;
+
+    @Override
+    public void registerObserver(Observer o) {
+        observers.add(o);
+    }
+
+    @Override
+    public void removeObserver(Observer o) {
+        observers.remove(o);
+    }
+
+    @Override
+    public void notifyObservers() {
+        for (Observer o : observers) {
+            o.update();
+        }
+    }
+
+    public void setState(int state) {
+        this.state = state;
+        if (state > 50) {
+            notifyObservers();
+        }
+    }
+
+    public int getState() {
+        return state;
+    }
+}

src/learn/simple_observer/Main.java

@@ -0,0 +1,12 @@
+package learn.simple_observer;
+
+public class Main {
+    public static void main(String[] args) {
+        ConcreteSubject subject = new ConcreteSubject();
+        Observer observer = new ConcreteObserver(subject);
+        subject.setState(40);
+        subject.setState(100);
+        Observer observer2 = new ConcreteObserver(subject);
+        subject.setState(200);
+    }
+}

src/learn/simple_observer/Observer.java

@@ -0,0 +1,5 @@
+package learn.simple_observer;
+
+public interface Observer {
+    void update();
+}

src/learn/simple_observer/Subject.java

@@ -0,0 +1,7 @@
+package learn.simple_observer;
+
+public interface Subject {
+    void registerObserver(Observer o);
+    void removeObserver(Observer o);
+    void notifyObservers();
+}

src/learn/simple_proxy/Main.java

@@ -0,0 +1,8 @@
+package learn.simple_proxy;
+
+public class Main {
+    public static void main(String[] args) {
+        Subject subject = new Proxy();
+        subject.request();
+    }
+}

src/learn/simple_proxy/Proxy.java

@@ -0,0 +1,11 @@
+package learn.simple_proxy;
+
+public class Proxy implements Subject {
+    private RealSubject realSubject = new RealSubject();
+
+    @Override
+    public void request() {
+        System.out.println("Proxy does some preliminary job and checks");
+        realSubject.request();
+    }
+}

src/learn/simple_proxy/RealSubject.java

@@ -0,0 +1,8 @@
+package learn.simple_proxy;
+
+public class RealSubject implements Subject {
+    @Override
+    public void request() {
+        System.out.println("Real subject action");
+    }
+}

src/learn/simple_proxy/Subject.java

@@ -0,0 +1,5 @@
+package learn.simple_proxy;
+
+public interface Subject {
+    public void request();
+}

src/learn/simple_strategy/ConcreteStrategyA.java

@@ -0,0 +1,8 @@
+package learn.simple_strategy;
+
+public class ConcreteStrategyA implements Strategy {
+    @Override
+    public void algorithm() {
+        System.out.println("nice strategy A");
+    }
+}

src/learn/simple_strategy/ConcreteStrategyB.java

@@ -0,0 +1,8 @@
+package learn.simple_strategy;
+
+public class ConcreteStrategyB implements Strategy {
+    @Override
+    public void algorithm() {
+        System.out.println("nice strategy B");
+    }
+}

src/learn/simple_strategy/Context.java

@@ -0,0 +1,17 @@
+package learn.simple_strategy;
+
+public class Context {
+    private Strategy currentStrategy;
+
+    public Context(Strategy currentStrategy) {
+        this.currentStrategy = currentStrategy;
+    }
+
+    public void setCurrentStrategy(Strategy currentStrategy) {
+        this.currentStrategy = currentStrategy;
+    }
+
+    public void doSomeJob() {
+        currentStrategy.algorithm();
+    }
+}

src/learn/simple_strategy/Main.java

@@ -0,0 +1,11 @@
+package learn.simple_strategy;
+
+public class Main {
+    public static void main(String[] args) {
+        Context context = new Context(new ConcreteStrategyB());
+
+        context.doSomeJob();
+        context.setCurrentStrategy(new ConcreteStrategyA());
+        context.doSomeJob();
+    }
+}

src/learn/simple_strategy/Strategy.java

@@ -0,0 +1,5 @@
+package learn.simple_strategy;
+
+public interface Strategy {
+    void algorithm();
+}