wpjr2’s Weblog

Artigos e tutoriais úteis

Archive for 20 de abril de 2008

Multithreading em Java

Posted by wpjr2 em abril 20, 2008

A classe Thread representa um fluxo de controle ou execução de um programa. A Máquina Virtual Java permite que uma aplicação tenha múltiplos processos concorrentes em execução. Threads são também
considerados como processos “leves” de execução. As threads são criadas e existem dentro de um processo, onde cada um deste deve possuir pelo menos uma thread. As threads dento de um mesmo processo  compartilham recursos do processo, incluindo memória e arquivos abertos.

Cada processo ou thread possui uma prioridade associada, onde processos com prioridade mais alta são executados em preferência de processos com prioridade mais baixa pela máquina virtual Java. Quando
uma nova thread é criada, esta possui uma prioridade igual à thread que a criou. Threads do tipo Daemon são threads especiais onde estas provêem serviço para outras threads.

Em Java, existem duas maneiras de se criar objetos executáveis do tipo Thread:

  1. Criando uma subclasse (extensão) da classe Thread
  2. Criando uma classe que implemente a interface Runnable

Extendendo Thread

O primeiro destes implica na criação da uma classe que seja subclasse de Thread. Esta classe deve sobrescrever o método run() da superclasse Thread. Uma instância desta classe pode ser instanciada e
iniciada. Por exemplo, uma thread que calcula primos maiores do que um valor mencionado pode ser implementada da seguinte forma:

class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}

public void run() {
// compute primes larger than minPrime
. . .
}
}

O seguinte código abaixo pode ser usado para criar um objeto do tipo Thread e iniciar sua execução:

PrimeThread p = new PrimeThread(143);
p.start();

Implementando Runnable
A outra maneira de se criar uma thread é declarando uma classe que implemente a interface Runnable. Esta classe então implementaria o método run(). Uma instância desta classe poderia ser alocada, passada
como argumento na criação de uma nova Thread e iniciada. O mesmo exemplo acima implementado desta maneira estaria da seguinte forma:

class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}

public void run() {
// compute primes larger than minPrime
. . .
}
}

O seguinte código cria então uma nova thread e a inicia:
PrimeRun p = new PrimeRun(143);
new Thread(p).start();

Anúncios

Posted in Curso de Programação Java | Etiquetado: , , | Leave a Comment »

Polimorfismo na música

Posted by wpjr2 em abril 20, 2008

Na programação orientada a objetos, o polimorfismo permite que referências de tipos de classes mais abstratas representem o comportamento das classes concretas que referenciam. Assim, um mesmo método pode apresentar várias formas, de acordo com seu contexto. O polimorfismo é importante pois permite que a semântica de uma interface seja efetivamente separada da implementação que a representa. O termo polimorfismo é originário do grego e significa “muitas formas” (poli = muitas, morphos = formas).

No exemplo abaixo, operações foram definidas para as classes que extendem a classe Músico. De todas as operações, algumas poderão ser chamadas a partir de todas as classes, mas algumas destas não poderão ser chamadas.

class Musico{
public void afinarInstrumento(){
System.out.println(“Músico”);
}
}

class Tecladista extends Musico{
public void afinarInstrumento(){
System.out.println(“Tecladista”);
}
public void pressionarTecla(){
System.out.println(“Tecla pressionada”);
}
}

class Pianista extends Tecladista{
public void afinarInstrumento(){
System.out.println(“Pianista”);
}
public void fecharPiano(){
System.out.println(“Piano fechado”);
}
}

public class Ensaio{
public static void main(
String [] args){

Pianista p = new Pianista();
Teladista t = p;
Musico m = p;
p.afinarInstrumento(); // o pianista pode afinar o instrumento, OK
t.afinarInstrumento(); // o tecladista pode afinar o instrumento, OK
m.afinarInstrumento(); // o musico pode afinar o instrumento, OK
p.pressionarTecla(); // o pianista pode pressionar a tecla, OK
t.pressionarTecla(); // o tecladista pode pressionar a tecla, OK
m.pressionarTecla(); // o músico NÃO pode pressionar a tecla, ERRO
p.fecharPiano(); // o pianista pode fechar o piano, OK
t.fecharPiano(); // o tecladista NÃO pode fechar o piano, ERRO
m.fecharPiano(); // o músico NÃO pode fechar o piano, ERRO
}
}

