m (→Exemplo de Aplicação) |
|||
(One intermediate revision by the same user not shown) | |||
Line 2: | Line 2: | ||
== Problema == | == Problema == | ||
− | # Considere a tabela da Aula | + | # Considere a tabela da [[Polimorfismo, Interfaces, Classes Abstractas/Exercício 02: Tabelas e Predicados|Aula Prática 05]]. Redefina a classe como sendo comparável. Diz-se que uma tabela é menor/igual/maior que outra quando se verificar a relação menor/igual/maior entre as somas dos elementos de cada uma. |
# Considere ainda o caso da alínea anterior. Defina agora dois comparadores (devem ser implementados como classes internas da tabela) que estabelecem as relações de comparação relativamente (i) aos máximos das tabelas e (ii) ao número de elementos (independentemente dos valores). | # Considere ainda o caso da alínea anterior. Defina agora dois comparadores (devem ser implementados como classes internas da tabela) que estabelecem as relações de comparação relativamente (i) aos máximos das tabelas e (ii) ao número de elementos (independentemente dos valores). | ||
# Considere agora, em lugar de tabelas de inteiros, que as tabelas contêm gatos (classe definida acima). Altere o código da alínea 2(i) para que funcione com as tabelas de gatos. | # Considere agora, em lugar de tabelas de inteiros, que as tabelas contêm gatos (classe definida acima). Altere o código da alínea 2(i) para que funcione com as tabelas de gatos. | ||
Line 13: | Line 13: | ||
{{CollapsedCode|Ficheiro '''Table.java'''| | {{CollapsedCode|Ficheiro '''Table.java'''| | ||
− | < | + | <source lang="java"> |
/** | /** | ||
* A table holding a fixed number of integers. | * A table holding a fixed number of integers. | ||
− | * | + | * |
* It is possible to verify certain predicates against the table's contents. | * It is possible to verify certain predicates against the table's contents. | ||
*/ | */ | ||
public class Table implements Comparable<Table> { | public class Table implements Comparable<Table> { | ||
− | + | /** | |
− | + | * Space for a fixed number of integers. | |
− | + | */ | |
− | + | int _vector[]; | |
− | + | /** | |
− | + | * @param nInts | |
− | + | * number of integers to store. | |
− | + | */ | |
− | + | public Table(int nInts) { | |
− | + | _vector = new int[nInts]; | |
− | + | } | |
− | + | /** | |
− | + | * FIXME: insert checks to ensure position is within range. | |
− | + | * | |
− | + | * @param position | |
− | + | * position to define | |
− | + | * @return value at position | |
− | + | */ | |
− | + | public int getValue(int position) { | |
− | + | return _vector[position]; | |
− | + | } | |
− | + | /** | |
− | + | * FIXME: insert checks to ensure position is within range. | |
− | + | * | |
− | + | * @param position | |
− | + | * position to define | |
− | + | * @param value | |
− | + | * value to set | |
− | + | */ | |
− | + | public void setValue(int position, int value) { | |
− | + | _vector[position] = value; | |
− | + | } | |
− | + | /** | |
− | + | * Set all positions to the same value. | |
− | + | * | |
− | + | * @param value | |
− | + | * value to set | |
− | + | */ | |
− | + | public void setAll(int value) { | |
− | + | for (int position = 0; position < _vector.length; position++) | |
− | + | _vector[position] = value; | |
− | + | } | |
− | + | /** | |
− | + | * @param predicate | |
− | + | * the predicate to validate. | |
− | + | * @return true, if the predicate is valid for at least one position; false, | |
− | + | * otherwise. | |
− | + | */ | |
− | + | public boolean contains(SelectionPredicate predicate) { | |
− | + | for (int position = 0; position < _vector.length; position++) | |
− | + | if (predicate.ok(_vector[position])) | |
− | + | return true; | |
− | + | return false; | |
− | + | } | |
− | + | /** | |
− | + | * This method makes it easy to get the sum of all elements. As with the | |
− | + | * predicate, this type of algorithm could also be provided from outside: | |
− | + | * instead of a selector, a collector would have to be provided. | |
− | + | * | |
− | + | * @return sum of all elements. | |
− | + | */ | |
− | + | public int getSum() { | |
− | + | int sum = 0; | |
− | + | for (int i : _vector) | |
− | + | sum += i; | |
− | + | return sum; | |
− | + | } | |
− | + | /** | |
− | + | * @see java.lang.Comparable#compareTo(java.lang.Object) | |
− | + | */ | |
− | + | @Override | |
− | + | public int compareTo(Table other) { | |
− | + | return getSum() - other.getSum(); | |
− | + | } | |
} | } | ||
− | </ | + | </source> |
}} | }} | ||
Line 116: | Line 116: | ||
{{CollapsedCode|Ficheiro '''Table.java'''| | {{CollapsedCode|Ficheiro '''Table.java'''| | ||
− | < | + | <source lang="java"> |
import java.util.Comparator; | import java.util.Comparator; | ||
/** | /** | ||
* A table holding a fixed number of integers. | * A table holding a fixed number of integers. | ||
− | * | + | * |
* It is possible to verify certain predicates against the table's contents. | * It is possible to verify certain predicates against the table's contents. | ||
*/ | */ | ||
public class Table implements Comparable<Table> { | public class Table implements Comparable<Table> { | ||
− | + | /** | |
− | + | * A comparator for tables: based on maximum value. | |
− | + | * | |
− | + | * Use as: Table.MAX_COMPARATOR | |
− | + | */ | |
− | + | public final static Comparator<Table> MAX_COMPARATOR = new MaxComparator(); | |
− | + | ||
− | + | /** | |
− | + | * A comparator for tables: based on length. | |
− | + | * | |
− | + | * Use as: Table.LENGTH_COMPARATOR | |
− | + | */ | |
− | + | public final static Comparator<Table> LENGTH_COMPARATOR = new LengthComparator(); | |
− | + | /** | |
− | + | * This is a private class implementing the comparator. | |
− | + | */ | |
− | + | private static class MaxComparator implements Comparator<Table> { | |
− | + | /** | |
− | + | * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) | |
− | + | */ | |
− | + | @Override | |
− | + | public int compare(Table table1, Table table2) { | |
− | + | return table1.getMax() - table2.getMax(); | |
− | + | } | |
− | + | ||
− | + | } | |
− | + | /** | |
− | + | * This is a private class implementing the comparator. | |
− | + | */ | |
− | + | private static class LengthComparator implements Comparator<Table> { | |
− | + | /** | |
− | + | * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) | |
− | + | */ | |
− | + | @Override | |
− | + | public int compare(Table table1, Table table2) { | |
− | + | return table1.getLength() - table2.getLength(); | |
− | + | } | |
− | + | ||
− | + | } | |
− | + | ||
− | + | /** | |
− | + | * Space for a fixed number of integers. | |
− | + | */ | |
− | + | int _vector[]; | |
− | + | /** | |
− | + | * @param nInts | |
− | + | * number of integers to store. | |
− | + | */ | |
− | + | public Table(int nInts) { | |
− | + | _vector = new int[nInts]; | |
− | + | } | |
− | + | /** | |
− | + | * FIXME: insert checks to ensure position is within range. | |
− | + | * | |
− | + | * @param position | |
− | + | * position to define | |
− | + | * @return value at position | |
− | + | */ | |
− | + | public int getValue(int position) { | |
− | + | return _vector[position]; | |
− | + | } | |
− | + | /** | |
− | + | * FIXME: insert checks to ensure position is within range. | |
− | + | * | |
− | + | * @param position | |
− | + | * position to define | |
− | + | * @param value | |
− | + | * value to set | |
− | + | */ | |
− | + | public void setValue(int position, int value) { | |
− | + | _vector[position] = value; | |
− | + | } | |
− | + | /** | |
− | + | * Set all positions to the same value. | |
− | + | * | |
− | + | * @param value | |
− | + | * value to set | |
− | + | */ | |
− | + | public void setAll(int value) { | |
− | + | for (int position = 0; position < _vector.length; position++) | |
− | + | _vector[position] = value; | |
− | + | } | |
− | + | /** | |
− | + | * @param predicate | |
− | + | * the predicate to validate. | |
− | + | * @return true, if the predicate is valid for at least one position; false, | |
− | + | * otherwise. | |
− | + | */ | |
− | + | public boolean contains(SelectionPredicate predicate) { | |
− | + | for (int position = 0; position < _vector.length; position++) | |
− | + | if (predicate.ok(_vector[position])) | |
− | + | return true; | |
− | + | return false; | |
− | + | } | |
− | + | /** | |
− | + | * This method makes it easy to get the sum of all elements. As with the | |
− | + | * predicate, this type of algorithm could also be provided from outside: | |
− | + | * instead of a selector, a collector would have to be provided. | |
− | + | * | |
− | + | * @return sum of all elements. | |
− | + | */ | |
− | + | public int getSum() { | |
− | + | int sum = 0; | |
− | + | for (int i : _vector) | |
− | + | sum += i; | |
− | + | return sum; | |
− | + | } | |
− | + | /** | |
− | + | * This method makes it easy to get the maximum of all elements. As with the | |
− | + | * predicate, this type of algorithm could also be provided from outside: | |
− | + | * instead of a selector, a collector would have to be provided. | |
− | + | * | |
− | + | * @return maximum value in the table. | |
− | + | */ | |
− | + | public int getMax() { | |
− | + | int max = _vector[0]; | |
− | + | for (int i : _vector) | |
− | + | if (i > max) | |
− | + | max = i; | |
− | + | return max; | |
− | + | } | |
− | + | /** | |
− | + | * This method makes it easy to get the number of elements. As with the | |
− | + | * predicate, this type of algorithm could also be provided from outside: | |
− | + | * instead of a selector, a collector would have to be provided. | |
− | + | * | |
− | + | * In this case, we are not actually iterating, since it is much easier and | |
− | + | * efficient to access the length attribute. | |
− | + | * | |
− | + | * @return length of table. | |
− | + | */ | |
− | + | public int getLength() { | |
− | + | return _vector.length; | |
− | + | } | |
− | + | /** | |
− | + | * @see java.lang.Comparable#compareTo(java.lang.Object) | |
− | + | */ | |
− | + | @Override | |
− | + | public int compareTo(Table other) { | |
− | + | return getSum() - other.getSum(); | |
− | + | } | |
− | + | ||
} | } | ||
− | </ | + | </source> |
}} | }} | ||
Line 292: | Line 292: | ||
{{CollapsedCode|Ficheiro '''Application.java'''| | {{CollapsedCode|Ficheiro '''Application.java'''| | ||
− | < | + | <source lang="java"> |
public class Application { | public class Application { | ||
− | + | /** | |
− | + | * @param args | |
− | + | */ | |
− | + | public static void main(String[] args) { | |
− | + | Table t1 = new Table(3); // table with 3 integers | |
− | + | Table t2 = new Table(3); // table with 3 integers | |
− | + | t1.setAll(3); | |
− | + | t2.setAll(90); | |
− | + | ||
− | + | System.out.println(t1.compareTo(t2)); // <0 | |
− | + | System.out.println(Table.MAX_COMPARATOR.compare(t1, t2)); // <0 | |
− | + | System.out.println(Table.MAX_COMPARATOR.compare(t1, t1)); // 0 | |
− | + | System.out.println(Table.MAX_COMPARATOR.compare(t2, t2)); // 0 | |
− | + | System.out.println(Table.MAX_COMPARATOR.compare(t2, t1)); // >0 | |
− | + | System.out.println(Table.LENGTH_COMPARATOR.compare(t1, t2)); // 0 (same length) | |
− | + | ||
− | + | } | |
} | } | ||
− | </ | + | </source> |
}} | }} | ||
Para este caso, é necessário definir a classe Table como implementando Comparable.
Ficheiro Table.java |
---|
/**
* A table holding a fixed number of integers.
*
* It is possible to verify certain predicates against the table's contents.
*/
public class Table implements Comparable<Table> {
/**
* Space for a fixed number of integers.
*/
int _vector[];
/**
* @param nInts
* number of integers to store.
*/
public Table(int nInts) {
_vector = new int[nInts];
}
/**
* FIXME: insert checks to ensure position is within range.
*
* @param position
* position to define
* @return value at position
*/
public int getValue(int position) {
return _vector[position];
}
/**
* FIXME: insert checks to ensure position is within range.
*
* @param position
* position to define
* @param value
* value to set
*/
public void setValue(int position, int value) {
_vector[position] = value;
}
/**
* Set all positions to the same value.
*
* @param value
* value to set
*/
public void setAll(int value) {
for (int position = 0; position < _vector.length; position++)
_vector[position] = value;
}
/**
* @param predicate
* the predicate to validate.
* @return true, if the predicate is valid for at least one position; false,
* otherwise.
*/
public boolean contains(SelectionPredicate predicate) {
for (int position = 0; position < _vector.length; position++)
if (predicate.ok(_vector[position]))
return true;
return false;
}
/**
* This method makes it easy to get the sum of all elements. As with the
* predicate, this type of algorithm could also be provided from outside:
* instead of a selector, a collector would have to be provided.
*
* @return sum of all elements.
*/
public int getSum() {
int sum = 0;
for (int i : _vector)
sum += i;
return sum;
}
/**
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo(Table other) {
return getSum() - other.getSum();
}
}
|
Diagrama de classes |
---|
(por lapso, o diagrama UML omite o método contains, mas o resto está correcto) |
Notar que as classes internas são static e que apenas estão contidas na classe Table por conveniência de ocultação de código.
Ficheiro Table.java |
---|
import java.util.Comparator;
/**
* A table holding a fixed number of integers.
*
* It is possible to verify certain predicates against the table's contents.
*/
public class Table implements Comparable<Table> {
/**
* A comparator for tables: based on maximum value.
*
* Use as: Table.MAX_COMPARATOR
*/
public final static Comparator<Table> MAX_COMPARATOR = new MaxComparator();
/**
* A comparator for tables: based on length.
*
* Use as: Table.LENGTH_COMPARATOR
*/
public final static Comparator<Table> LENGTH_COMPARATOR = new LengthComparator();
/**
* This is a private class implementing the comparator.
*/
private static class MaxComparator implements Comparator<Table> {
/**
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
@Override
public int compare(Table table1, Table table2) {
return table1.getMax() - table2.getMax();
}
}
/**
* This is a private class implementing the comparator.
*/
private static class LengthComparator implements Comparator<Table> {
/**
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
@Override
public int compare(Table table1, Table table2) {
return table1.getLength() - table2.getLength();
}
}
/**
* Space for a fixed number of integers.
*/
int _vector[];
/**
* @param nInts
* number of integers to store.
*/
public Table(int nInts) {
_vector = new int[nInts];
}
/**
* FIXME: insert checks to ensure position is within range.
*
* @param position
* position to define
* @return value at position
*/
public int getValue(int position) {
return _vector[position];
}
/**
* FIXME: insert checks to ensure position is within range.
*
* @param position
* position to define
* @param value
* value to set
*/
public void setValue(int position, int value) {
_vector[position] = value;
}
/**
* Set all positions to the same value.
*
* @param value
* value to set
*/
public void setAll(int value) {
for (int position = 0; position < _vector.length; position++)
_vector[position] = value;
}
/**
* @param predicate
* the predicate to validate.
* @return true, if the predicate is valid for at least one position; false,
* otherwise.
*/
public boolean contains(SelectionPredicate predicate) {
for (int position = 0; position < _vector.length; position++)
if (predicate.ok(_vector[position]))
return true;
return false;
}
/**
* This method makes it easy to get the sum of all elements. As with the
* predicate, this type of algorithm could also be provided from outside:
* instead of a selector, a collector would have to be provided.
*
* @return sum of all elements.
*/
public int getSum() {
int sum = 0;
for (int i : _vector)
sum += i;
return sum;
}
/**
* This method makes it easy to get the maximum of all elements. As with the
* predicate, this type of algorithm could also be provided from outside:
* instead of a selector, a collector would have to be provided.
*
* @return maximum value in the table.
*/
public int getMax() {
int max = _vector[0];
for (int i : _vector)
if (i > max)
max = i;
return max;
}
/**
* This method makes it easy to get the number of elements. As with the
* predicate, this type of algorithm could also be provided from outside:
* instead of a selector, a collector would have to be provided.
*
* In this case, we are not actually iterating, since it is much easier and
* efficient to access the length attribute.
*
* @return length of table.
*/
public int getLength() {
return _vector.length;
}
/**
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo(Table other) {
return getSum() - other.getSum();
}
}
|
(a publicar)
Ficheiro Application.java |
---|
public class Application {
/**
* @param args
*/
public static void main(String[] args) {
Table t1 = new Table(3); // table with 3 integers
Table t2 = new Table(3); // table with 3 integers
t1.setAll(3);
t2.setAll(90);
System.out.println(t1.compareTo(t2)); // <0
System.out.println(Table.MAX_COMPARATOR.compare(t1, t2)); // <0
System.out.println(Table.MAX_COMPARATOR.compare(t1, t1)); // 0
System.out.println(Table.MAX_COMPARATOR.compare(t2, t2)); // 0
System.out.println(Table.MAX_COMPARATOR.compare(t2, t1)); // >0
System.out.println(Table.LENGTH_COMPARATOR.compare(t1, t2)); // 0 (same length)
}
}
|