Nos capítulos anteriores, usamos frequentemente System.out.println(), então o que é?
println() é um método (Método), e System é uma classe de sistema (Classe) e out é um objeto de saída padrão (Objeto). O uso desta frase é chamar o método println() no objeto de saída padrão na classe do sistema System.
Um método Java é uma coleção de instruções que juntas executam uma função.
Um método é uma combinação ordenada de etapas para resolver um tipo de problema
Métodos contidos em classes ou objetos
Os métodos são criados no programa e referenciados em outro lugar
Geralmente, definir um método contém a seguinte sintaxe:
Tipo de valor de retorno do modificador nome do método (tipo de parâmetro nome do parâmetro) {
...
Corpo do método...
valor de retorno de retorno;
}Um método contém um cabeçalho de método e um corpo de método. Aqui estão todas as partes de um método:
Modificadores: Modificadores, que são opcionais, informam ao compilador como chamar o método. Define o tipo de acesso para este método.
Tipo de valor de retorno: os métodos podem retornar valores. returnValueType é o tipo de dados do valor de retorno do método. Alguns métodos executam a operação necessária, mas não retornam um valor. Nesse caso, returnValueType é a palavra-chave void .
Nome do método: é o nome real do método. O nome do método e a lista de parâmetros juntos formam a assinatura do método.
Tipo de parâmetro: o parâmetro é como um espaço reservado. Quando o método é chamado, os valores são passados para os parâmetros. Este valor é chamado de parâmetro ou variável real. A lista de parâmetros refere-se ao tipo de parâmetro, ordem e número de parâmetros do método. Os parâmetros são opcionais e os métodos não podem conter parâmetros.
Corpo do método: O corpo do método contém instruções específicas que definem a função do método.
como:
publicstaticintage(intbirthday){...}Pode haver vários parâmetros:
staticfloatinterest(floatprincipal,intyear){...}Nota: Em algumas outras linguagens os métodos referem-se a procedimentos e funções. Um método que retorna um valor de retorno não nulo é chamado de função; um método que retorna um valor de retorno nulo é chamado de procedimento.
O método abaixo contém 2 parâmetros num1 e num2 e retorna o valor máximo desses dois parâmetros.
/**Retorna o maior valor dos dois dados de variáveis inteiras*/
publicstaticintmax(intnum1,intnum2){
insulto;
if(num1>num2){
resultado=num1;
}outro{
resultado=num2;
}
resultado de retorno;
}Java oferece suporte a duas maneiras de chamar métodos, dependendo se o método retorna um valor.
Quando um programa chama um método, o controle do programa é transferido para o método chamado. O controle é retornado ao programa quando a instrução return do método chamado é executada ou o colchete de fechamento do corpo do método é alcançado.
Quando um método retorna um valor, a chamada do método geralmente é tratada como um valor. Por exemplo:
intmaior=máx(30,40);Se o valor de retorno do método for nulo, a chamada do método deverá ser uma instrução. Por exemplo, o método println retorna void. A seguinte chamada é uma declaração:
System.out.println("Bem-vindo aoJava!");O exemplo a seguir demonstra como definir um método e como chamá-lo:
publicclassTestMax{
/**Método principal*/
publicstaticvoidmain(String[]args){
inti=5;
intj=2;
intk=max(i,j);
System.out.println("Omáximoentre"+i+
"e"+j+"é"+k);
}
/**Retorna o maior valor das duas variáveis inteiras*/
publicstaticintmax(intnum1,intnum2){
insulto;
if(num1>num2){
resultado=num1;
}outro{
resultado=num2;
}
resultado de retorno;
}
}Os resultados de compilação e execução do exemplo acima são os seguintes:
O máximo entre 5 e 2 é 5Este programa contém o método principal e o método max. O método Main é chamado pela JVM. Fora isso, o método principal não é diferente de outros métodos.
O cabeçalho do método principal permanece inalterado, conforme mostrado no exemplo, com os modificadores public e static, retorna um valor do tipo void, o nome do método é main e recebe um parâmetro do tipo String[]. String[] indica que o parâmetro é uma matriz de strings.
Esta seção explica como declarar e chamar um método void.
O exemplo a seguir declara um método chamado printGrade e o chama para imprimir a nota fornecida.
publicclassTestVoidMethod{
publicstaticvoidmain(String[]args){
imprimirGrau(78,5);
}
publicstaticvoidprintGrade(pontuação dupla){
if(pontuação>=90,0){
System.out.println('A');
}
elseif(pontuação>=80,0){
System.out.println('B');
}
elseif(pontuação>=70,0){
System.out.println('C');
}
elseif(pontuação>=60,0){
System.out.println('D');
}
outro{
System.out.println('F');
}
}
}Os resultados de compilação e execução do exemplo acima são os seguintes:
CO método printGrade aqui é um método do tipo void e não retorna um valor.
Uma chamada para um método void deve ser uma instrução. Portanto, é chamado como uma instrução na terceira linha do método principal. Assim como qualquer declaração que termina com ponto e vírgula.
Ao chamar um método, você precisa fornecer parâmetros e deve fornecê-los na ordem especificada na lista de parâmetros.
Por exemplo, o método a seguir imprime uma mensagem n vezes seguidas:
publicstaticvoidnPrintln(Stringmessage,intn){
para(inti=0;i<n;i++)
System.out.println(mensagem);
}O exemplo a seguir demonstra o efeito da passagem por valor.
Este programa cria um método que troca duas variáveis.
publicclassTestPassByValue{
publicstaticvoidmain(String[]args){
intnum1=1;
intnum2=2;
System.out.println("Beforeswapmethod,num1is"+
num1+"andnum2is"+num2);
//Chama o método de troca swap(num1,num2);
System.out.println("Método Afterswap,num1is"+
num1+"andnum2is"+num2);
}
/**Método para trocar duas variáveis*/
publicstaticvoidswap(intn1,intn2){
System.out.println("tInsidetheswapmethod");
System.out.println("ttAntes da trocan1is"+n1
+"n2é"+n2);
//Troca os valores de n1 e n2 inttemp=n1;
n1=n2;
n2=temperatura;
System.out.println("ttAfterswappingn1is"+n1
+"n2é"+n2);
}
}Os resultados de compilação e execução do exemplo acima são os seguintes:
Antes do método de troca, num1is1andnum2is2
Dentro do método swap
Antes de trocarn1is1n2is2
Após trocan1is2n2is1
Após o método de troca, num1is1andnum2is2Chame o método swap passando dois parâmetros. Curiosamente, os valores dos parâmetros reais não mudam depois que o método é chamado.
O método max usado acima se aplica apenas a dados do tipo int. Mas e se você quiser obter o valor máximo de dois tipos de dados de ponto flutuante?
A solução é criar outro método com o mesmo nome, mas com parâmetros diferentes, conforme mostrado no código a seguir:
publicstaticdoublemax(duplonum1,duplonum2){
if(num1>num2){
número de retorno1;
}outro{
retornonum2;
}
}Se você passar um parâmetro int ao chamar o método max, o método max do parâmetro int será chamado;
Se um parâmetro double for passado, o corpo máximo do método do tipo double será chamado.
Ou seja, dois métodos de uma classe possuem o mesmo nome, mas listas de parâmetros diferentes.
O compilador Java determina qual método deve ser chamado com base na assinatura do método.
A sobrecarga de métodos pode tornar o programa mais claro e fácil de ler. Os métodos que executam tarefas intimamente relacionadas devem usar o mesmo nome.
Os métodos sobrecarregados devem ter listas de parâmetros diferentes. Você não pode sobrecarregar métodos baseados apenas em modificadores ou tipos de retorno.
O escopo de uma variável é a parte do programa a partir da qual a variável pode ser referenciada.
Variáveis definidas dentro de um método são chamadas de variáveis locais.
O escopo de uma variável local começa na sua declaração e termina no final do bloco que a contém.
Variáveis locais devem ser declaradas antes de serem usadas.
O escopo do parâmetro de um método cobre todo o método. O parâmetro é na verdade uma variável local.
As variáveis declaradas na parte de inicialização do loop for têm escopo em todo o loop.
Mas o escopo de aplicação da variável declarada no corpo do loop vai desde sua declaração até o final do corpo do loop. Ele contém declarações de variáveis conforme mostrado abaixo:
Você pode declarar uma variável local com o mesmo nome várias vezes dentro de um método, em diferentes blocos não aninhados, mas não pode declarar uma variável local duas vezes dentro de um bloco aninhado.
Às vezes você deseja passar mensagens para um programa enquanto ele está em execução. Isso é feito passando argumentos de linha de comando para a função main().
Os parâmetros da linha de comando são as informações imediatamente após o nome do programa ao executá-lo.
O programa a seguir imprime todos os argumentos da linha de comando:
publicclassCommandLine{
publicstaticvoidmain(Stringargs[]){
for(inti=0;i<args.length;i++){
System.out.println("args ["+i+"]:"+args[i]);
}
}
}Execute o programa conforme mostrado abaixo:
javaCommandLinethisisacommandline200-100Os resultados da execução são os seguintes:
args[0]:este
args[1]:é
argumentos[2]:a
args[3]:comando
args[4]:linha
argumentos[5]:200
argumentos[6]:-100Quando um objeto é criado, construtores são usados para inicializá-lo. O construtor tem o mesmo nome da classe em que está, mas não tem valor de retorno.
Construtores normalmente são usados para atribuir valores iniciais a variáveis de instância de uma classe ou para executar outras etapas necessárias para criar um objeto completo.
Independentemente de você personalizar ou não o construtor, todas as classes possuem construtores porque Java fornece automaticamente um construtor padrão que inicializa todos os membros como 0.
Depois de definir seu próprio construtor, o construtor padrão se torna inválido.
Aqui está um exemplo usando métodos construtores:
//Um construtor simples static classMyClass{
intx;
//A seguir está o construtor MyClass(){
x=10;
}
}Você pode inicializar um objeto chamando o construtor assim:
publicclassConsDemo{
publicstaticvoidmain(Stringargs[]){
MinhaClasst1=newMinhaClass();
MinhaClasse2=newMinhaClass();
System.out.println(t1.x+""+t2.x);
}
}Na maioria das vezes é necessário um construtor com parâmetros.
Aqui está um exemplo usando métodos construtores:
//Um construtor simples classMyClass{
intx;
//A seguir está o construtor MyClass(inti){
x=eu;
}
}Você pode inicializar um objeto chamando o construtor assim:
publicclassConsDemo{
publicstaticvoidmain(Stringargs[]){
MinhaClasset1=newMinhaClasse(10);
MinhaClasse2=newMinhaClasse(20);
System.out.println(t1.x+""+t2.x);
}
}Os resultados da execução são os seguintes:
1020A partir do JDK 1.5, Java suporta a passagem de parâmetros variáveis do mesmo tipo para um método.
A declaração dos parâmetros variáveis do método fica assim:
tipoNome...parâmetroNomeEm uma declaração de método, adicione reticências (...) após especificar o tipo de parâmetro.
Apenas um parâmetro variável pode ser especificado em um método e deve ser o último parâmetro do método. Quaisquer parâmetros comuns devem ser declarados antes dele.
publicclassVarargsDemo{
publicstaticvoidmain(Stringargs[]){
//Chama o método do parâmetro variável printMax(34,3,3,2,56.5);
printMax(novoduplo[]{1,2,3});
}
publicstaticvoidprintMax(duplo...números){
if(números.comprimento==0){
System.out.println("Noargumentpassed");
retornar;
}
resultado duplo=números[0];
for(inti=1;i<números.comprimento;i++)
if(números[i]>resultado){
resultado=números[i];
}
System.out.println("Themaxvalueis"+resultado);
}
}Os resultados de compilação e execução do exemplo acima são os seguintes:
O valor máximo é 56,5
O valor máximo é 3,0Java permite a definição de tal método, que é chamado antes que o objeto seja destruído (reciclado) pelo coletor de lixo. Esse método é chamado finalize(), que é usado para limpar o objeto reciclado.
Por exemplo, você pode usar finalize() para garantir que um arquivo aberto por um objeto seja fechado.
No método finalize(), você deve especificar as operações a serem executadas quando o objeto for destruído.
O formato geral de finalize() é:
protegidovoidfinalize()
{
//Código do terminal aqui}A palavra-chave protected é um qualificador que garante que o método finalize() não será chamado por código fora da classe.
Obviamente, a reciclagem de memória do Java pode ser concluída automaticamente pela JVM. Se você usá-lo manualmente, poderá usar o método acima.
publicclassFinalizationDemo{
publicstaticvoidmain(String[]args){
Boloc1=novoBolo(1);
Boloc2=novoBolo(2);
Boloc3=novoBolo(3);
c2=c3=nulo;
System.gc();//chamando o coletor de lixo Java}
}
classCakeextendsObject{
privadointid;
publicCake(intid){
isto.id=id;
System.out.println("CakeObject"+id+"iscreated");
}
protegidovoidfinalize()throwsjava.lang.Throwable{
super.finalize();
System.out.println("CakeObject"+id+"isdisposed");
}
}Executando o código acima, os resultados de saída são os seguintes:
C:1>javaFinalizationDemo
CakeObject1 foi criado
CakeObject2 foi criado
CakeObject3 foi criado
CakeObject3 está descartado
CakeObject2isdisposed