Dia 6

Criar classes e aplicações em Java

Laura Lemay

• Definição de classes
• Criar variáveis de classe e exemplo
  • Definição de variáveis de exemplo
  • Constantes
  • Variáveis de classe
• Criação de métodos
  • Definição de métodos
  • A palavra-chave de this
  • Definições de método e alcance variáveis
  • Passar argumentos a métodos
  • Métodos de classe
• Criação de aplicações de Java
  • Classes de ajudante
• Aplicações de Java e argumentos de linha de comando
  • Passar argumentos a programas de Java
  • Tratar argumentos no seu programa de Java
• Sumário
• Perguntas e Respostas
  

Em quase cada lição até este ponto tem criado classes de escrita das aplicações de Java, criando variáveis de exemplo e métodos, e dirigindo aquelas aplicações para executar tarefas simples. Também até este ponto, enfocou qualquer o muito largo (teoria orientada ao objeto geral) ou o mesmo minuto (aritmética e outras expressões). Hoje juntará tudo isso e aprenderá como e porque criar classes usando os seguintes fundamentos:

• As partes de uma definição de classe
• Declarar e usar variáveis de exemplo
• Definir e usar métodos
• Criar aplicações de Java, inclusive o método de main() e como passar argumentos a um programa Java de uma linha de comando

Definição de classes

A definição de classes é bastante fácil; viu como fazê-lo um ramo de tempos em lições prévias. Para definir uma classe, use a palavra-chave de class e o nome da classe:

class MyClassName {
...
}

À revelia, as classes herdam da classe de Object. Se esta classe for uma subclasse de outra classe específica (isto é, herda de outra classe), use extends para indicar a superclasse desta classe:

class myClassName extends mySuperClassName {
...
}

Criar variáveis de classe e exemplo

Uma definição de classe com nada nele é bastante enfadonha; normalmente, quando cria uma classe, tem algo que quer acrescentar para fazer aquela classe diferente das suas superclasses. Dentro de cada classe definição são declarações e definições de variáveis ou métodos ou tanto - para a classe como para cada exemplo. Nesta seção, aprenderá todos sobre variáveis de classe e exemplo; a seguinte seção fala sobre métodos.

Definição de variáveis de exemplo

No Dia 3, "os Fundamentos de Java", aprendeu como declarar e inicializar variáveis locais - isto é, variáveis dentro de definições de método. As variáveis de exemplo, afortunadamente, declaram-se e definem-se em quase exatamente o mesmo caminho que variáveis locais; a diferença principal é a sua posição na definição de classe. As variáveis consideram-se variáveis de exemplo se se declararem do lado de fora de uma definição de método. Habitualmente, contudo, a maior parte de variáveis de exemplo definem-se somente depois da primeira linha da definição de classe. Por exemplo, a Listagem 6.1 mostra uma definição de classe simples da classe Bicycle, que herda da classe PersonPoweredVehicle. Esta definição de classe contém cinco variáveis de exemplo:

• bikeType - a espécie de bicicleta este ser por exemplo de bicicleta, Mountain ou Street
• chainGear - O número de engrenagens na frente
• rearCogs - O número de engrenagens menores no eixo de roda traseiro
• currentGearFront e currentGearRear - a engrenagem a bicicleta estão atualmente em, tanto frente como parte de trás

A listagem 6.1. A classe de Bicycle.

1: class Bicycle extends PersonPoweredVehicle {
2:     String bikeType;
3:     int chainGear;
4:     int rearCogs;
5:     int currentGearFront;
6:     int currentGearRear;
7: }

Constantes

Uma constante variável ou constante é uma variável cujo valor nunca se modifica (que pode parecer estranho dado a significação da variável de palavra). As constantes são úteis para definir valores compartilhados de todos os métodos de um objeto - para dar nomes significativos para valores objectwides que nunca se modificarão. Em Java, pode criar constantes só por exemplo ou variáveis de classe, não para variáveis locais.

Para declarar uma constante, use a palavra-chave de final antes da declaração variável e inclua um valor inicial daquela variável:

final float pi = 3.141592;
final boolean debug = false;
final int maxsize = 40000;

As constantes podem ser úteis para denominar vários estados de um objeto e logo testar para aqueles estados. Por exemplo, suponha que tem uma etiqueta de experiência que pode alinhar-se deixada, direito ou centro. Pode definir aqueles valores como números inteiros constantes:

final int LEFT = 0;
final int RIGHT = 1;
final int CENTER = 2;

O alinhamento variável então também se declara como um int:

int alignment;

Então, depois no corpo de uma definição de método, pode estabelecer o alinhamento:

this.alignment = CENTER;

ou teste de um alinhamento dado:

switch (this.alignment) {
    case LEFT: // deal with left alignment
               ...
               break;
    case RIGHT: // deal with right alignment
                ...
                break;
    case CENTER: // deal with center alignment
                 ...
                 break;
}

Variáveis de classe

Como aprendeu em lições prévias, as variáveis de classe são globais a uma classe e a exemplos de toda aquela classe. Pode pensar em variáveis de classe como até mais globais do que variáveis de exemplo. As variáveis de classe são boas para comunicar-se entre objetos diferentes com a mesma classe, ou para guardar a pista de estados globais entre o grupo de objetos.

Para declarar uma variável de classe, use a palavra-chave de static na declaração de classe:

static int sum;
static final int maxObjects = 10;

Criação de métodos

Os métodos, como aprendeu no Dia 2, "Programação orientada ao Objeto e Java", definem o comportamento de um objeto - o que acontece quando aquele objeto se cria e várias operações que o objeto pode executar durante a sua vida. Nesta seção, adquirirá uma introdução básica para a definição de método e como trabalham os métodos; amanhã, entrará em mais detalhe sobre coisas promovidas que pode fazer com métodos.

Definição de métodos

As definições de método têm quatro partes básicas:

• O nome do método
• O tipo de objeto ou tipo primitivo os regressos de método
• Uma lista de parâmetros
• O corpo do método

Três primeiras partes da definição de método formam o que chamou a assinatura do método e indica a informação mais importante sobre o próprio método.

Em outras línguas, o nome do método (ou função, subrotina ou procedimento) é bastante para distingui-lo de outros métodos no programa. Em Java, pode ter métodos diferentes que têm o mesmo nome mas um tipo de regresso diferente ou lista de parâmetros, portanto todas estas partes da definição de método são importantes. Isto chama-se a baldeação de método, e aprenderá mais sobre ele amanhã.

Aqui está a que uma definição de método básica parece:

returntype methodname(type1 arg1, type2 arg2, type3 arg3..) {
    ...
}

O returntype é o tipo do valor este método regressos. Pode ser um dos tipos primitivos, um nome de classe ou void se o método não devolver um valor em absoluto.

Observe que se este método devolver um objeto de tabela, os suportes de forma triangular de tabela podem ir depois do tipo de regresso ou depois da lista de parâmetro; porque o antigo caminho é consideravelmente mais fácil ler, usa-se nos exemplos hoje (e em todas as partes deste livro):

int[] makeRange(int lower, int upper) {...}

A lista de parâmetro do método é grupo de declarações variáveis, separadas por vírgulas, dentro de parênteses. Estes parâmetros tornam-se variáveis locais no corpo do método, cujos valores são os objetos ou os valores de primitivos passaram em quando o método se chama.

Dentro do corpo do método pode ter afirmações, expressões, o método chama a outros objetos, condicionais, laços, e assim por diante - tudo sobre o qual aprendeu nas lições prévias.

