/*
* Aluno.java
* Autores: Jorge e Andreia - DI-UFPE - 8/1/96
*/
package academico;
import java.util.Dictionary;
import java.io.*;
abstract class Aluno extends Pessoa {
..
}
class Matricula {
..
}
interface Armazenavel {
boolean grave(File arquivo, Object objeto);
Object leia(File arquivo);
}
// Comentario ate o final da linha /* Comentario estilo c */ /** Comentario documentavel em, HTML */
int a; byte d; float x, y; boolean fui; d = 60; a = d * d; x = a / 360; fui = true; if (fui) y = x; else y = x * x; System.out.println(y); /* Qual o valor impresso ? */
int anos[] = new int[3];
anos[0] = 1996;
anos[1] = 1997; anos[2] = 1998; anos[3] = 1999; /* Erro em tempo de execucao */
int matriz[][] = new int[4][3]; int arrayDeArrays[][] = new int[2][];
System.out.println(anos.length); System.out.println(matriz.length); System.out.println(matriz[0].length); System.out.println(arrayDeArrays[0].length); /* O que Ocorre ? */
Classes
Em Java, cada classe cria um novo tipo. O formato geral de uma
declaração de classe é o seguinte:
[modificadores] class NomeDaClasse
extends NomeDaSuperClasse
implements Interface{, Interface}* {
Corpo
}
Por exemplo:
public class AlunoIC
extends AlunoGraduacao
implements Remuneravel {
String projeto;
Professor orientador;
private int diasPesquisa;
AlunoIC() {
..
}
..
public void diasTrabalhados(int dias) {
..
};
..
}
Métodos definem as mensagens às quais os objetos desta classe respondem. Métodos podem ser declarados em classes e interfaces, mas só podem ser implementados (ter corpo) em classes. O formato geral de uma declaração de método é como se vê abaixo:
[modificadores] TipoDeRetorno nomeDoMetodo (Parametros) {
Corpo
}
Exemplos:
public int diasTrabalhados() {
return diasPesquisa;
}
public void diasTrabalhados(int dias) {
diasPesquisa = dias;
}
Todas as variáveis declaradas fora do escopo de um método e não marcadas como estáticas são variáveis de instância. Variáveis de instância podem ter modificadores e ser inicializadas.
public class AlunoIC ... {
String projeto;
Professor orientador;
private int valorBolsa = 0;
..
}
Construtores são métodos especiais providos para criação de objetos. Métodos construtores tem o mesmo nome da classe e podem ser sobrecarregados variando-se o número e tipo dos parâmetros fornecidos quando de sua chamada, por exemplo:
public class Curso {
String nome;
int creditosParaConclusao;
..
Curso() {
nome = "indefinido";
creditosParaConclusao = 0;
..
}
Curso(String nomeCurso, int creditosCurso) {
nome = nomeCurso;
creditosParaConclusao = creditosCurso;
..
}
..
public static void teste() {
Curso curso1 = new Curso();
Curso curso2 = new Curso("M.Sc. Informatica",36);
System.out.println(curso1.nome);
System.out.println(curso2.nome);
}
}
Curso(String nome, int creditos) {
this.nome = nome;
this.creditosParaConclusao = creditos;
..
}
As diferenças entre as duas declarações (acima) do construtor Curso(String, int) são apenas sintáticas. No primeiro caso tivemos que dar nomes
aos parâmetros formais (nomeCurso e creditosCurso) que fossem diferentes
das variáveis de instância (nome e creditos). No segundo caso, utilizando
a variável this podemos dar nomes iguais aos parâmetros
e variáveis de instância, fazendo uso do qualificador this. para
eliminar ambiguidades.A variável super tambem é uma referência para o próprio objeto, com a diferença que o tipo da referência é o tipo da superclasse. Existem diferenças no uso de super em métodos construtores e métodos não-construtores, isto só ficará claro com maior experiência. Um exemplo de uso (em construtores) pode clarear seu significado:
class Pessoa {
String nome;
String endereco;
..
Pessoa (String nome, String endereco) {
this.nome = nome;
this.endereco = endereco;
}
}
class Aluno extends Pessoa {
Curso curso;
int creditosPagos;
..
Aluno (String nome, String endereco, Curso curso) {
super(nome,endereco);
this.curso = curso;
creditosPagos = 0;
}
}
Variáveis e métodos modificados com static se aplicam à classe propriamente dita e não ao objeto. Por exemplo:
public class Sistema {
static SetorPagamento setorPagamento = new SetorPagamento();
static SetorEventos setorEventos = new SetorEventos();
static Departamento departamentos = new Departamento("Informatica");
static Curso cursos = new Curso("Graduacao",100);
public static void main (String args[]) {
..
}
..
}
Interfaces
Interfaces especificam uma coleção de métodos sem implementar seus corpos.
Interfaces provêem encapsulamento de protocolos de métodos sem
restringir sua implementação a uma linha de herança.
Quando uma classe implementa uma interface ela deve geralmente implementar os corpos de todos os métodos descritos na interface.
Interfaces permitem o uso mais amplo de polimorfismo sem basear-se em herança múltipla. Por exemplo:
interface Remuneravel {
int remuneracao();
int diasTrabalhados();
}
class SetorPagamento {
..
float calculaPag(Remuneravel feliz) {
float pagto;
pagto = feliz.diasTrabalhados() *
(feliz.remuneracao() / 30);
..
return pagto;
};
..
}
public class Professor
extends Pessoa
implements Remuneravel{
..
private int salarioMensal;
private int diasNoMes;
..
public int remuneracao() {
return salarioMensal;
};
public int diasTrabalhados(){
return diasNoMes;
};
..
}
public class AlunoIC
extends AlunoGraduacao
implements Remuneravel {
..
private int valorBolsa;
private int diasPesquisa;
..
public int remuneracao() {
return valorBolsa;
};
public int diasTrabalhados() {
return diasPesquisa;
};
..
}
Leia o documento The Java Language Specification, versão beta, páginas 38 a 43.
Jorge Fernandes, jhcf@di.ufpe.br