Composite (padrão de desenho)/Exercício 1: Verificador

Problema

Os elementos de uma colecção de nomes (String) têm um conjunto de propriedades a verificar. Para tal, foi criado um verificador automático que faz uso de avaliadores booleanos representados por objectos. Cada avaliador booleano tem uma função ok que aceita uma String e devolve um valor booleano. Implemente os seguintes predicados e operadores: NonZeroLength, LengthIsEven, LengthIsOdd, LengthGreaterThan, LengthLesserThan, LengthEqualTo, And (operador binário que é verdadeiro quando dois elementos são verdadeiros), Or (operador binário que é falso quando dois elementos são falsos), Not (operador unário que é verdadeiro quando o seu argumento é falso).

Exemplo:

String s1 = "batata";
String s2 = "oo";
String s3 = "xyz";
Validator v = new Or(new And(new LengthGreaterThan(5),
              new LengthLesserThan(8)), new LengthEqualTo(2));
boolean b1 = v.ok(s1); // true
boolean b2 = v.ok(s2); // true
boolean b3 = v.ok(s3); // false

Solução

Classe Validator

/**
 * Abstract validator class.
 */
public abstract class Validator {
	/**
	 * @param string
	 * @return true if the string is valid according to some criterion; false
	 *         otherwise.
	 */
	public abstract boolean ok(String string);
}

Classe UnaryOperator

/**
 * A simple unary operator.
 */
public abstract class UnaryOperator extends Validator {

	/**
	 * The argument.
	 */
	protected Validator _validator;

	/**
	 * @param validator
	 */
	public UnaryOperator(Validator validator) {
		_validator = validator;
	}

}

Classe Not

/**
 * Negation operator.
 */
public class Not extends UnaryOperator {

	/**
	 * @param validator
	 */
	public Not(Validator validator) {
		super(validator);
	}

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return !_validator.ok(string);
	}

}

Classe BinaryOperator

/**
 * A simple binary operator.
 */
public abstract class BinaryOperator extends Validator {

	/**
	 * The 1st argument.
	 */
	protected Validator _first;

	/**
	 * The 2nd argument.
	 */
	protected Validator _second;

	/**
	 * @param first
	 * @param second
	 */
	public BinaryOperator(Validator first, Validator second) {
		_first = first;
		_second = second;
	}

}

Classe And

/**
 * AND operation.
 */
public class And extends BinaryOperator {

	/**
	 * @param first
	 * @param second
	 */
	public And(Validator first, Validator second) {
		super(first, second);
	}

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return _first.ok(string) && _second.ok(string);
	}

}

Classe Or

/**
 * AND operation.
 */
public class Or extends BinaryOperator {

	/**
	 * @param first
	 * @param second
	 */
	public Or(Validator first, Validator second) {
		super(first, second);
	}

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return _first.ok(string) || _second.ok(string);
	}

}

Classe IntegerComparisonOperator

/**
 * Compare some integer value with a reference.
 */
public abstract class IntegerComparisonOperator extends Validator {

	/**
	 * The reference (an integer).
	 */
	protected int _reference;

	/**
	 * @param reference
	 */
	public IntegerComparisonOperator(int reference) {
		_reference = reference;
	}
}

Classe LengthGreaterThan

/**
 * Return true if string length is lesser than the reference.
 */
public class LengthGreaterThan extends IntegerComparisonOperator {

	/**
	 * @param reference
	 */
	public LengthGreaterThan(int reference) {
		super(reference);
	}

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return string.length() > _reference;
	}

}

Classe LengthLesserThan

/**
 * Return true if string length is greater than reference.
 */
public class LengthLesserThan extends IntegerComparisonOperator {

	/**
	 * @param reference
	 */
	public LengthLesserThan(int reference) {
		super(reference);
	}

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return string.length() < _reference;
	}

}

Classe LengthEqualTo

/**
 * Return true if string length is equal to the reference.
 */
public class LengthEqualTo extends IntegerComparisonOperator {

	/**
	 * @param reference
	 */
	public LengthEqualTo(int reference) {
		super(reference);
	}

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return string.length() == _reference;
	}

}

Classe LengthIsEven

/**
 * True for non-empty strings.
 */
public class LengthIsEven extends Validator {

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return string.length() % 2 != 0;
	}

}

Classe LengthIsOdd

/**
 * True for non-empty strings.
 */
public class LengthIsOdd extends Validator {

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return string.length() % 2 == 0;
	}

}

Classe NonZeroLength

/**
 * True for non-empty strings.
 */
public class NonZeroLength extends Validator {

	/**
	 * @see Validator#ok(java.lang.String)
	 */
	@Override
	public boolean ok(String string) {
		return string.length() != 0;
	}

}

Classe App

/**
 * A simple application.
 */
public class App {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s1 = "batata";
		String s2 = "oo";
		String s3 = "xyz";
		Validator v = new Or(new And(new LengthGreaterThan(5),
				new LengthLesserThan(8)), new LengthEqualTo(2));
		boolean b1 = v.ok(s1); // true
		boolean b2 = v.ok(s2); // true
		boolean b3 = v.ok(s3); // false
		System.out.println("b1=" + b1 + " b2=" + b2 + " b3=" + b3);
	}

}

Compilação e Execução

Execução

java App

Resultado:

b1=true b2=true b3=false