Pilha em Java

Pilha:

A forma mais geral de uma lista permite a inserção ou eliminação de um elemento em qualquer posição na lista. Se restringirmos a ocorrência de inserção e eliminação a uma extremidade da lista, por exemplo, extremidades superiores, então temos uma estrutura de dados chamada de pilha.

Utilizando a terminologia de pilhas, operações de inserção e eliminação são comumente citadas como operações “push” e “pop”, respectivamente. O único elemento diretamente acessível de uma pilha é seu elemento superior. O elemento menos acessível é seu elemento inferior.

Desde que as operações de inserção e eliminação são executadas na mesma extremidade da pilha (por exemplo, na extremidade superior), os elementos podem ser removidos somente na ordem oposta a que foram inseridos.

Este interessante fenômeno é conhecido como LIFO. LIFO é um acrônimo para a expressão inglesa Last In, First Out que, em português significa último a entrar, primeiro a sair.

Um exemplo comum de pilha, que permite a seleção de seu elemento superior, é a pilha de pratos num restaurante. Os pratos em pilha fazem com que a pessoa tenha acesso ao prato superior, à remoção de um prato superior faz com que a pessoa tenha acesso ao próximo prato, se colocado um novo prato na pilha, esse será o primeiro a sair.

Em Java, já existe a classe para o TAD pilha, que é a java.util.Stack.

Os métodos disponíveis nesta classe, entre outros, são: push(), pop(), equivalentes a empilha() e desempilha() e peek(), equivalente a topo(), tamanho() e vazia().

Os métodos pop() e peek() lançam a exceção StackEmptyException se a pilha estiver vazia quando eles são chamados.

• Outros métodos
  • size(): retorna o número de objetos da pilha
  • isEmpty(): retorna true se a pilha estiver vazia
  • top(): retorna, mas não remove, o objeto do topo da pilha, retornando um erro se a pilha estiver vazia

Exemplo simples:

Operação	Conteúdo da Pilha	Saida
Inserir X	X	-
Inserir Y	X Y	-
Inserir Z	X Y Z	-
Remover	X Y	Z
Inserir W	X Y W	-
Remover	X Y	W
Remover	X	Y
Remover		X
Remover		erro

Traduzindo a tabela em linguagem java.

import java.util.Stack;

/**

* Esta classe demonstra como funciona uma pilha em java

*

* @author Nico

*

* @since 20 MAIO, 2009

*

*/

public class TestarUmaStack {

public static void main(String[] args) {

// DECLARANDO NOSSOS ELEMENTOS/OBJETOS

String nico = “Nico”, kawano = “Kawano”, gaucho = “Gaucho”, erick = “Erick”, cris = “Cris”, junior = “Junior”, silvio = “Silvio”, jean = “Jean”;

// DECLARANDO A PILHA

Stack<String> nossaPilha = new Stack<String>();

// Passo 1: Incrementar Nico

nossaPilha.push(nico);

// Passo 2: Incrementar Kawano

nossaPilha.push(kawano);

// Passo 3: Incrementar Gaucho e Cris

nossaPilha.push(gaucho);

nossaPilha.push(cris);

// Passo 4: Decrementar elemento Cris do topo

nossaPilha.pop();

// Passo 5: Incrementar Erick

nossaPilha.push(erick);

// Passo 6: Incrementar Jean e Junior

nossaPilha.push(jean);

nossaPilha.push(junior);

// Passo 7: Substituir elemento na pilha. Jean por Silvio!

nossaPilha.set(4, silvio);

// EXIBINDO INFORMAÇÕES SOBRE A PILHA

if (nossaPilha.isEmpty()) {

System.out.println(“A PILHA ESTÁ VAZIA!”);

} else {

System.out

.println(“NOSSA PILHA DO GRUPO…\n\nElemento\tÍndice\n———————-”);

for (int i = nossaPilha.size() – 1; i > -1; i–) {

System.out.println(nossaPilha.get(i) + “\t\t” + i);

}

System.out.println(“\nNÚMERO DE ELEMENTOS: “ + nossaPilha.size());

System.out.println(“ELEMENTO NO TOPO: \”" + nossaPilha.peek()

+ “\” no índice “ + nossaPilha.indexOf(nossaPilha.peek()));

}

}

}

