trabalho de linguagem ll trabalho

Prévia do material em texto

Campus Santa Cruz
TRABALHO DE 
LINGUAGEM DE PROGRAMAÇÃO II
Alunos: Gustavo Eliezer da Silva Cabral 201301164101
 Carlos Henrique Alves Martins 201301163961 
Objetivo
Obter diferentes formas de escrever um programa em Java e suas aplicações
Introdução
O que é a Tecnologia Java e porque preciso dela?
Java é uma linguagem de programação e plataforma computacional lançada pela primeira vez pela Sun Microsystems em 1995. Existem muitas aplicações e sites que não funcionarão, a menos que você tenha o Java instalado, e mais desses são criados todos os dias. O Java é rápido, seguro e confiável. De laptops a datacenters, consoles de games a supercomputadores científicos, telefones celulares à Internet, o Java está em todos os lugares!
À medida que os problemas computacionais vão se tornando maiores e mais complexos, sempre é possível simplificar a solução dividindo o programa em partes menores, chamadas de módulos (em Java, métodos). Um módulo pode ser definido como um conjunto de instruções da linguagem que realizam alguma tarefa, constituindo um procedimento algorítmico, com uma função bem definida e o mais independente possível em relação ao restante do programa. A sistemática de dividir os programas em módulos surgiu no final da década de 1960. O principal objetivo da modularização é permitir gerenciar a complexidade no desenvolvimento de programas de grande porte. Com a subdivisão de programas complexos em módulos, algumas vantagens são conquistadas como a legibilidade (trechos de código mais simples), a manutenibilidade (favorece a detecção e correção de erros) e a produtividade (facilita a reutilização de software).
A Plataforma
O universo Java é um vasto conjunto de tecnologias, composto por três plataformas principais que foram criadas para segmentos específicos de aplicações:
Java SE (Java Platform, Standard Edition). É a base da plataforma. Inclui o ambiente de execução e as bibliotecas comuns.
Java EE (Java Platform, Enterprise Edition). A edição voltada para o desenvolvimento de aplicações corporativas e para internet.
Java ME (Java Platform, Micro Edition). A edição para o desenvolvimento de aplicações para dispositivos móveis eembarcados.
Além disso, pode-se destacar outras duas plataformas Java mais específicas:
Java Card. Voltada para dispositivos embarcados com limitações de processamento e armazenamento, como smart cards e o Java Ring.
JavaFX. Plataforma para desenvolvimento de aplicações multimídia em desktop/web (JavaFX Script) e dispositivos móveis (JavaFX Mobile).
Ambiente de Execução Java
Um programa escrito para a plataforma Java necessita de dois componentes para ser executado: a máquina virtual Java, e um conjunto de bibliotecas de classe que disponibilizam um série de serviços para esse programa. O pacote de softwareque contém a máquina virtual e esta biblioteca de classes é conhecido como JRE (Java Runtime Environment).
Java Virtual Machine
O coração da plataforma Java não é o conceito de um processador "virtual", que executa os programas formados porbytecodes Java. Este bytecode é o mesmo independentemente do hardware ou sistema operacional do sistema em que o programa será executado. A plataforma Java disponibiliza um interpretador, a JVM, que traduz, em tempo de execução, obytecode para instruções nativas do processador. Isto permite que uma mesma aplicação seja executada em qualquer plataforma computacional que possua uma implementação da máquina virtual.
Desde a versão 1.2 da JRE, a implementação da Sun da JVM inclui um compilador just-in-time (JIT). Com este compilador todo o bytecode de um programa é transformado em instruções nativas e carregado na máquina virtual em uma só operação, permitindo um ganho de desempenho muito grande em comparação com a implementação anterior, onde as instruções em bytecode eram interpretadas uma por vez. O compilador JIT pode ser projetado de acordo com a plataforma ou hardware de destino, e o código que ele gera pode ser otimizado com base na observação de padrões de comportamento dos programas.
Desde a primeira versão, este ambiente de execução vem equipado com gestão automática de memória, realizada por um algoritmo colector de lixo garbage collector, que liberta o programador das tarefas de alocação e libertação de memória, fonte de muitos erros de programação.
A plataforma Java não é a primeira plataforma baseada em uma máquina virtual, mas é de longe a mais conhecida e a que alcançou maior sucesso. Anteriormente esta tecnologia era utilizada na criação de emuladores para auxílio ao projeto de hardware ou de sistemas operacionais. A plataforma Java foi desenhada para ser implementada inteiramente em software, enquanto permitindo a sua migração de maneira fácil para plataformas de hardware de todos os tipos.
Linguagens
A palavra Java usualmente é uma referência a linguagem de programação Java, que é a primeira linguagem criada antes do português e do ingles pela Sun Microsystems para a JVM. A segunda linguagem criada pela Sun Microsystems para a JVM é chamada de Groovy, uma linguagem mais dinâmica, inspirada em linguagens como Python, Ruby eSmalltalk. Também existem implementações para a linguagem Python, a Jython, e para a linguagem Ruby, a JRuby.
Plataformas similares
O sucesso da plataforma Java e o seu conceito write once, run anywhere levaram a outros esforços similares. O mais notável destes esforços é a plataforma .NET, da Microsoft, que utilizou muitos dos conceitos e inovações da plataforma Java sem, contudo, implementar os recursos de portabilidade entre sistemas operacionais e plataformas que a plataforma Java possui.
Em que situação o tema é útil:
À medida que os problemas vão se tornando maiores e mais complexos, sempre é possível simplificar dividindo a solução em partes menores, chamadas de subprogramas (em Java, métodos). Cada parte menor do problema tem uma implementação mais simples, favorecendo a legibilidade e a manutenibilidade do subprograma.
Com o avanço da tecnologia e o aumento na capacidade dos computadores, problemas mais complexos passaram a ser resolvidos pela máquina, provocando uma crise no processo de desenvolvimento de programas (software) que não apresentou uma evolução comparável.
A “crise do software” foi o termo utilizado, já no final dos anos 60, para expressar as dificuldades frente ao rápido crescimento da demanda por software, da complexidade dos problemas a serem resolvidos e da inexistência de técnicas estabelecidas para o desenvolvimento de sistemas. Uma das primeiras e mais conhecidas referências ao termo foi feita por Edsger W. Dijkstra, em 1972, no Prêmio Turing da Association for Computing Machinery, no manuscrito intitulado “The Humble Programmer”.
Infelizmente os problemas encontrados nas etapas do processo de desenvolvimento de software continuam atormentando a vida dos projetistas até hoje. A crise se manifesta de várias formas, como a baixa produtividade dos programadores (projetos ultrapassando os prazos e orçamentos), a falta de uma metodologia formal para o desenvolvimento de software e os códigos de baixa qualidade (programas literalmente sem a possibilidade de serem mantidos).
Com base nisso, neste primeiro artigo sobre programação modular em Java, será estudado como organizar a solução de problemas computacionais em pedaços, enfatizando como declarar e utilizar módulos para facilitar o projeto, implementação e manutenção de grandes programas.
Elementos chaves da programação estruturada
A programação estruturada é uma forma de programação de computadores que estabelece uma disciplina no desenvolvimento de algoritmos, independentemente da complexidade do problema e da linguagem de programação na qual a solução será codificada. Essa disciplina orienta os programadores na criação de estruturas simples em seus programas, usando um número restrito de mecanismos de codificação com especialdestaque para a subprogramação (ou modularização).
À medida que os problemas vão se tornando maiores e mais complexos, sempre é possível simplificar a solução dividindo o programa em partes menores, chamadas subprogramas. Um subprograma é o nome dado a um trecho de um programa mais complexo e que, em geral, encerra em si próprio um pedaço da solução de um problema maior (o programa a que ele está subordinado). Procedimento, função, módulo (estrutura modular), e métodos (orientação a objetos), são sinônimos usados na Engenharia de Software para o conceito de subprograma.
Na programação estruturada, o “método dos refinamentos sucessivos” é uma “sistemática” de abordagem útil no projeto e na implementação de softwares. Partindo-se de um dado problema, para o qual se deseja encontrar um programa de solução, deve-se procurar subdividi-lo em problemas menores e consequentemente de solução mais simples (dividir para conquistar). Alguns destes problemas menores (subproblemas) terão solução imediata (na forma de um subprograma ou método) e outros não. Os subproblemas para os quais não for possível encontrar uma solução direta devem ser novamente subdivididos. Assim, o processo é repetido até que se consiga encontrar um subprograma para solucionar cada um dos subproblemas definidos. Então, o programa de solução do problema original será composto pela justaposição dos subprogramas usados para solucionar cada um dos subproblemas em que o problema original foi decomposto.
Com a subdivisão de programas complexos, algumas vantagens são conquistadas:
a) cada parte menor tem um código mais simples; 
b) facilita o entendimento uma vez que os subprogramas podem ser analisados como partes independentes (legibilidade); 
c) códigos menores são mais facilmente modificáveis para satisfazer novos requisitos do usuário e para correção de erros (manutenibilidade); 
d) simplificação da documentação de sistemas;
e) desenvolvimento de software por equipes de programadores; e,
f) reutilização de software através de bibliotecas de subprogramas (produtividade) – na linguagem C, sob a forma dos arquivos de cabeçalhos (.h) e na linguagem Pascal, através das unidades de código (unit).
A reutilização de software pode ser apoiada pela construção de bibliotecas com conjuntos de subprogramas destinados a solucionar tarefas bastante corriqueiras, como, por exemplo, validação de CPF e CNPJ, operações com data, cálculos matemáticos como médias e percentuais, entre outras. No desenvolvimento de novos sistemas, deve-se basear sua concepção ao máximo nos subprogramas disponíveis nas bibliotecas, de modo que a quantidade de código realmente novo a ser desenvolvido seja minimizada. A reutilização de subprogramas busca aumentar a qualidade e a produtividade no desenvolvimento de software, objetivando a economia de tempo e trabalho, benefícios técnicos que trazem vantagens financeiras.
Programando em Java
No desenvolvimento de software o enfoque estruturado sugere a construção de sistemas de informação baseada na compreensão desses sistemas como um conjunto de subprogramas que, por sua vez, executam processos sobre os dados. Já o enfoque orientado a objetos consiste na observação do mundo real como uma coletânea de objetos que interagem entre si, com características próprias, representadas por seus atributos (dados) e operações (processos).
Java é uma linguagem de programação orientada a objetos em que o principal bloco de construção de todos os sistemas de software é a classe. Sob essa perspectiva, os dados e os processos fazem parte, ou são encapsulados, nesse elemento básico de programação.
A sintaxe (forma de escrever uma sentença corretamente) Java usada na definição de uma classe está dividida em quatro partes, identificadas na Figura 1, que são:
1) modificador; 
2) palavra-chave class; 
3) nome da classe; e, 
4) corpo da classe. 
O modificador (opcional) especifica a acessibilidade da classe; se presente, pode ser uma combinação de public e abstract ou final. Neste momento, é necessário entender que uma classe declarada com um modificador de acesso public, indica que todo o conteúdo (atributos e métodos) público da classe pode ser utilizado livremente (sem restrições). A palavra-chave class define que trata-se da declaração de uma classe Java. O nome da classe é o identificador da classe e deve ser um identificador válido para a linguagem. No corpo da classe residem as declarações de todos os atributos e métodos delimitados por chaves de abertura ({) e fechamento (}).
Figura 1. Sintaxe Java na definição de classes.
Módulos de programa em Java
Segundo DEITEL (2005, pág. 165), há três tipos de módulos em Java: métodos, classes e pacotes. Os métodos, denominados funções ou procedimentos nas linguagens de programação estruturada, são serviços implementados na forma de um conjunto de instruções da linguagem (procedimentos algorítmicos) que realizam alguma tarefa específica e podem, como resultado, retornar um valor. Uma boa prática de programação é manter a funcionalidade de um método simples, desempenhando uma única tarefa.
A sintaxe Java usada na definição de um método está dividida em cinco partes, identificadas na Figura 2, que são: 
1) modificador; 
2) tipo do valor de retorno; 
3) nome do método; 
4) lista de parâmetros; e, 
5) corpo do método. 
O modificador (opcional) especifica a acessibilidade do método; se presente, pode ser uma combinação dos modificadores de acesso: public, protected ou private; abstract ou final; e, static. O tipo do retorno é um indicador para o valor de retorno. Deve-se usar a palavra reservada void quando o método não possuir um valor de retorno (procedimento). O nome do método é o identificador usado para referenciá-lo em uma sentença de chamada de método. Os parâmetros (opcional) são representados por uma lista de parâmetros, separados por vírgulas, onde cada parâmetro obedece à forma tipo nome, tal como na declaração de variáveis. Os parâmetros são utilizados para receber os valores (argumentos) fornecidos ao método pela respectiva chamada. No corpo do método deverá ser implementado o trecho de código Java que realiza a tarefa, delimitada por chaves de abertura ({) e fechamento (}).
Figura 2. Sintaxe Java na definição de métodos.
Para DEITEL (2005), a experiência mostra que a melhor maneira de desenvolver e manter um programa grande é construí-lo em partes pequenas e simples, chamadas de métodos. Um programa maior dividido em módulos, chamado de “programa modular”, pode apresentar quantos módulos forem necessários ou convenientes, dos quais o método main(), principal em inglês, representa o “ponto inicial” da execução.
Quando o Java encontra uma chamada de método em uma aplicação Java modular, por exemplo, na chamada do método soma() implementada através da instrução:
System.out.printf("5 + 3 = %d\n", soma(5, 3));
Imediatamente o fluxo de execução é transferido para o método chamado, iniciando a execução a partir do primeiro comando implementado no corpo desse método. Quando o último comando do corpo do método ou o comando return for executado, o Java transfere desta vez a execução para o comando que segue imediatamente a chamada do método.
A Figura 3 apresenta uma “classe Java principal”, nome dado a uma classe Java que possui o método main(), com três métodos: 
1) main() – módulo principal da aplicação, que corresponde ao ponto inicial da execução do código da classe (módulo chamador); 
2) soma () – módulo chamado para calcular e retornar a soma de dois números inteiros; e, 
3) sub() – módulo chamado para calcular e retornar a subtração de dois números inteiros.
Figura 3. Organização deuma classe Java dividida em métodos.
De acordo com DEITEL (2005), os métodos permitem que o programador modularize um programa separando suas tarefas em unidades autocontidas. A Listagem 1 apresenta uma classe Java principal dividida em três métodos: 
1) main() – módulo principal da aplicação, que corresponde ao ponto inicial da execuçãodo código da classe (módulo chamador); 
2) tabuada() – módulo chamado para executar a tabuada de um número; e, 
3) direitos() – módulo chamado para mostrar os direitos autorais da aplicação.
Listagem 1. Aplicação Java dividida em métodos.
public class Exemplo1 {
 public static void main(String[] args) {
 tabuada(7);
 tabuada(8);
 direitos();
 }
 public static void tabuada(int n) {
 int i;
 System.out.printf("+--Resultado--+\n");
 for (i=1; i<=10; i++) {
 System.out.printf("| %2d * %d = %2d 
 |\n", i, n, (i*n));
 }
 System.out.printf("+-------------+\n\n");
 }
 public static void direitos() {
 System.out.printf("Copyright (C) 
 Prof. Omero Francisco Bertol.\n");
 }
}
No método main() da aplicação Java apresentada na Listagem 1, foram realizadas duas chamadas ao método tabuada() enviando como argumentos os valores 7 e 8, respectivamente, e uma chamada ao método direitos(),que não necessita de argumentos.
O método tabuada(), ainda na Listagem 1, foi implementado com um parâmetro inteiro identificado por n. Esse parâmetro recebe uma “cópia” do valor do argumento enviado através da instrução de chamada correspondente. No corpo desse método foi implementado um processo de repetição (for) para montar a tabuada de n. Já o método direitos() foi desenvolvido para exibir no monitor de vídeo, através de uma operação de saída usando o método printf(), o nome do autor que detém os direitos autorais da aplicação.
Na Figura 4 pode-se observar a execução da classe Exemplo1, desenvolvida para exemplificar uma aplicação Java dividida em métodos.
Figura 4. Executando a classe Exemplo1 dividida em métodos.
Para realização de uma tarefa em um programa é necessário um método. Os métodos são blocos de código Java que pertencem a uma classe e definem as ações a serem tomadas em diversos momentos da execução de um programa.
A execução de um método para realizar uma tarefa ocorre quando um módulo envia uma “mensagem”, conhecida como “chamada de método”, com informações que instruem como o método deverá executar sua tarefa. Essas informações são conhecidas como parâmetros.
Parâmetros
Os parâmetros são canais pelos quais se estabelece a transferência de informações (constantes, variáveis ou expressões) entre um método e o método que realizou a chamada (o método main() ou outro método qualquer) funcionando como variáveis de entrada de dados.
Um método deve ser definido com uma lista de zero ou mais parâmetros declarada no seu cabeçalho. Essa lista é denominada de lista de parâmetros formais, lista de parâmetros ou simplesmente parâmetros. Quando um método é definido com mais de um parâmetro, é necessário especificar o tipo e o nome de cada parâmetro individualmente e separá-los por vírgula. Por exemplo:
a) declarando o cabeçalho do método direitos(), apresentado na Listagem 1, que não possui parâmetros:
// mostrar os direitos autorais da aplicação
public staticvoid direitos() { … }
b) declarando o cabeçalho do método tabuada(), apresentado na Listagem 1, que tem um parâmetro do tipo inteiro, identificado por n:
// montar a tabuada de “n”
public staticvoid tabuada(int n) { … }
c) declarando o método IMC(), que no cabeçalho relaciona dois parâmetros dotipo real de dupla precisão, identificados por pce alt, respectivamente:
// calcular o Índice de Massa Corporal (IMC): peso corporal dividido pela altura ao quadrado
public staticdouble IMC(double pc, doublealt) {
return(pc / (alt * alt));
}
d) declarando o método GEB(), que no cabeçalho relaciona quatro parâmetros, o primeiro do tipo caractere, o segundo do tipo real de dupla precisão e o terceiro e quarto do tipo inteiro, identificados por sexo, pc, alt e idade, respectivamente:
// calcular o Gasto Energético Basal (GEB): consumo diário básico definido em função do sexo, peso corporal, altura e idade
public static double GEB(char sexo, double pc, int alt, int idade) {
if ((sexo == 'M') || (sexo == 'm'))
return(66.47 + (13.75 * pc) + (5 * alt)- (6.76 * idade));
else
return(655.1 + (9.56 * pc) + (1.85 * alt) - (4.67 * idade));
}
Se um método for implementado recebendo parâmetros, os mesmos deverão ser colocados no interior dos parênteses na instrução de chamada, separados por vírgulas; caso contrário, os parênteses deverão permanecer vazios. Esses valores são denominados de parâmetros reais, parâmetros efetivos ou simplesmente argumentos. Por exemplo:
a) chamando o método direitos(), apresentado na Listagem 1, para mostrar os direitos autorais da aplicação:
direitos();
b) chamando o método tabuada(), apresentado na Listagem 1, para montar a tabuada do número 7 (sete):
tabuada(7);
c) chamando o método IMC() para calcular o índice de massa corporal de uma pessoa com peso corporal de 82,500 quilogramas e altura de 1,77 metros:
System.out.printf("IMC = %.2f", IMC(82.500, 1.77));
d) chamando o método GEB() para calcular o gasto energético basal em quilocalorias (kcal) de uma pessoa do sexo masculino, peso corporal de 82,500 quilogramas, altura de 177 centímetros e 46 anos de idade:
System.out.printf("GEB = %.2f kcal", GEB('M', 82.500, 177, 46));
Um método é uma parte separada do código de uma classe e somenteé executado quando o seu nome (ou identificador) for referenciado em umasentença de chamada de método. Quando um método é chamado para execução, érealizada a associação e passagem de parâmetros obedecendo a ordem de declaração: o 1º argumento é associado ao 1º parâmetro; o 2º argumento é associado ao 2º parâmetro e assim por diante. Portanto, no momento de uma chamada é importante que a quantidade de argumentos na chamada deva ser igual à quantidade de parâmetros do método. E ainda, o tipo do argumento enviado deve ser compatível com o tipo do respectivo parâmetro de entrada.
A Listagem 2 apresenta uma classe Java que implementa três versões para a tarefa de mostrar no dispositivo de saída padrão uma mensagem um determinado número de vezes. Essas versões apresentam diferenças alcançadas, principalmente, pela quantidade de parâmetros usados na chamada do respectivo método.
Listagem 2. Comunicação entre métodos através de parâmetros.
public class Exemplo2 {
 public static void main(String[] args) {
 mensagemUm();
 System.out.printf("\n");
 mensagemDois(5);
 System.out.printf("\n");
 mensagemTres(5, "MÉTODOS EM JAVA");
 System.out.printf("\n");
 mensagemTres(4, "PATO BRANCO/PR");
 }
 public static void mensagemUm() {
 int i;
 for (i=1; i<=3; i++) {
 System.out.printf("%d- DevMedia 
 | Canal Java\n", i);
 }
 }
 public static void mensagemDois(int n) {
 int i;
 for (i=1; i<=n; i++) {
 System.out.printf("%d- DevMedia 
 | Canal Java\n", i);
 }
 }
 public static void mensagemTres(int n, String s) {
 int i;
 for (i=1; i<=n; i++) {
 System.out.printf("%d- %s\n", i, s);
 }
 }
}
No método main() daaplicação Java apresentada na Listagem 2, foram realizadas as chamadas aos métodos mensagemUm(), mensagemDois()e mensagemTres(). O método mensagemUm() não possui parâmetros, e foi implementado usando um processo de repetição (for)para mostrar 3 (três) vezes a mensagem “DevMedia | Canal Java” no dispositivo de saída. Nesse método o número de vezes e a mensagem são valores constantes e,portanto, o resultado da execução do método será sempre o mesmo. Já o método mensagemDois(), implementado com um parâmetro inteiro identificado por n, permite que oresultado alcançando seja um pouco mais flexível. A flexibilidade no resultado ocorre porque o número de vezes que a mensagem “DevMedia | Canal Java” seráexibida depende do valor do argumento enviado para o parâmetro n na respectiva chamada do método. Por último, o método mensagemTres(), implementado com um parâmetro int identificado por n e umparâmetro String identificado por s, conquista uma flexibilidade total no resultado. Isso ocorre porque o número de vezes(parâmetro n) que a mensagem será exibida e a mensagem (parâmetro s) serão definidos somente no momento que a chamada do método for realizada. Por exemplo:
a) definindo na chamada do método mensagemTres() que a mensagem “MÉTODOS EM JAVA” será mostrada 5 (cinco) vezes:
mensagemTres(5, "MÉTODOS EM JAVA");
b) definindo na chamada do método mensagemTres() que a mensagem “PATO BRANCO/PR” será mostrada 4 (quatro) vezes:
mensagemTres(4, "PATO BRANCO/PR");
Na Figura 5 pode-se observar a execução da classe Exemplo2, desenvolvida para demonstrar que os parâmetros funcionam como canais de comunicação entre os métodos de uma aplicação Java.
Figura 5. Executando a classe Exemplo2 para demonstrar a finalidade dos parâmetros.
Os métodos mensagemUm(), mensagemDois() e mensagemTres() apresentados na Listagem 2, na realidade desempenham a mesma tarefa de mostrar uma mensagem um determinador número de vezes. Esses três métodos poderiam ser implementados, na mesma classe, aplicando o mecanismo da sobrecarga de método (overloading), que permite que um método possa apresentar diversos tratamentos diferentes de acordo com os parâmetros usados na chamada. Na prática têm-se dois ou mais métodos com o mesmo nome, mas aceitando parâmetros diferentes (métodos com assinaturas diferentes). A sobrecarga de método será tema abordado nos próximos artigos sobre métodos em Java.
Promoção de argumentos
Um recurso importante das chamadas de método é a promoção de argumentos. O Java promoverá um argumento de chamada de método a fim de coincidir com seu respectivo parâmetro de acordo com as regras de promoção. Por exemplo, um programa pode chamar o método sqrt(), square root ou raiz quadrada, da classe Math, com um argumento inteiro mesmo que o método espere receber um argumento double. Por exemplo, a instrução de chamada:
System.out.printf(“Raiz quadrada de 4 é igual a %.2f\n”, Math.sqrt(4));
será avaliada corretamente para mostrar o resultado 2.00. Essa situação ocorre porque o parâmetro da declaração do método faz com que o Java converta o valor 4 do tipo int no valor 4.0 do tipo double antes de enviar o valor para o método sqrt().
Tentar essas conversões pode levar a erros de compilação se as regras de promoção do Java não forem satisfeitas. A Tabela 1 mostra as regras de promoção indicando quais conversões são autorizadas.
Tabela 1. Promoções válidas de argumentos – Fonte: DEITEL (2005, pág. 173).
Métodos public static
Segundo DEITEL (2005, pág. 166), cada classe fornece métodos que realizam tarefas sobre os objetos da classe. Por exemplo, a partir do Java 1.5 ou Java 5.0, o pacote de classes java.util disponibilizou a classe Scanner, que implementa operações de entrada de dados através do teclado. Para utilizá-la em uma aplicação, o seguinte conjunto de instruções deverá ser implementado:
// importando o pacote “java.util”
import java.util.Scanner;
// instancia e cria o objeto “teclado” a partir da classe “Scanner” para realizar a entrada de dados através do teclado (System.in)
Scanner teclado = new Scanner(System.in);
int n;
System.out.printf("Informeum número para a tabuada:\n");
// aceita a entrada de um número inteiro chamando o método “nextInt()” da classe “Scanner” no objeto “teclado”
n = teclado.nextInt();
Novamente em DEITEL (2005, pág. 167), tem-se que embora a maioria dos métodos seja executada em resposta a chamadas de métodos em objetos específicos, esse nem sempre é o caso. Às vezes um método realiza uma tarefa que não depende do conteúdo de nenhum objeto. Esse método se aplica à classe como um todo e é conhecido como método static (estático) ou método de classe. É comum encontrar classes que disponibilizam grupos de métodos static implementados para realizar tarefas de propósitos gerais. Por exemplo, um programa pode chamar o método de classe pow(), power ou potência, da classe Math, para calcular o valor de 2 elevado à potência de 8 (isto é, 28) usando a seguinte instrução:
System.out.printf(“2 elevado a 8 é igual a %.0f\n”, Math.pow(2, 8));
A classe Math, além dos métodos sqrt() e pow() citados nos exemplos anteriores, fornece uma coleção de métodos static que permite realizar cálculos matemáticos comuns; entre eles destacam-se: abs(x) – valor absoluto de x; max(x, y) – maior valor de x e y; min(x, y) – menor valor de x e y; e, sin(x) – seno trigonométrico de x.
Para declarar métodos de classe deve-se utilizar apalavra-chave static antes do tipo de retornono cabeçalho do método. Por exemplo, o método de classe soma() projetado para somar os valores dosparâmetros a e b,pode apresentar a seguinte implementação:
public static int soma(int a, int b) {
return(a + b);
}
A instrução de chamada de qualquer método static deve ser realizada especificando o nome da classe em que o método está implementado, seguido do operador ponto (.) e pelo nome do método, obedecendo à sintaxe:
NomeDaClasse.nomeDoMétodo([argumentos]);
O modificador de acesso public, também usado na declaração de um método static, indica que o método pode ser utilizado livremente (sem restrições) por outras classes do mesmo projeto. Por exemplo, a chamada do método soma() implementado na classe Exemplo (Figura 3) poderia ser realizada através da seguinte instrução:
System.out.printf("5 + 3 = %d\n\n", Exemplo.soma(5, 3));
A Listagem 3 apresenta uma classe Java que implementa chamadas de métodos estáticos.
Listagem 3. Chamando métodos static.
public class Exemplo3 {
 public static void main(String[] args) {
 System.out.printf("5 + 3 = %d\n\n", 
 Exemplo.soma(5, 3));
 
 Exemplo1.tabuada(9);
 Exemplo2.mensagemDois(3);
 }
}
No método main() da aplicação Java apresentada na Listagem 3, foram realizadas 3 (três) chamadas a métodos static:
1) chamando o método soma() implementado na classe Exemplo (Figura 3);
2) chamando o método tabuada()implementado na classe Exemplo1 (Listagem 1); e, 
3) chamando o método mensagemDois() implementado na classe Exemplo2 (Listagem2).
Na Figura 6 pode-se observar a execução da classe Exemplo3, que realiza a chamada de métodos static ou métodos de classe.
Figura 6. Executando a classe Exemplo3na chamada de métodos static.
Conclusão
Neste primeiro artigo sobre métodos em Java foram apresentados os elementos chaves da programação estruturada que organiza a solução de problemas computacionais em pedaços. Como o Java é uma linguagem de programação orientada a objetos, inicialmente foi apresentada a sintaxe usada na definição de uma classe. A classe em Java corresponde ao principal bloco de construção de sistemas de software.
Na sequência, os métodos foram definidos como serviços implementados na forma de um conjunto de instruções da linguagem que realizam alguma tarefa específica e podem como resultado retornar um valor. A execução de um método ocorre quando um módulo envia uma mensagem com informações que instruem como o método deverá executar sua tarefa. Essas informações são conhecidas como parâmetros, que funcionam como canais de transferência de dados entre os métodos. Uma situação importante nas chamadas de método é a promoção de argumentos, que ocorre para converter o valor de um argumento no tipo que o método espera receber no seu parâmetro correspondente.
Na última parte do artigo foi realizado um estudo sobre os métodos estáticos ou métodos de classe, que são desenvolvidos para realizar tarefas de propósitos gerais e que não dependem do conteúdo de nenhum objeto na sua utilização.
Bibliografia
DEITEL, H.M. (2005) Java: Como Programar. São Paulo: Person Prentice Hall, 6ª edição.
Capítulo 3- Introdução a classes e objetos, páginas 57-85.
Capítulo 6- Métodos: um exame mais profundo, páginas 164-202.
Links
Download dos exemplos apresentados no artigo.
www.pb.utfpr.edu.br/omero/Java/Artigos/MetodosParte1.rarAplicações Java sobre métodos (44 estudos de casos).
www.pb.utfpr.edu.br/omero/Java/Fontes/Lista%
20Subprogramacao/Lista%20Subprogramacao.HTM
Conjunto de slides sobre métodos em Java.
www.pb.utfpr.edu.br/omero/Java/ppt/Metodos.zip
Edsger W. Dijkstra Archive: Home Page.
www.cs.utexas.edu/users/EWD/
The humble programmer.
www.cs.utexas.edu/~EWD/ewd03xx/EWD340.PDF
A Case against the GO TO Statement.
www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF