Laura Lemay
Os métodos são discutivelmente a parte mais importante de qualquer língua orientada ao objeto. Ao passo que as classes e os objetos fornecem a armação, e a classe e as variáveis de exemplo fornecem um modo de considerar que os atributos de classe ou objeto, os métodos de fato fornecem o comportamento de um objeto e definem como aquele objeto interage com outros objetos no sistema.
Ontem aprendeu um pouco sobre a definição de métodos. Com que aprendeu ontem, pode criar muitos programas Java, mas estaria faltando a algumas características de métodos que os fazem realmente potentes e que fazem os seus objetos e classes mais eficientes e mais fáceis entender. Hoje aprenderá sobre estas características adicionais, inclusive o seguinte:
Ontem aprendeu como criar métodos com um nome único e uma assinatura única. Os métodos em Java também podem sobrecarregar-se - isto é, pode criar métodos que têm o mesmo nome, mas assinaturas diferentes e definições diferentes. A baldeação de método permite aos exemplos da sua classe ter uma interface mais simples para outros objetos (nenhuma necessidade de métodos inteiramente diferentes com nomes diferentes que fazem essencialmente a mesma coisa) e comportar-se diferentemente baseado na entrada àquele método. Por exemplo, um método de draw() sobrecarregado pode usar-se para desenhar quase algo, se foi um círculo ou um ponto ou uma imagem. O mesmo nome de método, com argumentos diferentes, pode usar-se para todos os casos.
Quando chama um método em um objeto, Java experimenta o nome de método e o número e o tipo de argumentos para selecionar que definição de método realizar.
| Novo termo |
A baldeação de método cria múltiplos métodos com o mesmo nome mas com assinaturas diferentes e definições. Java usa o número e o tipo de argumentos para selecionar que definição de método realizar. |
Para criar um método sobrecarregado, tudo que tem de fazer é criam várias definições de método diferentes na sua classe, todos com o mesmo nome, mas com listas de parâmetro diferentes (em número ou em tipo de argumentos). Java permite o método que sobrecarrega enquanto cada lista de parâmetro é única para o mesmo nome de método.
Observe que Java diferencia métodos sobrecarregados baseados no número e o tipo de parâmetros àquele método, não no tipo de regresso do método. Isto é, se tentar criar dois métodos com o mesmo nome e a mesma lista de parâmetro, mas tipos de regresso diferentes, adquirirá um erro de compilador. Também, os nomes da variável que escolhe para cada parâmetro ao método são inaplicáveis - tudo que importa é o número e o tipo.
Aqui está um exemplo de criar um método sobrecarregado. A listagem 7.1 mostra uma definição de classe simples de uma classe chamada MyRect, que define uma forma retangular. A classe de MyRect tem quatro variáveis de exemplo para definir as esquinas deixadas de maneira superior e mais baixas e direitas do retângulo: x1, y1, x2 e y2.
| Observar |
Porque o chamei MyRect em vez de somente Rectangle? O pacote de java.awt tem uma classe chamada Rectangle que implementa a maior parte deste mesmo comportamento. Chamei esta classe MyRect para prevenir a confusão entre as duas classes. |
A listagem 7.1. A classe de MyRect.
1: class MyRect {
2: int x1 = 0;
3: int y1 = 0;
4: int x2 = 0;
5: int y2 = 0;
6: }
| Observar |
Não tente compilar este exemplo ainda. De fato, compilará somente perfeito, mas não correrá porque (ainda) não tem um método de main(). Quando se termina construindo esta definição de classe, a versão final pode compilar-se e dirigir-se. |
Quando um novo exemplo da classe de myRect se cria inicialmente, todas as suas variáveis de exemplo inicializam-se a 0. Vamos definir um método de buildRecpt() que toma quatro argumentos de número inteiro e "altera o tamanho" do retângulo para ter os valores apropriados das suas esquinas, devolvendo o objeto de retângulo resultante (observe que porque os argumentos têm os mesmos nomes que as variáveis de exemplo, tem de assegurar-se para usar this para referir-se a eles):
MyRect buildRect(int x1, int y1, int x2, int y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
return this;
}
E se quer definir dimensões de um retângulo de um modo por exemplo diferente, usando objetos de Point em vez de coordenadas individuais? Pode sobrecarregar buildRect() para que a sua lista de parâmetro tome dois objetos de Point (observe que também precisará de importar a classe de java.awt.Point em cima do seu arquivo original portanto Java pode encontrá-lo):
MyRect buildRect(Point topLeft, Point bottomRight) {
x1 = topLeft.x;
y1 = topLeft.y;
x2 = bottomRight.x;
y2 = bottomRight.y;
return this;
}
Possivelmente quer definir o retângulo usando uma esquina superior e uma largura e altura. Pode fazer isto, também. Somente crie uma definição diferente de buildRect():
MyRect buildRect(Point topLeft, int w, int h) {
x1 = topLeft.x;
y1 = topLeft.y;
x2 = (x1 + w);
y2 = (y1 + h);
return this;
}
Para terminar este exemplo, vamos criar um printRect() chamado pelo método - para imprimir as coordenadas do retângulo e um método de main() para testar tudo isso (somente para comprovar que isto realmente de fato trabalha). A listagem 7.2 mostra a definição de classe concluída com todos os seus métodos: três métodos de buildRect(), um printRect() e um main().
A listagem 7.2. A classe de MyRect completa.
1:import java.awt.Point;
2:
3:class MyRect {
4: int x1 = 0;
5: int y1 = 0;
6: int x2 = 0;
7: int y2 = 0;
8:
9: MyRect buildRect(int x1, int y1, int x2, int y2) {
10: this.x1 = x1;
11: this.y1 = y1;
12: this.x2 = x2;
13: this.y2 = y2;
14: return this;
15: }
16:
17: MyRect buildRect(Point topLeft, Point bottomRight) {
18: x1 = topLeft.x;
19: y1 = topLeft.y;
20: x2 = bottomRight.x;
21: y2 = bottomRight.y;
22: return this;
23: }
24:
25: MyRect buildRect(Point topLeft, int w, int h) {
26: x1 = topLeft.x;
27: y1 = topLeft.y;
28: x2 = (x1 + w);
29: y2 = (y1 + h);
30: return this;
31: }
32:
33: void printRect(){
34: System.out.print("MyRect: <" + x1 + ", " + y1);
35: System.out.println(", " + x2 + ", " + y2 + ">");
36: }
37:
38: public static void main(String args[]) {
39: MyRect rect = new MyRect();
40:
41: System.out.println("Calling buildRect with coordinates 25,25
50,50:");
42: rect.buildRect(25, 25, 50, 50);
43: rect.printRect();
44: System.out.println("----------");
45:
46: System.out.println("Calling buildRect w/points (10,10), (20,20):");
47: rect.buildRect(new Point(10,10), new Point(20,20));
48: rect.printRect();
49: System.out.println("----------");
50:
51: System.out.print("Calling buildRect w/1 point (10,10),");
52: System.out.println(" width (50) and height (50):");
53:
54: rect.buildRect(new Point(10,10), 50, 50);
55: rect.printRect();
56: System.out.println("----------");
57: }
58: }
Como pode ver deste exemplo, todo o trabalho de métodos de buildRect() baseado nos argumentos com os quais os chamam. Pode definir tantas versões de um método como precisa nas suas próprias classes para implementar o comportamento do qual precisa para aquela classe. Além de métodos regulares, também pode definir métodos de construtor na sua definição de classe. Os métodos de construtor usam-se para inicializar novos objetos quando se criam. Diferentemente de métodos regulares, não pode chamar um método de construtor chamando-o diretamente; em vez disso, os métodos de construtor chamam-se por Java automaticamente quando cria um novo objeto. Como aprendeu no Dia 4, "Trabalhando com Objetos", quando usa new, Java faz três coisas:
Se uma classe não tiver métodos de construtor especiais definidos, ainda terminará com um novo objeto, mas deveria estabelecer as suas variáveis de exemplo ou chamar outros métodos que o objeto tem de inicializar ele mesmo. Todos os exemplos que criou até este ponto comportaram-se como isto. Definindo métodos de construtor nas suas próprias classes, pode estabelecer valores iniciais de variáveis de exemplo, chamar métodos baseados naquelas variáveis ou em outros objetos ou calcular propriedades iniciais do seu objeto. Também pode sobrecarregar construtores, como ia métodos regulares, para criar um objeto que tem propriedades específicas baseadas nos argumentos que dá na expressão de new . Os construtores parecem a métodos muito regulares, com duas diferenças básicas: Por exemplo, a Listagem 7.3 mostra uma classe simples chamada Person. O método de construtor de Person toma dois argumentos: um objeto de cadeia que representa o nome de uma pessoa e um número inteiro da idade da pessoa.
A classe de pessoa tem três métodos: O primeiro é o método de construtor, definido em linhas 5 para 8, que inicializa as duas variáveis de exemplo da classe baseadas nos argumentos a new. A classe de Person também inclui um método chamado printPerson() para que o objeto possa "apresentar-se" e um método de main() para testar cada uma destas coisas. Alguns construtores que escreve podem ser supergrupos de outros construtores definidos na sua classe; isto é, poderiam ter o mesmo comportamento mais um bocado mais. Em vez de duplicar o comportamento idêntico em múltiplos métodos de construtor na sua classe, faz sentido para ser capaz de chamar somente aquele primeiro construtor do interior do corpo do segundo construtor. Java fornece uma sintaxe especial para fazer isto. Para chamar um construtor definido na classe atual, use a palavra-chave de this como se fosse um nome de método, com os argumentos somente depois dele, como isto: Os argumentos a this() são, naturalmente, os argumentos ao construtor. Como métodos regulares, os construtores também podem tomar números variados e tipos de parâmetros, permitindo-lhe criar o seu objeto com exatamente as propriedades que quer que ele tenha, ou para ele para ser capaz de calcular propriedades de tipos diferentes da entrada. Por exemplo, os métodos de buildRect() que definiu na classe de MyRect antes hoje fariam construtores excelentes porque inicializam variáveis de exemplo de um objeto aos valores apropriados. Deste modo, por exemplo, em vez do método de buildRect() original tinha definido (que tomou quatro parâmetros das coordenadas das esquinas), pode criar um construtor em vez disso. A listagem 7.4 mostra uma nova classe, MyRect2, que tem mesmo assim a funcionalidade do MyRect original, exceto com métodos de construtor sobrecarregados em vez do método de buildRect() sobrecarregado. A produção mostrada no fim também é a mesma produção quanto à classe de MyRect prévia; só o código para produzi-lo se modificou.
Quando chama o método de um objeto, Java procura aquela definição de método na classe daquele objeto, e se não encontrar um jogo com a assinatura direita, passa o método convocam a hierarquia de classe até que uma definição se encontre. A herança de método significa que pode usar métodos em subclasses sem ter necessidade de duplicar o código. Contudo, podem haver tempos quando quer um objeto de responder aos mesmos métodos mas ter comportamento diferente quando aquele método se chama. Neste caso, pode ignorar aquele método. A anulação de um método implica a definição de um método em uma subclasse que tem a mesma assinatura que um método em uma superclasse. Então, quando aquele método chama-se, o método na subclasse encontra-se e realiza-se em vez daquela na superclasse. Para ignorar um método, tudo que tem de fazer é criam um método na sua subclasse que tem a mesma assinatura (nome, devolva o tipo e a lista de parâmetro) como um método definido por uma de superclasses da sua classe. Como Java realiza a primeira definição de método encontra que combina com a assinatura, isto efetivamente "esconde" a definição de método original. Aqui está um exemplo simples; a Listagem 7.5 mostra uma classe simples com um método chamado printMe(), que imprime o nome da classe e os valores das suas variáveis de exemplo. A listagem 7.6 mostra uma classe chamada PrintSubClass que é uma subclasse de (extends) PrintClass. A única diferença entre PrintClass e PrintSubClass é que o último tem uma variável de exemplo de z.
No método de main() de PrintSubClass, cria um objeto de PrintSubClass e chama o método de printMe(). Observe que PrintSubClass não define este método, portanto Java o procura em cada uma de superclasses de PrintSubClass - e o encontra, neste caso, em PrintClass. Infelizmente, porque printMe() ainda se define em PrintClass, não imprime a variável de exemplo de z.
Agora, vamos criar uma terceira classe. PrintSubClass2 é quase idêntico a PrintSubClass, mas ignora o método de printMe() para incluir a variável de z. A listagem 7.7 mostra esta classe. Agora quando você instantiate esta classe e chamada o método de printMe(), a versão de printMe() que definiu para esta classe chamam-se em vez daquele na superclasse PrintClass (como pode ver nesta produção):
Normalmente, há duas razões porque quer ignorar um método que uma superclasse já implementou: Já aprendeu sobre o primeiro; ignorando um método e dando àquele método uma nova definição, escondeu a definição de método original. Mas às vezes somente pode querer acrescentar o comportamento à definição original em vez de apagá-lo completamente. Isto é especialmente útil onde termina de duplicar o comportamento tanto no método original como no método que o ignora; sendo capaz de chamar o método original no corpo do método ignoto, pode acrescentar só de que precisa. Para chamar o método original do interior de uma definição de método, use a palavra-chave de super para passar o método convocam a hierarquia: A palavra-chave de super, um tanto como a palavra-chave de this, é um placeholder da superclasse desta classe. Pode usá-lo em qualquer lugar pode usar this, mas referir-se à superclasse em vez de à classe atual. Por exemplo, a Listagem 7.8 mostra dois métodos de printMe() diferentes usados no exemplo prévio. Em vez de duplicar a maioria do comportamento do método da superclasse na subclasse, pode reajustar o método da superclasse para que o comportamento adicional possa acrescentar-se facilmente: Então, na subclasse, quando ignora printMe(), simplesmente pode chamar o método original e logo acrescentar o extra material: Aqui está a produção de chamar printMe() em um exemplo da subclasse:
Como os construtores têm o mesmo nome que a classe atual, não pode ignorar tecnicamente construtores de uma superclasse. Se quer um construtor em uma subclasse com o mesmo número e o tipo de argumentos como na superclasse, terá de definir aquele construtor na sua própria classe. Contudo, quando cria os seus construtores sempre quererá quase chamar construtores da sua superclasse para assegurar-se que as partes herdadas do seu objeto se inicializam de maneira a sua superclasse destina-os para ser. Chamando explicitamente os seus construtores de superclasses deste modo pode criar construtores que efetivamente ignoram ou sobrecarregam construtores da sua superclasse. Para chamar um método regular em uma superclasse, usa a forma super.methodname(arguments). Como com construtores não tem um nome de método para a chamada, tem de usar uma forma diferente: Observe que Java tem uma regra específica do uso de super(): deve ser a muito primeira coisa na sua definição de construtor. Se não chamar super() explicitamente no seu construtor, Java o fará para super() você usando sem argumentos. Semelhante à utilização de this(...) em um construtor, super(...) chama um método de construtor da superclasse imediata com os argumentos apropriados (que pode chamar, à sua vez, o construtor da sua superclasse, e assim por diante). Observe que um construtor com aquela assinatura tem de existir na superclasse para a chamada a super() para trabalhar. O compilador de Java verificará isto quando tentar compilar o arquivo original. Observe que não tem de chamar o construtor na sua superclasse que tem exatamente a mesma assinatura que o construtor na sua classe; só tem de chamar o construtor dos valores dos quais precisa inicializado. De fato, pode criar uma classe que tem construtores com assinaturas inteiramente diferentes de algum dos construtores da superclasse. A listagem 7.9 mostra uma classe chamada NamedPoint, que estende a classe Point do pacote de awt de Java. A classe de Point tem só um construtor, que toma um x e um argumento de y e devolve um objeto de Point. NamedPoint tem uma variável de exemplo adicional (uma cadeia do nome) e define um construtor para inicializar x, y e o nome.
O construtor definiu aqui para NamedPoint (linhas 5 para 8) chama o método de construtor de Point para inicializar variáveis de exemplo de Point (x e y). Embora possa inicializar tão facilmente x e y você mesmo, não pode saber o que outras coisas Point faz para inicializar-se, portanto sempre é uma boa ideia de passar construtores a hierarquia para assegurar-se que tudo se funda corretamente. Os métodos de Finalizer são quase o contrário de métodos de construtor; ao passo que um método de construtor se usa para inicializar um objeto, finalizer métodos chamam-se justo antes de que o objeto reúne-se do lixo e a sua memória reforma-se. O método finalizer denomina-se simplesmente finalize(). A classe de Object define um default finalizer método, que não faz nada. Para criar um método finalizer das suas próprias classes, ignore o método de finalize() usando esta assinatura:
Dentro do corpo de que método de finalize(), inclua qualquer limpeza quer fazer para aquele objeto. Também pode chamar super.finalize() para permitir às superclasses da sua classe finalizar o seu objeto, se necessário (é uma boa ideia de fazer assim somente para assegurar-se que todo o mundo adquire uma possibilidade de tratar com o objeto se precisarem a). Sempre pode chamar o método de finalize() você mesmo em qualquer momento; é somente um método claro como algum outro. Contudo, a chamada de finalize() não provoca um objeto a reunir-se do lixo. Só retirar todas as referências para um objeto fará que ele se marque para a eliminação. Os métodos de Finalizer usam-se melhor para otimizar a remoção de um objeto por exemplo, retirando referências para outros objetos, lançando recursos externos que se adquiriram (por exemplo, arquivos externos), ou para outros comportamentos que podem facilitar para aquele objeto retirar-se. Na maioria dos casos, não precisará de usar finalize() em absoluto. Ver o Dia 21, "Abaixo do Capuz", para mais sobre a coleção de lixo e finalize(). Hoje aprendeu todas as espécies de técnicas de utilização, reutilização, definição e redefinição de métodos. Aprendeu como sobrecarregar um nome de método para que o mesmo método possa ter comportamentos diferentes baseados nos argumentos com os quais se chama. Aprendeu sobre métodos de construtor, que se usam para inicializar um novo objeto quando se cria. Aprendeu sobre a herança de método e como ignorar métodos que se definiram em superclasses de uma classe. Finalmente, aprendeu sobre métodos finalizer, que podem usar-se para limpar depois de um objeto justo antes de que aquele objeto se reúne do lixo e a sua memória reforma-se. As congratulações com o completamento da sua primeira semana de Ensinam-se Java durante 21 Dias! Começando a próxima semana, aplicará tudo que aprendeu nesta semana à escrita de Java applets e ao trabalho com conceitos mais promovidos em reunião de programas Java e trabalho com as bibliotecas de classe de Java padrão.
total interno (número interno arg1, número interno arg2, número interno arg3) {...}
O compilador de Java queixa-se quando tento compilar a classe com estas definições de método. Mas as suas assinaturas são diferentes. O que fiz mal?
Calling buildRect with coordinates 25,25 50,50:
MyRect: <25, 25, 50, 50>
----------
Calling buildRect w/points (10,10), (20,20):
MyRect: <10, 10, 20, 20>
----------
Calling buildRect w/1 point (10,10), width (50) and height (50):
MyRect: <10, 10, 60, 60>
----------
Métodos de construtor
Novo termo
Os métodos de construtor são métodos especiais que se chamam automaticamente por Java para inicializar um novo objeto.
Construtores básicos
`
A listagem 7.3. A classe de Person.
1: class Person {
2: String name;
3: int age;
4:
5: Person(String n, int a) {
6: name = n;
7: age = a;
8: }
9:
10: void printPerson() {
11: System.out.print("Hi, my name is " + name);
12: System.out.println(". I am " + age + " years old.");
13: }
14:
15: public static void main (String args[]) {
16: Person p;
17: p = new Person("Laura", 20);
18: p.printPerson();
19: System.out.println("--------");
20: p = new Person("Tommy", 3);
21: p.printPerson();
22: System.out.println("--------");
23: }
24:}
Hi, my name is Laura. I am 20 years old.
--------
Hi, my name is Tommy. I am 3 years old.
--------
Chamada de outro construtor
this(arg1, arg2, arg3...);
Baldeação de construtores
A listagem 7.4. A classe de MyRect2 (com construtores).
1: import java.awt.Point;
2:
3: class MyRect2 {
4: int x1 = 0;
5: int y1 = 0;
6: int x2 = 0;
7: int y2 = 0;
8:
9: MyRect2(int x1, int y1, int x2, int y2) {
10: this.x1 = x1;
11: this.y1 = y1;
12: this.x2 = x2;
13: this.y2 = y2;
14: }
15:
16: MyRect2(Point topLeft, Point bottomRight) {
17: x1 = topLeft.x;
18: y1 = topLeft.y;
19: x2 = bottomRight.x;
20: y2 = bottomRight.y;
21: }
22:
23: MyRect2(Point topLeft, int w, int h) {
24: x1 = topLeft.x;
25: y1 = topLeft.y;
26: x2 = (x1 + w);
27: y2 = (y1 + h);
28: }
29:
30: void printRect() {
31: System.out.print("MyRect: <" + x1 + ", " + y1);
32: System.out.println(", " + x2 + ", " + y2 + ">");
33: }
34:
35: public static void main(String args[]) {
36: MyRect2 rect;
37:
38: System.out.println("Calling MyRect2 with coordinates 25,25 50,50:");
39: rect = new MyRect2(25, 25, 50,50);
40: rect.printRect();
41: System.out.println("----------");
42:
43: System.out.println("Calling MyRect2 w/points (10,10), (20,20):");
44: rect= new MyRect2(new Point(10,10), new Point(20,20));
45: rect.printRect();
46: System.out.println("----------");
47:
48: System.out.print("Calling MyRect2 w/1 point (10,10)");
49: System.out.println(" width (50) and height (50):");
50: rect = new MyRect2(new Point(10,10), 50, 50);
51: rect.printRect();
52: System.out.println("----------");
53:
54: }
55: }
Calling MyRect2 with coordinates 25,25 50,50:
MyRect: <25, 25, 50, 50>
----------
Calling MyRect2 w/points (10,10), (20,20):
MyRect: <10, 10, 20, 20>
----------
Calling MyRect2 w/1 point (10,10), width (50) and height (50):
MyRect: <10, 10, 60, 60>
----------
Anulação de métodos
Criação de métodos que ignoram métodos existentes
A listagem 7.5. A classe de PrintClass.
1: class PrintClass {
2: int x = 0;
3: int y = 1;
4:
5: void printMe() {
6: System.out.println("x is " + x + ", y is " + y);
7: System.out.println("I am an instance of the class " +
8: this.getClass().getName());
9: }
10: }
A listagem 7.6. A classe de PrintSubClass.
1: class PrintSubClass extends PrintClass {
2: int z = 3;
3:
4: public static void main(String args[]) {
5: PrintSubClass obj = new PrintSubClass();
6: obj.printMe();
7: }
8: }
x is 0, y is 1
I am an instance of the class PrintSubClass
Observar
Há uma característica importante de PrintClass que devo indicar: não tem um método de main(). Não precisa daquele; não é uma aplicação. PrintClass é simplesmente uma classe de serviço da classe de PrintSubClass, que é uma aplicação e por isso tem um método de main(). Só a classe que executa de fato o intérprete de Java em necessidades um método de main().
A listagem 7.7. A classe de PrintSubClass2.
1: class PrintSubClass2 extends PrintClass {
2: int z = 3;
3:
4: void printMe() {
5: System.out.println("x is " + x + ", y is " + y +
6: ", z is " + z);
7: System.out.println("I am an instance of the class " +
8: this.getClass().getName());
9: }
10:
11: public static void main(String args[]) {
12: PrintSubClass2 obj = new PrintSubClass2();
13: obj.printMe();
14: }
15: }
x is 0, y is 1, z is 3
I am an instance of the class PrintSubClass2
Chamar o método original
void myMethod (String a, String b) {
// do stuff here
super.myMethod(a, b);
// maybe do more stuff here
}
A listagem 7.8. Os métodos de printMe().
1: // from PrintClass
2: void printMe() {
3: System.out.println("x is " + x + ", y is " + y);
4: System.out.println("I am an instance of the class" +
5: this.getClass().getName());
6: }
7: }
8:
9: //from PrintSubClass2
10: void printMe() {
11: System.out.println("x is " + x + ", y is " + y + ", z is " + z);
12: System.out.println("I am an instance of the class " +
13: this.getClass().getName());
14: }
// from PrintClass
void printMe() {
System.out.println("I am an instance of the class" +
this.getClass().getName());
System.out.println("x is " + x);
System.out.println("y is " + y);
}
// From PrintSubClass2
void printMe() {
super.printMe();
System.out.println("z is " + z);
}
I am an instance of the class PrintSubClass2
X is 0
Y is 1
Z is 3
Anulação de construtores
super(arg1, arg2, ...);
A listagem 7.9. A classe de NamedPoint.
1: import java.awt.Point;
2: class NamedPoint extends Point {
3: String name;
4:
5: NamedPoint(int x, int y, String name) {
6: super(x,y);
7: this.name = name;
8: }
9: public static void main (String arg[]) {
10: NamedPoint np = new NamedPoint(5, 5, "SmallPoint");
11: System.out.println("x is " + np.x);
12: System.out.println("y is " + np.y);
13: System.out.println("Name is " + np.name);
14: }
15:}
x is 5
y is 5
name is SmallPoint
Métodos de Finalizer
protected void finalize() throws Throwable {
super.finalize();
}
Observar
A parte de Throwable DE throws desta definição de método refere-se aos erros que poderiam ocorrer quando este método se chama. Os erros em Java chamam-se exceções; aprenderá mais sobre eles no Dia 17, "Exceções". Por agora, tudo que tem de fazer é incluem estas palavras-chave na definição de método.
Sumário
Perguntas e Respostas
Criei dois métodos com as seguintes assinaturas:
faça flutuar o total (número interno arg1, número interno arg2, número interno arg3) {...}
A baldeação de método em Java só trabalha se as listas de parâmetro forem diferentes - em número ou em tipo de argumentos. Volte o tipo não é relevante para a baldeação de método. Pense nele - se tinha dois métodos com exatamente a mesma lista de parâmetro, como Java saberia que chamar? Posso sobrecarregar métodos ignotos (isto é, posso criar métodos que têm o mesmo nome que um método herdado, mas uma lista de parâmetro diferente)?
Seguro! Enquanto as listas de parâmetro variam, não importa se definiu um novo nome de método ou aquele que herdou de uma superclasse.