✏️ Exercices : Approche structurelle

public void printI() {
    for(int i=0; i < 10; i++) {
        System.out.println("I is: " + i);
    }
}

public boolean m(String[] strings) {
    boolean found = false;
    int i = 0;
    while( i < strings.length ) {
        if(! strings[i].startsWith("J")) {
            i++;
            continue;
        }
        if(! strings[i].startsWith("G")) {
            found = true;
            break;
        }
        i++;
    }
    return found;
}

public int startsWithJ(String[] strings) {
    int wordsStartingWithJ = 0;
    for(String each : strings) {
        if(! each.startsWith("J")) {
            continue;
        }
        wordsStartingWithJ++;
    }
    return wordsStartingWithJ;
}

import java.lang.ref.WeakReference;
public class Queue<E> {
    protected Object[] values = new Object[10];
    protected Entry<E>[] entries = new Entry[10];
    protected int valuesLength;

    public void add(E value, Entry<E> entry) {
        int length = values.length;
        if (valuesLength == length) {
            Object[] newValues = new Object[2 * length];
            System.arraycopy(values, 0, newValues, 0, valuesLength);
            values = newValues;
        }
        if (entries == null || valuesLength == entries.length) {
            Entry<E>[] newEntries = new Entry[2 * length];
            if (entries != null) {System.arraycopy(entries, 0, newEntries, 0, valuesLength);}
            entries = newEntries;
        }
        values[valuesLength] = value;
        entries[valuesLength++] = entry;
    }
    protected static class Entry<E> extends WeakReference<E> {
        public final int hashCode = 0;
        private Entry() {
            super(null);
        }}}

/**
 * Searches for the first occurrence of the given argument in list starting from
 * a specified index. The equality is tested using both the operator '==' and
 * the 'equals' method.
 *
 * @param list the list in which the object must be searched.
 * @param o the object to search.
 * @param fromIndex the index in 'list' from which the search must start.
 * @return the index of the first occurrence of 'o' in 'list' (where
 *         index>=fromIndex); returns -1 if the object is not found.
 */
public static int indexOf(List<?> list, Object o, int fromIndex) {
    if (fromIndex < 0) {
        fromIndex = 0;
    }

    int size = list.size();
    for (int i = fromIndex; i < size; i++) {
        Object element = list.get(i);
        if (o == null) {
            if (element == null) {
                return i;
            }
        } else if (o == element || o.equals(element)) {
            return i;
        }
    }
    return -1;
}

/**
 * Construct a BasicAlarmClock.
 *
 * @param ring The value for 'ring'. Should be in [0; 10].
 * @param hour The value for 'hour'. Should be in [0; 23].
 * @param min The value for 'min'. Should be in [0; 59].
 * @throws AlarmClockException If one parameter is out of bounds.
 */
protected BasicAlarmClock(int ring, int hour, int min) throws AlarmClockException {
    if (hour < 0) {
        throw new AlarmClockException("bad hour: inf value");
    } else if (hour > 23) {
        throw new AlarmClockException("bad hour: sup value");
    } else if (min < 0) {
        throw new AlarmClockException("bad min: inf value");
    } else if (min > 59) {
        throw new AlarmClockException("bad min: sup value");
    } else if ((ring < 1) || (ring > 10)) {
        throw new AlarmClockException("bad ringtone: out of limits");
    } else {
        this.ring = ring;
        this.hour = hour;
        this.min = min;
    }
}

public class Pawn {

    /**
     * Position of the pawn in the board.
     */
    private Position position;

    /**
     * The board on which the pawn is located
     */
    private Board board;

    /**
     * The remaining number of hitpoints of the pawn
     */
    private int hitpoints;

    /**
     * The collected gold of the pawn.
     */
    private int gold;

    /**
     * The char that represents the pawn.
     */
    private char letter;

    /**
     * Create a Pawn with 2 hitpoints and 0 gold.
     *
     * @param n     The letter that represents the pawn.
     * @param x     Position on the x axis
     * @param y     Position on the y axis
     * @param board The board on which the pawn is located
     */
    public Pawn(char n, int x, int y, Board board) {
        this.letter = n;
        this.position = new Position(x, y);
        this.board = board;
        this.hitpoints = 2;
        this.gold = 0;
    }

    …

}

/**
* Make the pawn attack another position. If any, the enemy pawn should
* suffer 1 damage, but it should suffer 2 damages if the current pawn
* is on a bonus square.
*
* If the enemy pawn dies, then the current pawn obtains 1 gold.
*
* @param enemy The attacked pawn.
* @throws ImpossibleActionException If the target position is too far or empty.
*/
public void attack(Position p) throws ImpossibleActionException {

    if (this.position.isNextTo(p)) {
        Pawn enemy = this.board.getSquareContent(p);
        if (enemy == null) {
            throw new ImpossibleActionException("There is no enemy pawn in that position, cannot attack.");
        } else {
            Logger.log(this.letter + " attacks!\n");
            if (this.board.isBonusSquare(this.position))
                enemy.suffer(2);
            else
                enemy.suffer(1);
            if (enemy.isDead())
                gold++;
        }
    } else {
        throw new ImpossibleActionException("Square is too far, cannot attack.");
    }

}