A OO e dividida em três pilares, que são: Encapsulamento, Herança, e Polimorfismo, Nesse tutorial vamos falar um pouco sobre encapsulamento e sobre seus principais "componentes", que são :
Classe
Atributo
Método
Objeto
O encapsulamento e a "arte" de proteger seus atributos do acesso direto, permitindo a integridade deles, pois com o encapsulamento você pode fazer alguma verificações antes de alterar o valor de um atributo.
Ex.: você pode verificar se a idade de uma pessoa e um valor positivo ao fazer um cadastro , já que ninguem pode ter -10 anos de idade. Mas pra ser cincero, isso e uma boa prática de programação, que você vai fazer e pronto, sacou?
Sendo assim seus atributos sempre serão privados, e terão métodos públicos para acessar e modificar os mesmos.
exemplo:
class Pessoa{
private String Name;
private int Idade;
/**
Este será o método usado para atribuir/modificar o nome da pessoa
*/
public void setName(String n) {
Name = n;
}
/**
Este será o método usado para atribuito/modificar a idade da pessoa
Veja agora posso verificar o valor da idade, e mostrar uma menssagem de erro caso a idade
Seja inválida.
*/
public void setName(int i) {
if( i>0)//Verifico se a idade e positiva
Idade=i; //Se for eu altero seu valor
else
System.out.println( "Idade inválida");//Se não for eu mostro essa menssagem
}
}
O encapsulamento e a "arte" de proteger seus atributos do acesso direto, permitindo a integridade deles, pois com o encapsulamento você pode fazer alguma verificações antes de alterar o valor de um atributo.
Ex.: você pode verificar se a idade de uma pessoa e um valor positivo ao fazer um cadastro , já que ninguem pode ter -10 anos de idade. Mas pra ser cincero, isso e uma boa prática de programação, que você vai fazer e pronto, sacou?
Sendo assim seus atributos sempre serão privados, e terão métodos públicos para acessar e modificar os mesmos.
exemplo:
class Pessoa{
private String Name;
private int Idade;
/**
Este será o método usado para atribuir/modificar o nome da pessoa
*/
public void setName(String n) {
Name = n;
}
/**
Este será o método usado para atribuito/modificar a idade da pessoa
Veja agora posso verificar o valor da idade, e mostrar uma menssagem de erro caso a idade
Seja inválida.
*/
public void setName(int i) {
if( i>0)//Verifico se a idade e positiva
Idade=i; //Se for eu altero seu valor
else
System.out.println( "Idade inválida");//Se não for eu mostro essa menssagem
}
}
Uma breve descrição sobre os componentes utilizados no encapsulamento:
Classe: No português bem dizido, e um monte de código, criado de forma organizada , que depois vai "virar" um objeto, classe e onde ficam os métodos e atributos.
Atributo e o que conhecemos na programação estruturada de variáves(ou mais ou menos isso), e onde armazenamos valores na mémoria, são as caracteristicas do objeto, as informações que eu preciso sobre o item que eu vou manipular, ex.: Para fazer o cadastro de um paciente, eu vou precisar dos atributos Nome, idade, Endereço, Plano de saúde(e bom que você tenha um, se não corre um grande risco de morrer antes de atendido em um hospital público) etc..
Métodos e onde fazemos os processamento, onde ficam os comportamentos da classe, eu posso ter um atributo da classe Salario chamado salario, e INSS, e preciso de um metódo para fazer o calculo de quando vai ser o valor pago de INSS.
Objeto e uma ponte entre duas classes, uma meio de acessar a manipular outra classe, e um controle remoto onde eu posso acessar e configurar o conteúdo de outra classe.
Abaixo um exemplo da classe Salario com os INSS , e os calculo do mesmo.
Abaixo um exemplo da classe Salario com os INSS , e os calculo do mesmo.
class Salario{//declaração de classe
private double Salario;//atributo
private double INSS = 0.9;
public double CalcularINSS() {//metódo
double valorDesconto=0;
valorDesconto= Salario*INSS ;
return valorDesconto;
}
}
Salario MeuObjeto = new Salario();//Objeto da classe Salario
Esse exemplo e só pra ter uma visão do que são cada um desses itens.
Os atributos e métodos são acessivéis de acordo com o Modificador de acesso(dã), que são:
- public - Acessível dentro de fora da classe.
- private - Acessível apenas na mesma classe.
- protected - Acessível na classe a nas sua filhas(veremos isso logo).
- default - Semelhante a protected mas so e acesivél dentro do mesmo pacote.
Abordaremos esse assunto melhor na prática onde tudo ficara mais claro.
Nota.: Pacote são pastas, e uma forma de organizar do meu código, se você for criar um sistema para um banco não vai querer as suas 500.000 classes na mesma pasta, então são criados pacotes(packages) para separar as classes de acordo com a finalidade de cada uma delas.
Na hora de programar, praticamente sempre os atributos são privados, e os métodos são publicos, mas como disse quase sempre, pode haver ocasiões em que seus metódos vão ser privados e seus atributos publico(o último e mais raro).
No que diz respeito a atributos eles também podem ser final, ou seja , depois atribuido, seu valor não pode ser mais modificado. No exemplo acima, colocamos o valor do INSS como 0.9, mas sabemos que essa taxa varia de acordo com o salário, nesse caso eu poderia criar um metodo para identificar a taxa do INSS de acordo com o salario. Porém se o atributo fosse final, ele seria 0.9 e pronto, nada no mundo vai modificar o valor desse atributo em tempo de execução(quando você estiver usando o programa).
Exemplo de um atributo final;
Exemplo de um atributo final;
public final double PI = 0.37;
Criando objetos.
Objeto e um cópia , uma "imagem", ou tecnicamente uma referência da classes, e um controle remoto de uma classe, e é usados para manipular os metódos e atributos da classe.
class Salario{
private double salarioBruto;
public void setValor(double sb){
salarioBruto =sv;
}
public double getSalarioBruto (){
return salarioBruto;
}
}
Para criar um objeto sempre usando a seguinte sintaxe:
NomeDaClase identificacao = new NomeDaClase()
Para a classe salario poderíamos criar um objeto da seguinte forma:
Salario s = new Salario();
Para adicionar uma valor ao salario bruto poderíamos usar:
s.setSalarioBruto(622);
Se eu quiser mostrar o salário na tela pro exemplo, eu poderia usar a seguinte sintaxe:
System.out.println( s.getSalarioBruto() );
Para colocar o salario bruto e uma variável poderíamos fazer:
double valor = s.getSalarioBruto() ;
double valor = s.getSalarioBruto() ;
Construtores
Construtores são métodos, só que com características especiais, que são:
- Não possuem tipo de retorno
- É o primeiro método ao iniciar na classe
O construtor e o método que é chamado quando cria o objeto, ou seja quando você digita new NomeDaClasse(), e por isso ele e o primeiro a ser executado, pois e executando na criação do objeto.
Geralmente utilizamos contrutores para inicializar valores, e comportamentos, por exemplo, quando criamos uma classe de conexão com banco de dados, não dá pra acessar o banco, sem antes chamar o método de conexão, então , e interessante chamar esse método dentro do construtor, assim ao criar o objeto, você já estará conectanto no banco de dados, a sintaxe do construtor e bastante simples:
public NomedaClasse() {
}
Na classe Pessoa o contrutor seria:
public Pessoa() {
}
Fácil né?
Eu posso passar parâmetros a um construtor do mesmo jeito que passo para um método, exemplo:
public Pessoal(String name ){
this.Name=name;
}
Mas atenção - Ao sobrecarregar o construtor(Criar um com parâmetros ), o construtor sem parâmetros deixa de existir, ou seja se você tem um contrutor:
public Pessoa( String nome)
Você não pode criar o objeto Pessoa people = new Pessoa(), pois esse construtor chamado não possui parâmetros, você e obrigado a criar o objeto assim: Pessoa people = new Pessoa("Nome da pessoa" ).
Sempre que você precisar de um construtor com parâmetros , e boa prática de programação criar um construtor padrão. ex:
//Mesmo que vc tenha esse construtor
public Pessoa(String nome) {
//seu código
}
//Sempre crie um assim, mesmo que a principio não vá usar.
public Pessoa() {
}
Atributos estáticos X não estáticos.
Atributos estáticos, são aqueles que ficam na memória durante toda a execução da aplicação, e só possuem uma referência na memória, já os objetos não estáticos, pertencem a instância de um objeto, possuem um valor para cada novo objeto, e "são deletados" quando o objeto não possui mas referência na classe.
ex.:
class Funcionario{
private static String departamento;
private String Nome;
public Funcionario(String d, String n) {
departamento=D;
Nome=n;
}
}
Se criássemos os seguintes objetos:
Funcionario Ana = new Funcionario("rh","Ana");
Funcionario Jheybi = new Funcionario("Moda","Jheybi");
Funcionario Mariana = new Funcionario("Vendas","Mariana");
Se imprimirmos esse esses atributos na tela, teremos a seguinte saída:
Código:
...printl (" DPTO: "+Ana.getDepartamento()+", Nome: "+Ana.getNome() )
...printl (" DPTO: "+Jheybi .getDepartamento()+", Nome: "+Jheybi .getNome() )
...printl (" DPTO: "+Mariana .getDepartamento()+", Nome: "+Mariana .getNome() )
Saida:
DPTO: Vendas, Nome:Ana
DPTO: Vendas, Nome:Jheybi
DPTO: Vendas, Nome:Mariana
O atributo não estático nome, cria um novo valor na memória para cada cada instância da classe funcioario ( um para cada new Funcionario() ), já o departamento que e estático, só possui um valor na memória, por isso ele apenas substitui o valor anterior, pelo novo valor adicionado no construtor.
Ou seja, só use atributos estáticos , em valores que precisem estar na memória durante toda execução do aplicativo.
Obs.: O uso demasiado de objetos estáticos aumentam o consumo de memória, pois como já foi falado, estes ficam na memória durante toda a execução do programa, mesmo se não estiverem sendo usados.
Métodos estáticos.
Algumas vezes temos que fazer algumas coisas que não vão alterar o estados dos objetos, nesses casos eu posso criar um métodos estáticos, métodos estáticos são métodos que não precisam de um objeto para serem acessados, eles são acessados diretamente pelo nome da classe. Ex.: Suponhamos que estou fazendo um sistema que vai fazer muito cálculos com formas geométricas, então posso criar uma classe e colocar todos os métodos que faram cálculos, veja como ficaria um método estático:
public class UtilGeometrics{
public static
double AreaDoRetangulo(double base,
double altura ){
return (base*altura)/2;
}
}
A área to retângulo e calculada sempre da mesma forma, então eu não preciso de uma novo objeto na memória para fazer esse cálculo, basta eu informar os valores que o método calcula e me retorna o resultado. Se a classe não fosse estática teriamos que criar um objeto, e depois chamar o método:
UtilGeometrics UG = new UtilGeometrics()
double Area = UG.AreaDoRetangulo(25,89);
Com o método estático, podemos apenas fazer:
double Area = UtilGeometrics.AreaDoRetangulo(25,89);
Muito mais prático.
Metódos sem retorno( void) e com retorno.
Alguns métodos vão apenas receber um valor, ou inicializar um atributo, sendo assim não precisam "retornar nada" já outros, tem que lhe fornecer o valor de um cálculo, ou lhe fornecer o resultado de uma consulta no banco de dados etc...
Metódos void são aqueles que só fazem um processamento e pronto, não vão nós dar nenhum resultado ex.:
public class Funcionario{
private double Salario;
private int Idade;
public void setIdade(int i) {
if(i<0) {
System.out.println("Idade inválida");
System.exit(0);
}
else
this.idade=i;
}
public double calcTaxaINSS() {
return Salario*0.9;
}
}
No código acima, o método setIdade recebe um valor, verifica se o valor menor que zero, se for ele mostra uma menssagem, e encerra o aplicativo, caso contrário, ele atribui o valor passado, ao atributo Idade.
Já o calcTaxaINSS serve para eu saber quanto vai ser desconto de INSS, ou seja ele faz o cálculo e me dá o resultado, passa o resultado para outra classe, e eu posso manipular esse resultado de outra forma, como mostrar na tela, ou salvar em um banco de dados etc. Ou seja, quando eu quiser passar um valor entre duas classes , seja texto, ou número, eu especifico o tipo que deve ser retornado na assinatura do método* e uso a palavra return para enviar o valor, caso eu não precise passar o valor de uma classe pra outra eu ponho a palavra void.
Obs.: Se você não colocar a palavra void, você e obrigado a especificar um retorno(colocar a palavra return e o valor returnado) de acordo com o tipo informado, se não seu código nem vai compilar.
* - Assinatura do método e toda a primera linha de declaração do método ex.:
public void getNome()
public static int calcAreaRetangulo()
public double calcTaxaINCC()
Passagem de parâmetros.
Passar parâmetros, e informar ao compilado que você vai passar um valor para método utilizar. Ex.
public void calcAreaTrangulo(int Param, int Param2 )
As palavras entre os "( )" sao os parâmetros, são valores que você deve passar obrigatoriamente quando for chamar o método, caso contrário o compilador irá gerar um erro. Neste caso estamos passando dois valores, então ao chamar o método teremos que fazer:
calcAreaTrangulo(90,78 );
E não poderiamos fazer:
calcAreaTrangulo();
calcAreaTrangulo(90);
calcAreaTrangulo(90,23,89);
Ou seja , se você disse que quer dois parâmetros, você vai ter dois, somente dois, nem mais nem menos.
Porém existe um recurso chamado varArgs que dá uma flexibilidade maior ao passar parâmetros, eu digo apenas o tipo e o nome, mas posso colocar quando eu quiser, ou nenhum, ex.:
public void somaValores(int ... Valor )
Ao utilizar o "..." , o compilador permite que você passe quantos valores quiser, Ex.:
somaValores(56,90,52,123,456);
ou nenhum:
somaValores() //(Claro que isso não faz sentido né, mas você pode fazer isso ...)
Mas existem algumas regras para usar varArgs:
Você só pode ter um por método:
public void saveDB(String ...Nome, String... Endereco )
//Inválido, você não pode usar dois " ..." no mesmo método
Caso tenha mais de um parâmetro, o varArgs tem que ser o último, ex.:
public void ValidarEntradas(String ... campos, String regra, int valor )
//Inválido, o varArgs ("...") tem que ser o último parâmetro
Bom galhera, essa foi a primeira parte deste tutor sobre OO, espero que tenha ficado claro, e quem ainda tiver alguma dúvida e só comentar ai que eu respondo..
vlw
T+
Comentários
Postar um comentário