Tente Isto 13-1 - Crie uma fila genérica

Arquivos:
IGenQ.java
QueueFullException.java
QueueEmptyException.java
GenQueue.java
GenQDemo.java

Os genéricos permitem criar código confiável e reutilizável, simplificando o desenvolvimento de algoritmos genéricos que podem ser aplicados a diferentes tipos de dados. Por exemplo, uma classe de fila genérica pode ser usada com inteiros, strings ou objetos sem a necessidade de criar versões separadas para cada tipo.

Vantagens dos Genéricos:
Reutilização: Um único código genérico pode atender a diferentes tipos de dados.
Redução do Ciclo de Desenvolvimento: O projeto, codificação, teste e depuração são realizados apenas uma vez.
Flexibilidade: Adaptação para diferentes implementações de filas (tamanho fixo, dinâmica, circular, etc.).

Projeto Genérico: Neste exemplo, uma classe de fila genérica é implementada:

1 Estrutura Modular:
Interface genérica define as operações da fila.
Exceções específicas para erros da fila.
Implementação de fila genérica de tamanho fixo.

2 Organização Realista: O projeto é dividido em arquivos separados, simulando práticas do mundo real.

Esse projeto demonstra como transformar uma solução previamente específica em uma solução genérica flexível e escalável.

1 A primeira etapa da criação de uma fila genérica é criar uma interface genérica que descreva as duas operações da fila: inserção e retirada. A versão genérica da interface de fila se chama IGenQ e é mostrada abaixo. Insira essa interface em um arquivo chamado IGenQ.java.

// Interface de fila genérica.
public interface IGenQ<T> {
// Insere um item na fila.
void put(T ch) throws QueueFullException;
// Retira um item da fila.
T get() throws QueueEmptyException;
}

2 Em seguida, crie os arquivos QueueFullException.java e QueueEmptyExcep
tion.java. Insira em cada arquivo a classe correspondente:

// Exceção para erros de fila cheia.
public class QueueFullException extends Exception {
int size;
QueueFullException(int s) { size = s; }
public String toString() {
return "\nQueue is full. Maximum size is " +
size;
}
}
// Exceção para erros de fila vazia.
public class QueueEmptyException extends Exception {
public String toString() {
return "\nQueue is empty.";
}
}

Essas classes encapsulam os dois erros da fila: quando ela está cheia ou vazia. Não são classes genéricas, porque são iguais, não importando o tipo de dado armazenado em uma fila. Logo, as duas filas serão como as que você usou na seção Tente Isto 9-1.

3 Crie um arquivo chamado GenQueue.java:
// Classe genérica de uma fila de tamanho fixo.
class GenQueue<T> implements IGenQ<T> {
private T q[]; // esse array contém a fila
private int putloc, getloc; // índices de inserção e retirada
// Constrói uma fila vazia com o array dado.
public GenQueue(T[] aRef) {
q = aRef;
putloc = getloc = 0;
}
// Insere um item na fila.
public void put(T obj)
throws QueueFullException {
if(putloc==q.length)
throw new QueueFullException(q.length);
q[putloc++] = obj;
}
// Retira um item da fila.
public T get()
throws QueueEmptyException {
if(getloc == putloc)
throw new QueueEmptyException();
return q[getloc++];
}
}

A classe GenQueue é uma fila genérica que usa o parâmetro de tipo T para determinar o tipo de dado armazenado. O tipo T também é passado para a interface IGenQ, garantindo a consistência no tipo de dados.
Construtor: Recebe uma referência a um array que será usado para armazenar os elementos da fila.
Uso: Antes de criar um objeto GenQueue, é necessário:
Declarar um array do tipo compatível com os objetos a serem armazenados.
Passar o array como argumento ao construtor de GenQueue.

Para criar uma fila de strings:
String strArray[] = new String[10];
GenQueue<String> strQ = new GenQueue<String>(strArray);

4 Crie um arquivo chamado GenQDemo.java

//Tente Isto 13-1
//Demonstra uma classe genérica de fila.
class GenQDemo {
public static void main(String args[]) {
// Cria uma fila de inteiros.
Integer iStore[] = new Integer[10];
GenQueue<Integer> q = new GenQueue<Integer>(iStore);
Integer iVal;
System.out.println("Demonstrate a queue of Integers.");
try {
for(int i=0; i < 5; i++) {
System.out.println("Adding " + i + " to q.");
q.put(i); // adiciona o valor inteiro à q Código
}
}
catch (QueueFullException exc) {
System.out.println(exc);
}
System.out.println();
try {
for(int i=0; i < 5; i++) {
System.out.print("Getting next Integer from q: ");
iVal = q.get();
System.out.println(iVal);
}
}
catch (QueueEmptyException exc) {
System.out.println(exc);
}
System.out.println();
// Cria uma fila Double.
Double dStore[] = new Double[10];
GenQueue<Double> q2 = new GenQueue<Double>(dStore);
Double dVal;
System.out.println("Demonstrate a queue of Doubles.");
try {
for(int i=0; i < 5; i++) {
System.out.println("Adding " + (double)i/2 +
" to q2.");
q2.put((double)i/2); // adiciona o valor double à q2
}
}
catch (QueueFullException exc) {
System.out.println(exc);
}
System.out.println();
try {
for(int i=0; i < 5; i++) {
System.out.print("Getting next Double from q2: ");
dVal = q2.get();
System.out.println(dVal);
}
}
catch (QueueEmptyException exc) {
System.out.println(exc);
}
}
}