Se o seu método tiver um verdadeiro tipo de regresso (isto é, não se declarou que devolva void), em algum lugar dentro do corpo do método tem de devolver explicitamente um valor. Use a palavra-chave de return para fazer isto. A listagem 6.2 mostra um exemplo de uma classe que define um método de makeRange(). makeRange() toma dois números-inteiros-a mais baixo atados e um limite superior - e cria uma tabela que contém todos os números inteiros entre aqueles dois limites (inclusivamente).

A listagem 6.2. A classe de RangeClass.

 1: class RangeClass {
 2:     int[] makeRange(int lower, int upper) {
 3:         int arr[] = new int[ (upper - lower) + 1 ];
 4:
 5:         for (int i = 0; i < arr.length; i++) {
 6:             arr[i] = lower++;
 7:         }
 8:         return arr;
 9:     }
10:
11:     public static void main(String arg[]) {
12:         int theArray[];
13:         RangeClass theRange = new RangeClass();
14:
15:         theArray = theRange.makeRange(1, 10);
16:         System.out.print("The array: [ ");
17:         for (int i = 0; i < theArray.length; i++) {
18:             System.out.print(theArray[i] + " ");
19:         }
20:         System.out.println("]");
21:     }
22:
23: }

The array: [ 1 2 3 4 5 6 7 8 9 10 ]

A palavra-chave de this

No corpo de uma definição de método, pode querer referir-se ao objeto atual - o objeto no qual o método se contém no primeiro lugar - para referir-se a variáveis de exemplo daquele objeto ou passar o objeto atual como um argumento a outro método. Para referir-se ao objeto atual nestes casos, pode usar a palavra-chave de this. this pode usar-se em qualquer lugar o objeto atual poderia parecer - na notação de ponto referir-se às variáveis de exemplo do objeto, como um argumento a um método, como o valor de retorno do método atual, e assim por diante. Aqui está um exemplo:

t = this.x;          // the x instance variable for this object
this.myMethod(this); // call the myMethod method, defined in
                     // this class, and pass it the current
                     // object
return this;         // return the current object

Em muitos casos pode ser capaz de omitir a palavra-chave de this inteiramente. Pode referir-se tanto a variáveis de exemplo como a chamadas de método definidas na classe atual simplesmente de nome; o this é implícito naquelas referências. Portanto dois primeiros exemplos podem escrever-se como isto:

t = x          // the x instance variable for this object
myMethod(this) // call the myMethod method, defined in this
               // class

Tenha em mente que porque this é uma referência para o exemplo atual de uma classe, só deve usá-lo dentro do corpo de uma definição de método de exemplo. Os métodos de classe - isto é, métodos declarados com a palavra-chave estática - não podem usar this.

Definições de método e alcance variáveis

Quando declara uma variável, aquela variável sempre tem um alcance limitado. O alcance variável determina onde aquela variável pode usar-se. As variáveis com um alcance local, por exemplo, só podem usar-se dentro do bloco no qual se definiram. As variáveis de exemplo têm um alcance que se estende à classe inteira portanto podem usar-se por algum dos métodos dentro daquela classe.

Quando se refere a uma variável dentro das suas definições de método, cheques de Java de uma definição daquela variável primeiro no alcance atual (que pode ser um bloco, por exemplo, dentro de um laço), logo nos alcances exteriores até a definição de método atual. Se aquela variável não for uma variável local, Java então verifica uma definição daquela variável como um exemplo ou variável de classe na classe atual, e logo, finalmente, em cada superclasse à sua vez.

Por causa do caminho Java verifica o alcance de uma variável dada, é possível para você criar uma variável em um alcance mais baixo tal que uma definição do qual a mesma variável "esconde" o valor original daquela variável. Isto pode apresentar defeitos sutis e confusos no seu código.

Por exemplo, observe o pequeno programa Java na Listagem 6.3.

A listagem 6.3. Um exemplo de alcance variável.

 1: class ScopeTest {
 2:     int test = 10;
 3:
 4:     void printTest () {
 5:         int test = 20;
 6:         System.out.println("test = " + test);
 7:     }
 8:
 9:     public static void main (String args[]) {
10:        ScopeTest st = new ScopeTest();
11:        st.printTest();
12:     }
13: }