Resultado:

NOSSA PILHA DO GRUPO…

Elemento    Índice
———————-
Junior      5
Silvio       4
Erick        3
Gaucho   2
Kawano  1
Nico        0

NÚMERO DE ELEMENTOS:  6
ELEMENTO NO TOPO:  “Junior” no índice 5

Tratamento de exceções em Java

Hoje vou falar um pouquinho sobre o tratamento de exceções em Java, tambem do porque usar, sua estrutura e o que é uma exceção.

Como é comum no estudo do Java, ao chegar nesta parte e não conseguir visualizar a utilidade desse recurso e confundir os resultados com as instruções condicionais.

Conceito de Exceção

Exceção representa uma situação não esperada ocorrida na execução de algum trecho de programa.

Uma exceção deve ser vista como um retorno alternativo da execução de algum método.

O processo de gerar uma exceção é chamado de “lançamento de exceção” e o processo de processar uma exceção é chamado de “capturar a exceção”.

A exceção pode ser capturada por uma função dentro da seqüência de funções chamadas.

Agora veremos abaixo a estrutura de como tratar um erro ou exceção:

try - é usada para indicar um bloco de código que possa ocorrer uma exceção.

catch – serve para manipular as exceções, ou seja, tratar o erro

finally – sempre será executado depois do bloco try/catch. O importante é saber que esse bloco sempre será executado (exceto nos casos de encerramento da jvm System.exit()).

Veja abaixo as combinações válidas e inválidas para o uso do try{}, cacth{} e finally{} (isso é questão de certificação).

Combinações válidas:

try{}	catch{}
try{}	finally{}
try{}	catch{}	finally{}

Inválidas não Compila:

try{}	—	–
catch{}	finally{}	—
try{}	finally{}	catch{}

Tipos de Exceções em Java

Existem três tipos básicos de exceção em Java

Error

São exceções lançadas internamente pela Máquina Virtual na ocorrência de algum tipo de erro interno ou de falta de algum recurso.

Não se deve lançar nem tratar exceções desse tipo.

RuntimeException

São exceções lançadas devido algum erro do programa, como por exemplo, cast inválido, índice fora dos limites, acesso a referência nula de alguma classe.

Outras Exceções

São as exceções criadas para representar diversas situações. Podem ser as exceções criadas pelas bibliotecas ou exceções criadas pelo usuário.

Documentando as Exceções

A linguagem Java irá obrigar o programador a definir uma lista de exceções no cabeçalho do método quando ocorrer algumas das seguintes situações.

O método chama algum outro método que também possui em seu cabeçalho a indicação de lançamento de exceção e não faz o tratamento dessa exceção. O método lança uma exceção e não trata a mesma.

Sintaxe:

tipo_de_retorno nome ([params]) throws NomeExceção { ….. }

Capturando uma Exceção

Para capturar uma exceção devemos colocar o código passível de lançamento de exceção dentro de um bloco try. Para capturar a exceção devemos usar o catch.

Sintaxe:

try {

…. –> Código que pode lançar uma exceção

}

catch (tipo_exc e){

…. –> Código de tratamento

}

Lançando uma Exceção

Para lançar uma exceção deve-se usar o comando throw seguido de uma referência de uma classe de exceção.

Essa referência deve ter uma instância da classe de exceção a ser lançada.

Sintaxe:

retorno_do_método nome ([params]) throws

NomeExceção {

…..

if (cond_erro)

throw new IOException ();

….

}

Criando uma Classe de Exceção

Para criar uma nova classe de exceção de aplicação deve-se:

• Criar a classe herdando de alguma outra exceção existente ou da classe Exception.
• Criar um construtor sem parâmetros e um com um parâmetro do tipo String.
• No construtor do tipo String chamar o construtor da classe base, usando super, passando a string recebida.
• Podem-se colocar atributos e métodos adicionais na classe para definição melhor da exceção.

Métodos da Classe Throwable

A classe Throwable, classe base de todas as exceções do Java, possui os seguintes métodos:

• String getMessage( );

Retorna a descrição usada na criação da exceção.

• String toString( );

Retorna a descrição curta da exceção (nome/msg).

• void printStackTrace( );

Mostra todas as informações da pilha no momento da exceção.

• Throwable fillInStackTrace( );

Recoloca as informações na pilha da exceção.

Relançando uma Exceção

Uma vez capturada uma exceção, ela termina a função de indicar algum erro. Caso seja necessário que o tratamento continue em níveis superiores deve-se relançar a mesma através do comando throw colocado dentro do bloco catch.

O relançamento de uma exceção difere do lançamento no sentido de que não é criada uma nova instância e sim lançada a mesma instância da exceção capturada.

Sintaxe:

catch (tipo_exc e){

…. –> Código de tratamento

throw e; –> Relançando

}

Bloco finally

O bloco finally serve para indicar o código que será sempre executado em uma estrutura try…catch independente do caminho realizado por uma execução, normal ou exceção.

O bloco deve ser colocado após os blocos catch.

Pode-se colocar uma estrutura try com um bloco finnaly somente, sem o bloco catch.

Sintaxe:

finally {

…. –> Código a ser executado sempre

}

Exceções predefinidas do JAVA

Dentro do pacote-padrão java.lang Java define várias classes de exceção.  A maioria destas exceções são subclasses do tipo padrão RuntimeException. Desde que java.lang é implicitamente importada para todos os programas Java, a maioria das exceções derivadas de RuntimeException estão automaticamente disponíveis.

Então quando Usar Exceções !

Algumas sugestões sobre o uso de exceções:

• Não utilize exceções no lugar de testes simples. O tratamento de uma exceção custa muito em termos de processamento.
• Não faça o gerenciamento detalhado de exceção colocando cada comando que pode lançar uma exceção dentro de um bloco try/catch.
• Não descarte uma exceção, ou seja, não coloque um bloco catch vazio somente para evitar o erro de compilação.
• Não sinta constrangimento em não tratar todas as exceções que o seu código lançou. Trate somente as exceções cujo contorno você conhece.

Inside Microsoft’s ‘Future Home’

Microsoft Home, como é chamado, é um novo conceito para as casas no futuro, onde consegue juntar uma visão realista das nossas casas, em um horizonte de 5 a 10 anos no futuro, um cronograma bastante curto, suficiente para essa nova tecnologia chegar rapidamente em nossos lares.

[vídeo] – BBC

Como é o desempenho do seu Browser?

Peacekeeper é um serviço online que funciona através de qualquer navegador (exceto portáteis), o qual executa uma bateria de testes diversos para calcular o desempenho aproximado do navegador. Segundo a Futuremark (desenvolvedora do serviço e de programas como o 3D Mark), qualquer máquina que suporte o navegador em teste é perfeitamente capaz de executar o teste. Que tal efetuar os testes no seu PC e verificar qual navegador é mais rápido?

[link]

Orientação a Objetos – Parte 3

CONCEITO DE ENCAPSULAMENTO

• Encapsulamento é o mecanismo pelo qual podemos unir numa mesma estrutura de dados, dados e métodos.
• Por meio do encapsulamento pode-se ocultar os dados.
• O princípio do encapsulamento: “Princípio do Menor Privilégio” – disponibilize ao usuário somente aquilo que for necessário, o resto esconda.

CONCEITO DE HERANÇA

• Herança é o processo de definição de uma classe baseada em outra classe.
• Terminologia
  • Classe Base               Classe Derivada
  • Classe Mãe/Pai          Classe Filha
  • Super-classe              Sub-classe
  • Generalização            Especialização
• A classe derivada herda e incorpora todos os atributos e métodos da classe base.
• Podemos adicionar ou redefinir algum método ou adicionar atributos na classe derivada a fim de adaptar a definição à nova classe.

CONCEITO DE POLIMORFISMO

• O polimorfismo é caracterizado pela frase: “Uma interface, vários métodos”
• Caso se faça a sobreposição de métodos (com a mesma assinatura) em uma herança, será possível se aplicar o conceito de Polimorfismo.
• Tendo-se uma variável do tipo da classe mãe, pode-se criar uma instância para qualquer classe filha descendente da mesma e armazenar sua referência na variável.
• Como o método está definido na classe mãe e sobrecarregado na classe filha, o compilador irá escolher o método baseado no tipo da instância apontada pela referência e não pelo tipo da mesma.
• Permite uma interface ser usada para representar uma classe geral de ações.