added lab16 ex3

src/lab10_memento/ex1/CheckpointManager.java

@@ -0,0 +1,17 @@
+package lab10_memento.ex1;
+
+public class CheckpointManager {
+    private Player.Checkpoint lastCheckpoint = null;
+
+    public void save(Player player) {
+        lastCheckpoint = player.makeCheckpoint();
+    }
+
+    public void restore(Player player) {
+        if (lastCheckpoint != null) {
+            lastCheckpoint.restore(player);
+        } else {
+            System.out.println("No checkpoint to restore");
+        }
+    }
+}

src/lab10_memento/ex1/Game.java

@@ -0,0 +1,60 @@
+package lab10_memento.ex1;
+
+public class Game {
+    private final Player player;
+    private final CheckpointManager checkpointManager;
+
+    public Game() {
+        player = new Player(0, 0, 0);
+        checkpointManager = new CheckpointManager();
+    }
+
+    public void printInfo() {
+        System.out.println("Player position: (" + player.getX() + "," + player.getY() + ")");
+        System.out.println("Player score: " + player.getScore());
+        System.out.println();
+    }
+
+    public void doTurn(int dx, int dy, int score, boolean isCheckpoint) {
+        player.moveTo(player.getX() + dx, player.getY() + dy);
+        System.out.print("Player moves to (" + player.getX() + "," + player.getY() + ")");
+        if (score != 0) {
+            player.increaseScore(score);
+            System.out.print(" and gains +" + score + " score");
+        }
+        if (isCheckpoint) {
+            checkpointManager.save(player);
+            System.out.print(". It's a checkpoint and their position and score are saved");
+        }
+        System.out.println();
+        printInfo();
+    }
+
+    public void doTurn(int dx, int dy) {
+        doTurn(dx, dy, 0, false);
+    }
+
+    public void doTurn(int dx, int dy, int score) {
+        doTurn(dx, dy, score, false);
+    }
+
+    public void doTurn(int dx, int dy, boolean isCheckpoint) {
+        doTurn(dx, dy, 0, isCheckpoint);
+    }
+
+    public void die() {
+        checkpointManager.restore(player);
+        System.out.println("Player died ! Returning to previous checkpoint");
+        printInfo();
+    }
+
+    public static void main(String[] args) {
+        Game game = new Game();
+
+        game.printInfo();
+        game.doTurn(1, 1, 100);
+        game.doTurn(1, 1, true);
+        game.doTurn(4, 4, 100);
+        game.die();
+    }
+}

src/lab10_memento/ex1/Player.java