O modo mais fácil de vir em volta deste problema é assegurar-se que não usa os mesmos nomes para variáveis locais que faz por exemplo variáveis. Outro modo de vir em volta deste determinado problema, contudo, é usar this.test para enviar à variável de exemplo, e somente test a referir-se à variável local. Referindo-se explicitamente à variável de exemplo pelo seu alcance de objeto evita o conflito.

Um exemplo mais insidioso deste problema de nomeação variável ocorre quando redefine uma variável em uma subclasse que já ocorre em uma superclasse. Isto pode criar defeitos muito sutis no seu código por exemplo, pode chamar métodos que se destinam para modificar o valor de uma variável de exemplo, mas aquela modificação a incorreta. Outro defeito poderia ocorrer quando lança um objeto de uma classe ao outro - o valor da sua variável de exemplo pode modificar-se misteriosamente (porque adquiria aquele valor da superclasse em vez da sua classe). O melhor modo de evitar este comportamento é assegurar-se que quando define variáveis em uma subclasse sabe as variáveis em cada uma de superclasses daquela classe e não duplica o que já está lá.

Passar argumentos a métodos

Quando chama um método com parâmetros de objeto, as variáveis que passa no corpo do método passam-se pela referência, que significa que tudo o que faça àqueles objetos dentro do método afeta os objetos originais também. Isto inclui tabelas e todos os objetos que as tabelas contêm; quando passa uma tabela em um método e modifica os seus conteúdos, a tabela original afeta-se. (Observe que os tipos primitivos se passam pelo valor.)

A listagem 6.4 é um exemplo para demonstrar como isto trabalha.

A listagem 6.4. A classe de PassByReference.

 1: class PassByReference {
 2:     int onetoZero(int arg[]) {
 3:         int count = 0;
 4:
 5:         for (int i = 0; i < arg.length; i++) {
 6:             if (arg[i] == 1) {
 7:                 count++;
 8:                 arg[i] = 0;
 9:             }
10:         }
11:         return count;
12:     }
13:     public static void main (String arg[]) {
14        int arr[] = { 1, 3, 4, 5, 1, 1, 7 };
15:        PassByReference test = new PassByReference();
16:        int numOnes;
17:
18:        System.out.print("Values of the array: [ ");
19:        for (int i = 0; i < arr.length; i++) {
20:           System.out.print(arr[i] + " ");
21:        }
22:        System.out.println("]");
23:
24        numOnes = test.onetoZero(arr);
25:        System.out.println("Number of Ones = " + numOnes);
26:        System.out.print("New values of the array: [ ");
27:        for (int i = 0; i < arr.length; i++) {
28:            System.out.print(arr[i] + " ");
29:        }
30:        System.out.println("]");
31:     }
32:}

Values of the array: [ 1 3 4 5 1 1 7 ]
Number of Ones = 3
New values of the array: [ 0 3 4 5 0 0 7 ]

• Conta o número de 1 s na tabela e regressos aquele valor.
• Se encontrar um 1, substitui um 0 no seu lugar na tabela.

O método de main() na classe de PassByReference testa o uso do método the onetoZero(). Vamos sobre a linha de método de main() pela linha para que possa ver o que está acontecendo e porque a produção mostra o que faz.

As linhas 14 para 16 fundam as variáveis iniciais deste exemplo. O primeiro é uma tabela de números inteiros; o segundo é um exemplo da classe PassByReference, que se guarda no teste variável. O terceiro é um número inteiro simples para manter o número de na tabela.

As linhas 18 para 22 imprimem os valores iniciais da tabela; pode ver a produção destas linhas na primeira linha da produção.