Posted in Curso de Programação Java | Etiquetado: , | Leave a Comment »

Herança Múltipla: Anfíbios, animais terrestres e marinhos

Posted by wpjr2 em abril 20, 2008

A herança mútlipla de classes Java não é permitida pela linguagem. A alternativa para contornar esta limitação inclui a utilização de interfaces para representar cada tipo a ser representado pela classe. No exemplo abaixo, a classe Anfibio deve possuir características de animal terrestre e de animal marinho. Porém em cada uma dos ambientes definidos pela interface (terra e mar), o anfíbio se comportará somente com as características definidas para este ambiente.

As Interfaces AnimalMarinho e AnimalTerrestre

// define as operações de um animal marinho

interface AnimalMarinho{
void nadar();
}

// define as operações de um animal terrestre

interface AnimalTerrestre{
void andar();
}

A Classe Anfíbio
class Amfibio implements AnimalMarinho, AnimalTerrestre{
void andar(){…}
void nadar(){…}
}

Criando um Anfíbio

Anfibio a = new Anfibio();
a.nadar(); // o anfíbio sabe nadar
a.andar(); // o anfíbio sabe andar

Convertendo um anfíbio em um animal marinho

AnimalMarinho am = a;
am.andar(); // o animal marinho nâo sabe andar, ERRO
am.nadar(); // o animal mainho sabe nadar, OK

De acordo com a definição da interface AnimalMarinho, é somente possível nadar, não podendo por exemplo andar sobre a água. Desta forma, o animal marinho não possui a operação andar.

Convertendo um anfíbio em animal terrestre

AnimalTerrestre at = a;
at.andar(); // o animal terrestre sabe andar, OK
at.nadar(); // o animal terrestre não sabe nadar, ERRO

De acordo com a definição da interface AnimalTerrestre, é somente possível nadar, não podendo por exemplo andar sobre a água. Desta forma, o animal marinho não possui a operação andar.

Posted in Curso de Programação Java | Etiquetado: , , | Leave a Comment »

Sobrecarga vs. Sobrescrita

Posted by wpjr2 em abril 20, 2008

O objetivo deste artigo é apresentar as características da cobrecarga e sobrescrita na orientação por objetos em Java. Pelo fatos destes serem alguns dos tipos de polimorfismo existentes na linguagem, eles podem ser falcilmente confundidos e até trocados entre si.

Sobrecarga: criação de várias funções ou métodos com o mesmo nome, porém com parâmetros e tipos de retorno diferentes. A escolha de quais métodos serão usados pela aplicação é definido em tempo de compilação (dynamic/late binding), através dos parâmetros passados e do tipo de retorno esperado pela
classe cliente.

Ex:System.out.println()

Sobrescrita: recurso da linguagem onde uma impleemntação específica é provida pela subclasse de algum método já provido pela superclasse. A implementação da subclasse substitui a implementação da classe pai.
Métodos sobrescritos DEVEM possuir a mesma assinatura (tipo de retorno, nome do método, tipos e quantidade de parâmetros).

Ex:Métodos equals() e toString() que são sobrescritos nas classes filhas.

A covariância, um recurso acrescentado na linguagem a partir da versão 1.5, permite flexibilizar o tipo de retorno do método, retornando por exemplo uma subclasse do tipo de retorno definido na superclasse. Por
exemplo, em um método espera-se retornar um objeto Cão, mas na sobrescrita (subclasse) é possível retornar um objeto do tipo Dálmata.

Todos os métodos de classes em Java são automaticamente virtuais, significando que estes podem ser sobrescritos pelas subclasses desta classe. Para que um método não possa ser sobrescrito, o modificador
“final” deve ser usado no método.

Resumo:
– Sobrecarga: métodos com o mesmo nome, diferentes parãmetros e tipos
de retorno, provendo a mesma operação de formas diferentes
– Sobrescrita: métodos com o mesmo nome, parãmetros e tipos de
retorno, alterando o comportamento do método da classe pai.

Posted in Curso de Programação Java | Etiquetado: , , | Leave a Comment »