@@ -0,0 +1,68 @@
+package lab10_memento.ex1;
+
+public class Player {
+    private int x;
+    private int y;
+    private int score;
+
+    public Player(int x, int y, int score) {
+        this.x = x;
+        this.y = y;
+        this.score = score;
+    }
+
+    public void moveTo(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void increaseScore(int score) {
+        this.score += score;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public int getScore() {
+        return score;
+    }
+
+    public Checkpoint makeCheckpoint() {
+        return new Checkpoint(this);
+    }
+
+    public class Checkpoint {
+        private final int x;
+        private final int y;
+        private final int score;
+
+        public Checkpoint(Player player) {
+            x = player.getX();
+            y = player.getY();
+            score = player.getScore();
+        }
+
+        public int getX() {
+            return x;
+        }
+
+        public int getY() {
+            return y;
+        }
+
+        public int getScore() {
+            return score;
+        }
+
+        public void restore(Player player) {
+            player.x = this.getX();
+            player.y = this.getY();
+            player.score = this.getScore();
+        }
+    }
+}

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/lab1_decorator/ex2/Circle.java

@@ -9,6 +9,6 @@ public class Circle extends Shape {
 
     @Override
     public void draw() {
-        System.out.println("Drawing a circle");
+        System.out.printf("Drawing a circle of radius %fpx%n", radius);
     }
 }

src/lab1_decorator/ex2/Rectangle.java

@@ -11,6 +11,6 @@ public class Rectangle extends Shape {
 
     @Override
     public void draw() {
-        System.out.println("Drawing a rectangle");
+        System.out.printf("Drawing a rectangle of width %fpx and height %fpx%n", width, height);
     }
 }

src/lab1_decorator/ex2/Square.java

@@ -9,6 +9,6 @@ public class Square extends Shape {
 
     @Override
     public void draw() {
-        System.out.println("Drawing a square");
+        System.out.printf("Drawing a square of size %fpx%n", size);
     }
 }

src/lab2_factory_method/ex1/Car.java

@@ -0,0 +1,15 @@
+package lab2_factory_method.ex1;
+
+public abstract class Car {
+    private String color = "blank";
+
+    public Car() {}
+    public abstract String getName();
+    public String getColor() {
+        return color;
+    }
+    public void paintColor(String color) {
+        this.color = color;
+        System.out.println("Painting car in " + color);
+    }
+}

src/lab2_factory_method/ex1/CarCreator.java

@@ -0,0 +1,10 @@
+package lab2_factory_method.ex1;
+
+public abstract class CarCreator {
+    public Car orderCar(String color) {
+        Car car = createCar();
+        car.paintColor(color);
+        return car;
+    }
+    public abstract Car createCar();
+}

src/lab2_factory_method/ex1/Coupe.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex1;
+
+public class Coupe extends Car {
+    @Override
+    public String getName() {
+        return  "Coupe";
+    }
+}

src/lab2_factory_method/ex1/CoupeCreator.java

@@ -0,0 +1,9 @@
+package lab2_factory_method.ex1;
+
+public class CoupeCreator extends CarCreator {
+
+    @Override
+    public Car createCar() {
+        return new Coupe();
+    }
+}

src/lab2_factory_method/ex1/Minivan.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex1;
+
+public class Minivan extends Car {
+    @Override
+    public String getName() {
+        return "Minivan";
+    }
+}

src/lab2_factory_method/ex1/MinivanCreator.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex1;
+
+public class MinivanCreator extends CarCreator {
+    @Override
+    public Car createCar() {
+        return new Minivan();
+    }
+}

src/lab2_factory_method/ex1/Pickup.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex1;
+
+public class Pickup extends Car {
+    @Override
+    public String getName() {
+        return "Pickup";
+    }
+}

src/lab2_factory_method/ex1/PickupCreator.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex1;
+
+public class PickupCreator extends CarCreator {
+    @Override
+    public Car createCar() {
+        return new Pickup();
+    }
+}

src/lab2_factory_method/ex1/Program.java

@@ -0,0 +1,21 @@
+package lab2_factory_method.ex1;
+
+public class Program {
+    public static void main(String[] args) {
+        CarCreator coupeCreator = new CoupeCreator();
+        CarCreator minivanCreator = new MinivanCreator();
+        CarCreator pickupCreator = new PickupCreator();
+        Car c1 = coupeCreator.orderCar("red");
+        System.out.println("Car "
+                + c1.getName()
+                + " "
+                + c1.getColor()
+                + " has been ordered.");
+        Car c2 = minivanCreator.orderCar("red");
+        System.out.println("Car "
+                + c2.getName()
+                + " "
+                + c2.getColor()
+                + " has been ordered.");
+    }
+}

src/lab2_factory_method/ex2/ArchitectOffice.java

@@ -0,0 +1,19 @@
+package lab2_factory_method.ex2;
+
+public class ArchitectOffice {
+    public static void main(String[] args) {
+        HouseCreator glassHouseCreator = new GlassHouseCreator();
+        HouseCreator bricksHouseCreator = new BricksHouseCreator();
+        HouseCreator woodHouseCreator = new WoodHouseCreator();
+
+        House house1 = glassHouseCreator.create();
+        house1.buildHouse();
+        house1.calculatePrice();
+        House house2 = bricksHouseCreator.create();
+        house2.buildHouse();
+        house2.calculatePrice();
+        House house3 = woodHouseCreator.create();
+        house3.buildHouse();
+        house3.calculatePrice();
+    }
+}

src/lab2_factory_method/ex2/BricksHouse.java

@@ -0,0 +1,13 @@
+package lab2_factory_method.ex2;
+
+public class BricksHouse extends House {
+    @Override
+    public void buildHouse() {
+        System.out.println("Building a bricks house");
+    }
+
+    @Override
+    public void calculatePrice() {
+        System.out.println("Modest bricks house");
+    }
+}

src/lab2_factory_method/ex2/BricksHouseCreator.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex2;
+
+public class BricksHouseCreator extends HouseCreator {
+    @Override
+    public House create() {
+        return new BricksHouse();
+    }
+}

src/lab2_factory_method/ex2/GlassHouse.java

@@ -0,0 +1,13 @@
+package lab2_factory_method.ex2;
+
+public class GlassHouse extends House {
+    @Override
+    public void buildHouse() {
+        System.out.println("Building a glass house");
+    }
+
+    @Override
+    public void calculatePrice() {
+        System.out.println("Expensive glass house");
+    }
+}

src/lab2_factory_method/ex2/GlassHouseCreator.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex2;
+
+public class GlassHouseCreator extends HouseCreator {
+    @Override
+    public House create() {
+        return new GlassHouse();
+    }
+}

src/lab2_factory_method/ex2/House.java

@@ -0,0 +1,6 @@
+package lab2_factory_method.ex2;
+
+public abstract class House {
+    public abstract void buildHouse();
+    public abstract void calculatePrice();
+}

src/lab2_factory_method/ex2/HouseCreator.java

@@ -0,0 +1,5 @@
+package lab2_factory_method.ex2;
+
+public abstract class HouseCreator {
+    public abstract House create();
+}

src/lab2_factory_method/ex2/WoodHouse.java

@@ -0,0 +1,13 @@
+package lab2_factory_method.ex2;
+
+public class WoodHouse extends House {
+    @Override
+    public void buildHouse() {
+        System.out.println("Building a wooden house");
+    }
+
+    @Override
+    public void calculatePrice() {
+        System.out.println("Mid range wooden chalet");
+    }
+}

src/lab2_factory_method/ex2/WoodHouseCreator.java

@@ -0,0 +1,8 @@
+package lab2_factory_method.ex2;
+
+public class WoodHouseCreator extends HouseCreator {
+    @Override
+    public House create() {
+        return new WoodHouse();
+    }
+}

src/lab3_abstract_factory/ex1/AbstractDoor.java

@@ -0,0 +1,5 @@
+package lab3_abstract_factory.ex1;
+
+public abstract class AbstractDoor {
+    public abstract int getPrice();
+}

src/lab3_abstract_factory/ex1/AbstractWall.java

@@ -0,0 +1,5 @@
+package lab3_abstract_factory.ex1;
+
+public abstract class AbstractWall {
+    public abstract int getPrice();
+}

src/lab3_abstract_factory/ex1/AbstractWindows.java

@@ -0,0 +1,5 @@
+package lab3_abstract_factory.ex1;
+
+public abstract class AbstractWindows {
+    public abstract int getPrice();
+}

src/lab3_abstract_factory/ex1/ArchitectOffice.java

@@ -0,0 +1,26 @@
+package lab3_abstract_factory.ex1;
+
+import lab3_abstract_factory.ex1.house_factories.DutchHouseFactory;
+import lab3_abstract_factory.ex1.house_factories.GermanHouseFactory;
+import lab3_abstract_factory.ex1.house_factories.SwissWoodChaletFactory;
+
+public class ArchitectOffice {
+    public static void main(String[] args) {
+        House house1 = new House("Modern German house",
+                new GermanHouseFactory());
+        house1.buildHouse();
+        house1.calculatePrice();
+        House house2 = new House("Typical dutch house",
+                new DutchHouseFactory());
+        house2.buildHouse();
+        house2.calculatePrice();
+        House house3 = new House("Swiss wood chalet",
+                new SwissWoodChaletFactory());
+        house3.buildHouse();
+        house3.calculatePrice();
+
+        System.out.println(house1);
+        System.out.println(house2);
+        System.out.println(house3);
+    }
+}

src/lab3_abstract_factory/ex1/House.java

@@ -0,0 +1,46 @@
+package lab3_abstract_factory.ex1;
+
+public class House {
+    private String name;
+    private HouseFactory houseFactory;
+    private AbstractWall wall;
+    private AbstractWindows windows;
+    private AbstractDoor door;
+
+    public House(String name, HouseFactory houseFactory) {
+        this.name = name;
+        this.houseFactory = houseFactory;
+    }
+
+    public void buildHouse() {
+        wall = houseFactory.buildWall();
+        windows = houseFactory.buildWindows();
+        door = houseFactory.buildDoor();
+        System.out.println(
+            "Building a house with "
+                + wall
+                + ", "
+                + windows
+                + " and a "
+                + door
+        );
+    }
+
+    public void calculatePrice() {
+        int total = 0;
+        total += wall.getPrice();
+        total += windows.getPrice();
+        total += door.getPrice();
+
+        System.out.println("Total price: " + total);
+    }
+
+    @Override
+    public String toString() {
+        return "House '" + name + "' (\n"
+                + "  Walls: " + wall + "\n"
+                + "  Windows: " + windows + "\n"
+                + "  Door: " + door + "\n"
+                + ")";
+    }
+}

src/lab3_abstract_factory/ex1/HouseFactory.java

@@ -0,0 +1,7 @@
+package lab3_abstract_factory.ex1;
+
+public abstract class HouseFactory {
+    public abstract AbstractWall buildWall();
+    public abstract AbstractWindows buildWindows();
+    public abstract AbstractDoor buildDoor();
+}

src/lab3_abstract_factory/ex1/doors/LargeDoor.java

@@ -0,0 +1,15 @@
+package lab3_abstract_factory.ex1.doors;
+
+import lab3_abstract_factory.ex1.AbstractDoor;
+
+public class LargeDoor extends AbstractDoor {
+    @Override
+    public int getPrice() {
+        return 50;
+    }
+
+    @Override
+    public String toString() {
+        return "large door";
+    }
+}

src/lab3_abstract_factory/ex1/doors/ThinDoor.java

@@ -0,0 +1,15 @@
+package lab3_abstract_factory.ex1.doors;
+
+import lab3_abstract_factory.ex1.AbstractDoor;
+
+public class ThinDoor extends AbstractDoor {
+    @Override
+    public int getPrice() {
+        return 25;
+    }
+
+    @Override
+    public String toString() {
+        return "thin door";
+    }
+}

src/lab3_abstract_factory/ex1/house_factories/DutchHouseFactory.java

@@ -0,0 +1,26 @@
+package lab3_abstract_factory.ex1.house_factories;
+
+import lab3_abstract_factory.ex1.AbstractDoor;
+import lab3_abstract_factory.ex1.AbstractWall;
+import lab3_abstract_factory.ex1.AbstractWindows;
+import lab3_abstract_factory.ex1.HouseFactory;
+import lab3_abstract_factory.ex1.doors.LargeDoor;
+import lab3_abstract_factory.ex1.walls.BricksWall;
+import lab3_abstract_factory.ex1.windows.FramedWindows;
+
+public class DutchHouseFactory extends HouseFactory {
+    @Override
+    public AbstractWall buildWall() {
+        return new BricksWall();
+    }
+
+    @Override
+    public AbstractWindows buildWindows() {
+        return new FramedWindows();
+    }
+
+    @Override
+    public AbstractDoor buildDoor() {
+        return new LargeDoor();
+    }
+}

src/lab3_abstract_factory/ex1/house_factories/GermanHouseFactory.java

@@ -0,0 +1,26 @@
+package lab3_abstract_factory.ex1.house_factories;
+
+import lab3_abstract_factory.ex1.AbstractDoor;
+import lab3_abstract_factory.ex1.AbstractWall;
+import lab3_abstract_factory.ex1.AbstractWindows;
+import lab3_abstract_factory.ex1.HouseFactory;
+import lab3_abstract_factory.ex1.doors.LargeDoor;
+import lab3_abstract_factory.ex1.walls.GlassWall;
+import lab3_abstract_factory.ex1.windows.FullHeightWindows;
+
+public class GermanHouseFactory extends HouseFactory {
+    @Override
+    public AbstractWall buildWall() {
+        return new GlassWall();
+    }
+
+    @Override
+    public AbstractWindows buildWindows() {
+        return new FullHeightWindows();
+    }
+
+    @Override
+    public AbstractDoor buildDoor() {
+        return new LargeDoor();
+    }
+}

src/lab3_abstract_factory/ex1/house_factories/SwissWoodChaletFactory.java

@@ -0,0 +1,26 @@
+package lab3_abstract_factory.ex1.house_factories;
+
+import lab3_abstract_factory.ex1.AbstractDoor;
+import lab3_abstract_factory.ex1.AbstractWall;
+import lab3_abstract_factory.ex1.AbstractWindows;
+import lab3_abstract_factory.ex1.HouseFactory;
+import lab3_abstract_factory.ex1.doors.ThinDoor;
+import lab3_abstract_factory.ex1.walls.WoodWall;
+import lab3_abstract_factory.ex1.windows.FramedWindows;
+
+public class SwissWoodChaletFactory extends HouseFactory {
+    @Override
+    public AbstractWall buildWall() {
+        return new WoodWall();
+    }
+
+    @Override
+    public AbstractWindows buildWindows() {
+        return new FramedWindows();
+    }
+
+    @Override
+    public AbstractDoor buildDoor() {
+        return new ThinDoor();
+    }
+}

src/lab3_abstract_factory/ex1/walls/BricksWall.java

@@ -0,0 +1,15 @@
+package lab3_abstract_factory.ex1.walls;
+
+import lab3_abstract_factory.ex1.AbstractWall;
+
+public class BricksWall extends AbstractWall {
+    @Override
+    public int getPrice() {
+        return 10;
+    }
+
+    @Override
+    public String toString() {
+        return "brick walls";
+    }
+}