A linha 24 é onde o verdadeiro trabalho se realiza; isto é onde chama o método de onetoZero(), definido no teste de objeto, e o passa a tabela guardou em arr. Este método devolve o número de na tabela, que então destinará ao numOnes variável.

Adquiriu-o por enquanto? A linha 25 imprime o número de 1 s (isto é, o valor que devolveu do método de onetoZero()). Devolve 3, como esperaria.

O ramo último de linhas imprime os valores de tabela. Como uma referência para o objeto de tabela se passa ao método, modificando a tabela dentro daquele método modificações que a cópia original da tabela. Imprimir os valores em linhas 27 para 30 comprova isto - que a linha última da produção mostra que todo o 1 s na tabela se modificou para 0 s.

Métodos de classe

Tão como tem classe e variáveis de exemplo, também tem classe e métodos de exemplo, e as diferenças entre os dois tipos de métodos são análogas. Os métodos de classe estão disponíveis para qualquer exemplo da própria classe e podem pôr-se à disposição de outras classes. Por isso, alguns métodos de classe podem usar-se em qualquer lugar, mesmo que um exemplo da classe exista.

Por exemplo, as bibliotecas de classe de Java incluem uma classe chamada Math. A classe de Math define um jogo inteiro de operações matemáticas que podem usar-se em qualquer programa ou vários tipos de número:

float root = Math.sqrt(453.0);
System.out.print("The larger of x and y is " + Math.max(x, y));

Para definir métodos de classe, use a palavra-chave de static em frente da definição de método, tão como criaria uma variável de classe. Por exemplo, aquele método de classe de max poderia ter uma assinatura como isto:

static int max(int arg1, int arg2) { ... }

Java fornece a classes "de empacotador" de cada um dos tipos de dados por exemplo primitivos, classes de Integer, Float e boolean. Usar métodos de classe definiu naquelas classes, pode converter em e de objetos e tipos primitivos. Por exemplo, o método de classe de parseInt() na classe de Integer toma uma cadeia e uma raiz (base) e devolve o valor daquela cadeia como um número inteiro:

int count = Integer.parseInt("42", 10) // returns 42

A maior parte de métodos que produzem um determinado objeto, ou que afetam aquele objeto, devem definir-se como métodos de exemplo. Os métodos que fornecem alguma utilidade geral mas não afetam diretamente um exemplo daquela classe declaram-se melhor como métodos de classe.

Criação de aplicações de Java

Agora que sabe como criar classes, objetos, e classe e variáveis de exemplo e métodos, tudo que isto se deixa deve juntá-lo em algo que pode correr em outras palavras de fato, para criar uma aplicação de Java.

As aplicações, para refrescar a sua memória, são programas Java que correm sozinhos. As aplicações são diferentes de applets, que necessitam que um browser permitido por Java os examine. A maior parte do que tem criado até este ponto foi aplicações de Java; a próxima semana vai se mergulhar em como criar applets. (Applets necessitam um bocado mais contexto para conseguir que eles interajam com o browser e desenhem e atualizem com o sistema de gráficos. Aprenderá tudo isso a próxima semana.)

Uma aplicação de Java compõe-se de uma ou várias classes e pode ser tão grande ou tão pequena como quer que ela seja. Enquanto todas as aplicações de Java que criou até este ponto fazem apenas a produção alguns carateres à tela ou a uma janela, também pode criar aplicações de Java que usam janelas, gráfica e elementos de interface de usuário, como os applets fazem (aprenderá como fazer isto a próxima semana). A única coisa que tem de fazer uma aplicação de Java dirigir, contudo, é uma classe que serve do "salto -" do ponto do resto do seu programa Java. Se o seu programa for bastante pequeno, pode precisar-se só de uma classe.

O salto - da classe da sua aplicação precisa de só uma coisa: um método de main(). Quando dirige a sua classe de Java compilada (usando o intérprete de Java), o método de main() é a primeira coisa que se chama. Nenhum disto deve ser a maior parte de uma surpresa para você neste ponto; tem criado aplicações de Java com métodos de main() do início.

