Tipo de acesso
Acesso público – public
Qualquer objeto que interaja com a classe pode ter acesso aos seus elementos públicos.
Acesso padrão – default ou package*
Somente a própria classe, suas subclasses e as classes no mesmo
pacote terão acesso a esses elementos.
*Não há palavra chave - aplicado na ausência de um modificador.
Acesso protegido – protected
Somente a própria classe e suas subclasses podem acessar estes
elementos.
Acesso particular – private
Acessados apenas pela própria classe que os define.
Modificador de acesso
Atributos estáticos (static)
Quando há um atributo estático em uma classe, ele será único para todos os objetos
instanciados.
Podem ser acessados diretamente a partir da classe
Não é necessário criar uma instância da classe
Métodos estáticos
Quando há um método estático em uma classe, ele deve ser
acessado diretamente na classe e não nas suas instâncias.
Realizam tarefas que não dependem das características
específicas de cada objeto
Utilizam somente as informações contidas em seus próprios
parâmetros e informações contidas em atributos estáticos
Pode ser invocado a partir da própria classe, sem a necessidade
de instanciá-la
Atributos finais (final)
Quando o modificador final é utilizado em atributos, significa que
somente uma atribuição poderá ser feita ao atributo, podendo ser
feita na declaração ou no construtor.
Em outras palavras, quando queremos declarar um atributo
constante devemos utilizar o modificador final
Métodos finais
Podemos utilizar o modificador final na declaração de um
método para que este não possa ser sobrescrito em classes filhas.
Classes finais
O modificador final pode ser utilizado na declaração de classes,
indicando que não poderá ser estendida por outra, ou seja, não
poderá ser herdada.
Agregação / Composição
Uma nova classe estende uma classe base incluindo uma instância da classe base como
atributo na nova classe.
A nova classe é composta de campos específicos e de uma ou mais instâncias da classe base.
As classes originais ficam, assim, contidas na nova classe
Métodos correspondentes são criados na nova classe para viabilizar o uso dos métodos da
classe base, delegando, assim, a execução desses métodos.
Quando uma classe possui um atributo que é um objeto
de outra classe, chamamos de ‘Agregação’
Quando a parte só existe se o todo existir, chamamos
de ‘Composição’
Herança
Superclasse e Subclasse
Classes abstratas – podem servir como superclasses para a
criação de subclasses (ser progenitora), mas não podem ser
instanciadas.
Se for necessário um objeto com as características exatas, demanda herança pobre – com
criação de subclasse apenas para instanciar objetos com suas características
Métodos abstratos – declarados, porém não implementados
na superclasse (como no caso das interfaces)
Classes finais – não podem ser herdadas, ou seja, não
podem ser superclasses para nenhuma outra classe
Métodos finais – não podem ser sobrescritos nas subclasses
Se a superclasse tem atributos privados, então somente
poderão ser acessados por métodos da superclasse.
A herança permite que os métodos públicos da
superclasse sejam usados na subclasse para acessar os
atributos da superclasse.
Os métodos próprios da subclasse, porém, não podem
acessar diretamente os atributos privados da
superclasse.
Construtores da classe pai são chamados simplesmente
pela palavra super seguida dos argumentos.
Métodos são chamados pela palavra super seguida de
um ponto e do nome do método (ex: [Link]()).
Construtores de superclasses só podem ser chamados
de dentro de construtores de subclasses e na primeira
linha de código do construtor da subclasse.
Somente métodos e construtores da superclasse
imediata podem ser chamados usando super.
Não existem construções [Link]
Polimorfismo
Sobrecarga = Métodos diferentes podem ter o mesmo nome, desde
que tenham número ou tipo(s) de parâmetros diferentes
Sobreposição = É a capacidade de redeclarar em uma classe herdeira
métodos de uma classe ancestral com a mesma
assinatura, porém com funcionalidade diferente.
Geralmente com tarefas adicionais nas classes herdeiras
Métodos podem ser sobrepostos com diferentes modificadores de acesso
Os métodos sobrepostos devem ter modificadores menos restritivos
Ex: superclasse – public/ subclasse - private
Métodos estáticos (static) e finais (final) não podem ser
sobrepostos
Qualquer método da classe herdeira pode chamar qualquer método da classe ancestral
declarado como
public, protected ou sem modificador
Mensagem entre classes
package primeirojava_5bcc;
import static [Link];
import [Link];
public class Pessoa{
//Atributos
private String nome;
private int diaNasc, mesNasc, anoNasc;
private String cpf;
//Métodos get e set
public String getNome() {
return nome;
}
public void setNome(String novoNome) {
nome = novoNome;
}
public String getDataNasc(){
return (diaNasc<10? "0": "") + diaNasc + "/" +
(mesNasc<10? "0": "") + mesNasc + "/" +
anoNasc;
}
public void setDataNasc(int dn, int mn, int an){
diaNasc = dn;
mesNasc = mn;
anoNasc = an;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
[Link] = cpf;
}
//Métodos auxiliares
private int calculaIdade(){
int id, da, ma, aa;
Calendar hoje = [Link]();
da = [Link](Calendar.DAY_OF_MONTH);
ma = [Link]([Link] + 1);
aa = [Link]([Link]);
id = aa - anoNasc;
if (ma < mesNasc) id--;
else if((ma == mesNasc) && (da < diaNasc)) id--;
return id;
}
private int calculaIdade2(){
int id, da, aa, dn;
Calendar data = [Link]();
da = [Link](Calendar.DAY_OF_YEAR);
aa = [Link]([Link]);
[Link](anoNasc, mesNasc-1, diaNasc);
dn = [Link](Calendar.DAY_OF_YEAR);
id = aa - anoNasc;
if(da > dn) id--;
return id;
}
public int getIdade(){
return calculaIdade();
}
private static boolean algumNaoNumerico(String cpf){
String digitos = "0123456789";
for(int i=0; i<[Link](); i++)
if([Link]([Link](i)) == -1)
return true;
return false;
}
private static boolean digitosIguais(String cpf){
char[] charCpf = [Link]();
for(int i = 1; i < [Link](); i++)
if(charCpf[i] != charCpf[0])
return false;
return true;
}
public static int validaCpf(String cpf){
int i;
int soma = 0;
int resto = 0;
int digitoGerado1, digitoGerado2;
char[] charCpf;
if([Link]() != 11) return 1;
else if(algumNaoNumerico(cpf)) return 2;
else if(digitosIguais(cpf)) return 3;
else{
charCpf = [Link]();
//Gerando o primeiro dígito verificador
for(i = 0; i < [Link]()-2; i++)
soma += digit(charCpf[i], 10)*(10-i);
resto = soma%11;
if(resto<2) digitoGerado1 = 0;
else digitoGerado1 = 11 - resto;
//Gerando o segundo dígito verificador;
soma = 0;
for(i = 0; i < [Link]()-2; i++)
soma += digit(charCpf[i], 10) * (11-i);
soma += digitoGerado1*2;
resto = soma%11;
if(resto<2) digitoGerado2 = 0;
else digitoGerado2 = 11 - resto;
//Verificando se os dígitos gerados batem
if((digit(charCpf[9], 10) != digitoGerado1) ||
(digit(charCpf[10], 10) != digitoGerado2))
return 4;
}//Fim do else checagem dos dígitos verificadores
return 0;
} //Fim validaCpf
} //Fim classe Pessoa
package primeirojava_5bcc;
import [Link];
public class PrimeiroJava_5BCC {
public static void main(String[] args) {
[Link](null,
"Hello World.\nBem vindo ao meu primeiro programa Java.");
[Link]("Hello World.");
[Link]("Este eh ");
[Link]("o primeiro codigo no Netbeans");
Pessoa p = new Pessoa();
//[Link](null, [Link]);
[Link]([Link]("Digite seu nome."));
int dNasc, mNasc, aNasc;
dNasc = [Link](
[Link]("Dia no nascimento (dd)"));
mNasc = [Link](
[Link]("Mês no nascimento (mm)"));
do{
aNasc = [Link](
[Link]("Ano no nascimento (aaaa)"));
if(aNasc < 1000)
[Link](null, "Ano inválido!\n"
+ "Digite os 4 dígitos do ano.");
}while(aNasc<1000);
[Link](dNasc, mNasc, aNasc);
[Link](null, "Cadastro efetivado: " +
[Link]() + " - " +
[Link]());
} //Fim main
} //Fim classe PrimeiroJava