Como já vimos em aulas anteriores, e como qualquer linguagem para programação orientada a objetos, a linguagem Java permite que o programador crie suas próprias classes em seus programas, além de reutilizar uma grande quantidade de classes já prontas, chamadas de API Java (Application Program Interface).

Também como já vimos, um programa Java é uma coleção de classes em que uma delas tem um método “main”. Quando o programa é executado, instâncias das classes são criadas na memória. Essas instâncias são na verdade os objetos dessas tais classes, que interagem entre si enviando mensagens uns aos outros. Por enviar mensagem de A para B devemos entender que o objeto A aciona um método do objetos B.

Classes são portanto as bases para criação dos programas chamados de “orientados a objetos”.

Um classe tem normalmente a seguinte forma geral:

class <nome da classe> {
<atributos>;
<cosntrutores>;
<métodos de acesso>;
<métodos de serviço>
}
O atributos são dados que caracterizam os objetos da classe. Cada objeto quando criado terá sua própria cópia dos atributos definidos na classe. Os atributos podem ser dados de tipos comuns como int, double, boolean etc, ou até mesmo objetos de outras classes como String (que é da API), ou mesmo de classes criadas pelo programador.

Os atributos têm uma especificação de visibilidade que controla o acesso a eles por quem usa os objetos da classe. Atributos com visibilidade public têm acesso liberado, com visibilidade private têm acesso permitido apenas dentro da classe. Há ainda outros tipos de visibilidade que veremos depois.

Um exemplo de inicio de definição de uma classe:

class Aluno {
private int rgm;
private String Nome;
…
}
Os atributos podem ainda ser declarados como estáticos, isto é, uma única cópia desses atributos é criada na memória quando o primeiro objeto da classe for criado, e esta única cópia compartilhada por todos os demais objetos que vierem a ser criados. Atributos estáticos são inicializados na sua definição.

Exemplo, neste caso todos os alunos seriam da mesma matéria:

class Aluno {
private int rgm;
private String nome;
private static String materia = “fisica”;
…
}
Além dos atributos, uma classe tem métodos, geralmente públicos, que executam as operações válidas para os objetos da classes. Há um tipo especial de método chamado “construtor”, que tem o mesmo nome que a classe, e é acionado implicitamente quando criamos um objeto. Uma classe pode ter mais que um construtor, bastando que eles tenham diferenças no tipo e/ou número de parâmetros que recebem de quem cria o objeto.

Exemplo:

class Aluno {
// atributos
private int rgm;
private String nome;
private static String materia = “matematica”;
private double p1, p2, p3, p4;
// construtores, um com dois parametros
// e outro com tres
public Aluno(int r, String n) {
rgm = r;
nome = n;
}
public Aluno(int r, String n, String m) {
rgm = r;
nome = n;
materia = m;
}
}

Quando criamos um objeto devemos fazer duas coisas, primeiro definir uma “referência” para ele, isto é, um “nome“ como o qual o objeto será referenciado no programa. Depois devemos de fato criar o objeto na memória acionando um construtor da classe. O sistema saberá qual construtor acionar pelos parâmetros passados.


Exemplo, a criação do objeto b também muda a matéria do objeto a, uma vez que ambos compartilham o atributo estático.

Aluno a;
a = new Aluno(123, “Ana Maria”);

Aluno b = new Aluno(456, “Joao Carlos”, “fisica”);
Outro tipo de método muito comum são os métodos de acesso, isto é, métodos públicos que permitem o acesso aos atributos privados. Esta é uma forma eficiente de controlar o que se pode e não pode fazer com os atributos de objetos de uma classe. Esses métodos são normalmente usados para colocar (set) um valor num atributo, ou para ler e devolver o valor que está num atributo (get).

Os métodos do tipo “set” não retornam valores (tipos de resultado void) e recebem como parâmetros os valores a serem colocados nos atributos, enquanto os métodos do tipo “get” não recebem parâmetros e têm o mesmo tipo de retorno que o atributo.

Exemplo:

class Aluno {
// atributos
private int rgm;
private String nome;
private static String materia = “matematica”;
private double p1, p2, p3, p4;
// construtores, um com dois parametros
// e outro com tres
public Aluno(int r, String n) {
rgm = r;
nome = n;
}
public Aluno(int r, String n, String m) {
rgm = r;
nome = n;
materia = m;
}
// acesso set
public void setRgm(int r) { rgm = r; }
public void setNome(String n) { nome = n; }
public void setMateria(String m) { materia = m; }
public void setP1(double p) { p1 = p; }
public void setP2(double p) { p2 = p; }
public void setP3(double p) { p3 = p; }
public void setP4(double p) { p4 = p; }
// acesso get
public int getRgm() { return rgm; }
public String getNome() { return nome; }
public String getMateria() { return materia; }
public double getP1() { return p1; };
public double getP2() { return p2; };
public double getP3() { return p3; };
public double getP4() { return p4; };

}
Finalmente, as classes têm “métodos de serviço” que servem para fazer alguma coisa específica referente à aplicação dos objetos da classe.

Exemplo:

class Aluno {
// atributos
private int rgm;
private String nome;
private static String materia = \"matematica\";
private double p1, p2, p3, p4;
// construtores, um com dois parametros
// e outro com tres
public Aluno(int r, String n) {
rgm = r;
nome = n;
}
public Aluno(int r, String n, String m) {
rgm = r;
nome = n;
materia = m;
}
// acesso set
public void setRgm(int r) { rgm = r; }
public void setNome(String n) { nome = n; }
public void setMateria(String m) { materia = m; }
public void setP1(double p) { p1 = p; }
public void setP2(double p) { p2 = p; }
public void setP3(double p) { p3 = p; }
public void setP4(double p) { p4 = p; }
// acesso get
public int getRgm() { return rgm; }
public String getNome() { return nome; }
public String getMateria() { return materia; }
public double getP1() { return p1; }
public double getP2() { return p2; }
public double getP3() { return p3; }
public double getP4() { return p4; }
// servico - imprime
public void show() {
System.out.println(\"rgm:\" + rgm +
\" nome:\"+nome +
\" materia:\"+materia +
\" p1=\"+p1 +
\" p2=\"+p2 +
\" p3=\"+p3 +
\" p4=\"+p4 +
\" media=\"+calculaMedia()
);
}
// servico – media aritmetica
public double calculaMedia() {
double m;
m = (p1 + p2 + p3 + p4) / 4;
return m;
}
}
Observe que o método show() aciona outro método da mesma classe calculaMedia().

Um outro recurso comum é a definição de outras formas para um mesmo método na própria classe, o que se chama de “sobrecarga” desse método.

Por exemplo, podemos definir uma nova forma para o método calculaMedia. Usaremos o mesmo nome e tipo de retorno, mas temos que diferenciar nos parâmetros, enquanto o atual calcula média aritmética, o novo fará média ponderada e receberá os quatro pesos como parâmetros inteiros.

Abaixo vemos os dois métodos escritos:

// servico – media aritmetica
public double calculaMedia() {
double m;
m = (p1 + p2 + p3 + p4) / 4;
return m;
}
// servico - media ponderada
public double calculaMedia(int ps1, int ps2,
int ps3, int ps4) {
double m;
m = (p1*ps1+p2*ps2+p3*ps3+p4*ps4)/(p1+ps2+ps3+ps4);
return m;
}


até a próxima ... valew