A assinatura do método de main() sempre parece a isto:

public static void main(String args[]) {...}

Aqui está um enfraquecimento das partes do método de main():

• public significa que este método está disponível para outras classes e objetos. O método de main() deve declarar-se por public. Aprenderá mais sobre public e métodos de private na Semana 3.
• static significa que isto é um método de classe.
• void significa que o método de main() não devolve nada.
• main() toma um parâmetro: uma tabela de cadeias. Este argumento usa-se para argumentos de linha de comando, sobre os quais aprenderá na seguinte seção.

O corpo do método de main() contém qualquer código tem de começar a sua aplicação: inicialização de variáveis ou criação dos exemplos de qualquer classe pode ter declarado.

Quando Java realiza o método de main(), tenha em mente que main() é um método de classe - a classe que considera que não é automaticamente instantiated quando o seu programa corre. Se quiser tratar aquela classe como um objeto, tem-na a instantiate no método de main() você mesmo (todos os exemplos até este ponto fizeram isto).

Classes de ajudante

A sua aplicação de Java pode ter só uma classe, ou, em caso da maior parte de programas maiores, pode compor-se de várias classes, onde os exemplos diferentes de cada classe se criam e se usam enquanto a aplicação corre. Pode criar tantas classes como quer para o seu programa, e enquanto estão no mesmo diretório ou enumerados no seu CLASSPATH, Java será capaz de encontrá-los quando o seu programa corre. Observe, contudo, que só o salto daquele - da classe, só a classe usa com Java bytecode o intérprete precisa do método a main(). Lembre-se, main() só usa-se para que Java possa lançar o programa e criar um objeto inicial; depois que isto, os métodos dentro de várias classes e objetos assomem. Enquanto pode incluir métodos de main() em classes de ajudante, vão se ignorar quando o programa de fato corre.

Aplicações de Java e argumentos de linha de comando

Como as aplicações de Java são programas autônomos, é útil ser capaz de passar argumentos ou opções a um programa para determinar como o programa vai correr ou permitir a um programa genérico produzir muitos tipos diferentes da entrada. Os argumentos de linha de comando podem usar-se com muitos objetivos por exemplo diferentes, para acender a entrada de depuração, indicar um nome de arquivo para ler ou escrever de, ou para qualquer outra informação que poderia querer que o seu programa Java soubesse.

Passar argumentos a programas de Java

Como passa argumentos a uma aplicação de Java varia baseado na plataforma na qual dirige Java. No Windows e UNIX, pode passar argumentos ao programa Java via a linha de comando; no Macintosh, o Corredor de Java dá-lhe uma janela especial para datilografar aqueles argumentos.

A figura 6.1: argumentos de Corredor de Java.

Entre nos seus argumentos, separados por espaços, nesta caixa.

Nestes exemplos, passou três argumentos ao seu programa: argumentOne, o número 2 e three. Observe que um espaço separa argumentos, portanto se usar a frase Java is cool como os seus argumentos, adquirirá três deles.

A argumentos de grupo, rodeie-os de citações duplas. Deste modo, por exemplo, o argumento "Java is cool" produz um argumento pelo seu programa para tratar. As citações duplas despem-se de antes que o argumento venha ao seu programa Java.

Tratar argumentos no seu programa de Java

Como Java trata argumentos? Guarda-os em uma tabela de cadeias, que se passa ao método de main() no seu programa Java. Lembre-se da assinatura de main():

public static void main (String args[]) {...}

Aqui, args é o nome da tabela de cadeias que contém a lista de argumentos. Pode chamá-lo de fato algo que quer.

Dentro do seu método de main(), então pode tratar os argumentos que o seu programa se deu repetindo sobre a tabela de argumentos e tratando aqueles argumentos de qualquer caminho quer. Por exemplo, a Listagem 6.5 é uma classe realmente simples que imprime os argumentos que adquire, um por linha.

A listagem 6.5. A classe de EchoArgs.

1: class EchoArgs {
2:     public static void main(String args[]) {
3:         for (int i = 0; i < args.length; i++) {
4:             System.out.println("Argument " + i + ": " + args[i]);
5:         }
6:     }
7: }

O seguinte é alguma entrada e saída de mostra deste programa:

java EchoArgs 1 2 3 jump

Argument 0: 1
Argument 1: 2
Argument 2: 3
Argument 3: jump

java EchoArgs "foo bar" zap twaddle 5

Argument 0: foo bar
Argument 1: zap
Argument 2: twaddle
Argument 3: 5

Observe como os argumentos se agrupam no segundo exemplo de entrada; pôr citações em volta de foo bar faz que àquele argumento se trate como uma unidade dentro da tabela de argumento.

Uma coisa importante a observar sobre os argumentos que passa em um programa Java consiste em que aqueles argumentos se guardarão em uma tabela de cadeias. Isto significa que qualquer argumento que passa ao seu programa Java é cadeias guardadas na tabela de argumento. Para tratá-los como não-cadeias, terá de convertê-los em qualquer tipo que quer que eles sejam.

Por exemplo, suponha que tem um programa Java muito simples chamado SumAverage que toma qualquer número de argumentos numéricos e devolve a soma e a média daqueles argumentos. A listagem 6.6 mostra um primeiro passo neste programa. Não tente compilar este; somente olhe para o código e ver se pode compreender o que faz.

A listagem 6.6. Uma primeira tentativa na classe de SumAverage.

 1: class SumAverage {
 2:     public static void main (String args[]) {
 3:         int sum = 0;
 4:
 5:         for (int i = 0; i < args.length; i++) {
 6:             sum += args[i];
 7:         }
 8:
 9:         System.out.println("Sum is: " + sum);
10:         System.out.println("Average is: " +
11:             (float)sum / args.length);
12:     }
13: }

À primeira vista, este programa parece que o laço de for bastante franco-a repete sobre a tabela de argumentos, somando-os, e logo a soma e a média imprimem-se como o passo último.

O que acontece quando tenta e compila isto? Adquire um erro semelhante a este:

SumAverage.java:6: Incompatible type for +=.
Can't convert java.lang.String to int.
    sum += args[i];

Adquire este erro porque a tabela de argumento é uma tabela de cadeias. Embora passasse números inteiros no programa da linha de comando, aqueles números inteiros converteram-se em cadeias antes que se guardassem na tabela. Para ser capaz de somar aqueles números inteiros, tem de convertê-los atrás de cadeias a números inteiros. Há um método de classe da classe de Integer, chamada parseInt, que faz somente isto. Se modificar a linha 6 para usar aquele método, tudo trabalha somente perfeito:

sum += Integer.parseInt(args[i]);

Agora, a compilação do programa não produz nenhum erro e a gerência dele com vários argumentos devolve os resultados esperados. Por exemplo, java SumAverage 1 2 3 devolve a seguinte produção:

Sum is: 6
Average is: 2

Sumário

Hoje junta tudo que encontrou durante os dias precedentes desta semana sobre como criar classes de Java e usá-los em aplicações de Java. Isto inclui o seguinte:

• O exemplo e as variáveis de classe, que mantêm os atributos da classe e os seus exemplos. Aprendeu como declará-los, como são diferentes de variáveis locais regulares, e como declarar constantes.
• O exemplo e os métodos de classe, que definem o comportamento de uma classe. Aprendeu como definir métodos, inclusive as partes da assinatura de um método, como a valores de retorno de um método, como os argumentos se passam em e fora de métodos, e como usar a palavra-chave de this para referir-se ao objeto atual.
• As aplicações de Java - todos sobre o método de main() e como trabalha, bem como como passar argumentos em uma aplicação de Java de uma linha de comando.

Perguntas e Respostas