Pesquisar neste blog

sexta-feira, 29 de junho de 2012

O que é Herança em Java?


O conceito de encapsular estrutura e comportamento em um tipo não é exclusivo da orientação a objetos; particularmente, a programação por tipos abstratos de dados segue esse mesmo conceito. O que torna a orientação a objetos única é o conceito de herança.

Formas de herança

Há várias formas de relacionamentos em herança:
  1. Extensão: subclasse estende a superclasse, acrescentando novos membros (atributos e/ou métodos). A superclasse permanece inalterada, motivo pelo qual este tipo de relacionamento é normalmente referenciado como herança estrita.
  2. Especificação: a superclasse especifica o que uma subclasse deve oferecer, mas não implementa nenhuma funcionalidade. Diz-se que apenas a interface (conjunto de especificação dos métodos públicos) da superclasse é herdada pela subclasse.
  3. Combinação de extensão e especificação: a subclasse herda a interface e uma implementação padrão de (pelo menos alguns de) métodos da superclasse. A subclasse pode então redefinir métodos para especializar o comportamento em relação ao que é oferecido pela superclasse, ou ter que oferecer alguma implementação para métodos que a superclasse tenha declarado mas não implementado. Normalmente, este tipo de relacionamento é denominado herança polimórfica.
A última forma é, sem dúvida, a que mais ocorre na programação orientada a objetos. Algumas modelagens introduzem uma forma de herança conhecida como contração, que deve ser evitada.


Herança é um mecanismo que permite que características comuns a diversas classes sejam fatoradas em uma classe base, ou superclasse. A partir de uma classe base, outras classes podem ser especificadas. Cada classe derivada ou subclasse apresenta as características (estrutura e métodos) da classe base e acrescenta a elas o que for definido de particularidade para ela.
Sendo uma linguagem de programação orientada a objetos, Java oferece mecanismos para definir classes derivadas a partir de classes existentes. É fundamental que se tenha uma boa compreensão sobre como objetos de classes derivadas são criados e manipulados, assim como das restrições de acesso que podem se aplicar a membros de classes derivadas. Também importante para uma completa compreensão da utilização desse mecanismo em Java é a compreensão de como relacionam-se interfaces e herança.
Herança é sempre utilizada em Java, mesmo que não explicitamente. Quando uma classe é criada e não há nenhuma referência à sua superclasse, implicitamente a classe criada é derivada diretamente da classe Object. É por esse motivo que todos os objetos podem invocar os métodos da classe Object, tais como equals() e toString().

Exemplos e mais explicações:

Herança é quando uma classe herda atributos de outra. Na imagem abaixo podemos ver um exemplo:
Temos 5 classes: A classe pai (ou superclasse) Pessoa e suas respectivas classes filhas (ou subclasses), que são PF, PJ, Amigos e Parentes. PF é filha da classe Pessoa e pai das classes Amigos e Parentes. PJ é filha de Pessoa e não tem subclasses.
Podemos ver também que a classe pessoa tem os atributos nome, telefone e endereço. A classe PF tem os atributos RG e CPF. A classe PJ tem os atributos CNPJ e IE. A classe Amigos, tem o atributo blog. A classe Parentes tem o atributo email. Como PF e PJ são subclasses de Pessoas, elas herdam da classe Pessoas os atributos nome, telefone e endereço. As classes Amigos e Parentes, por serem subclasses de PF, herdam os atributos RG e CPF, além disso, também herdam os atributos nome, telefone e endereço, já que sua classe pai é uma classe filha de Pessoa (poderiamos dizer que a classe Pessoa é avô de Amigos e Parentes :P ).
Por esta razão podemos dizer que a hierarquia em Java ocorre de cima para baixo. Uma superclasse (ou classe pai) pode ter várias subclasses (ou classes filhas) que, por sua vez, podem ter suas próprias subclasses. Mas o oposto não acontece. Não é possível para uma classe filha ter duas ou mais classes pais (se pudesse já ia ter gente chamando a classe filha de “classe bastarda” ahuheuehuaheuhau).
Para melhor entendimento usaremos o esquema da primeira imagem para criarmos um programinha simples que irá receber os dados de pessoas digitados pelo usuário.

Código

Temos abaixo código do programa que receberá os dados digitados pelo usuário. Os comandos que ainda não foram explicados serão explicados antes da criação do código de cada classe. Gostaria de ressaltar que o foco aqui é a demonstração da herança. Por essa razão os comandos aqui são explicados apenas para facilitar o entendimento de como o código funciona.

Pessoa.java

Aqui a classe pai é criada com seus atributos e métodos construtores. O primeiro método já define o valor dos atributos enquanto o segundo método recebe os valores por parâmetro.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
public class Pessoa {
    String nome;
    String telefone;
    String endereco;
 
    public Pessoa() {
        nome = "";
        telefone = "";
        endereco = "";
    }
    public Pessoa(String nome, String telefone, String endereco) {
        this.nome = nome;
        this.telefone = telefone;
        this.endereco = endereco;
    }
}


PF.java

Aqui é criada a classe PF, que é filha da classe Pessoa. Por essa razão é utilizada a cláusula extends na criação da classe (para mostrar que a classe PF herda atributos da classe Pessoa). Da mesma forma que na classe Pessoa, na PF foram criados os métodos construtores. A diferença é que dessa vez utilizamos o comando super(), que serve para chamar o construtor da classe pai. É importante notar que o método construtor usado para passagem de parâmetros não tem apenas os seus atributos que já foram definidos na criação, mas também tem os atributos da classe Pessoa: public PF (String nome, String telefone, String endereco, String RG, String CPF) Na verdade tanto faz o nome que será usado. Para evitar confusões usei nomes iguais aos dos atributos:nome, telefone e endereco. Poderia também usar n, t e e que, da mesma forma, os valores seriam passados, já que o super() funciona de forma a enviar os parâmetros na ordem em que se encontram. No comando super() foram definidos os atributos que serão enviados para a classe pai. É justamente aqui que o super() faz a diferença, na passagem por parâmetros.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
public class PF extends Pessoa {
    String RG;
    String CPF;
 
    public PF() {
        super();
        RG = "";
        CPF = "";
    }
    public PF(String nome, String telefone, String endereco, String RG, String CPF) {
        super (nome, telefone, endereco);
        this.RG = RG;
        this.CPF = CPF;
    }
}

Amigos.java

Esta classe é filha da classe PF. O código é feito da mesma forma. São definidos na passagem por parâmetros os atributos da classe pai PF e também da classe Pessoa, que também é super classe da classe PF (classe avô, de certa forma ;P). Osuper(), da mesma forma, continua recebendo todos os parâmetros de suas superclasses. Sempre na ordem correta… De cima para baixo.

01
02
03
04
05
06
07
08
09
10
11
12
public class Amigos extends PF {
    String blog;
 
    public Amigos() {
        super();
        blog = "";
    }
    public Amigos(String nome, String telefone, String endereco, String RG, String CPF, String blog) {
        super(nome,telefone,endereco,RG,CPF);
        this.blog = blog;
    }
}

Parentes.java

Aqui o código é feito da mesma forma que o código acima, por se tratar também de uma subclasse da classe PF.

01
02
03
04
05
06
07
08
09
10
11
12
public class Parentes extends PF {
    String email;
 
    public Parentes() {
        super();
        email = "";
    }
    public Parentes(String nome, String telefone, String endereco, String RG, String CPF, String email) {
        super(nome,telefone,endereco,RG,CPF);
        this.email = email;
    }
}

PJ.java

Aqui o código é feito praticamente igual o código da classe PF, já que PJ é subclasse apenas da classe Pessoa.
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
public class PJ extends Pessoa {
    String CNPJ;
    String IE;
 
    public PJ() {
        super();
        CNPJ = "";
        IE = "";
    }
    public PJ(String nome, String telefone, String endereco, String CNPJ, String IE) {
        super (nome, telefone, endereco);
        this.CNPJ = CNPJ;
        this.IE = IE;
    }
}

CadastraPessoa.java

Este é o método principal (main), que é o primeiro código a ser executado. Por ser um código um pouco maior e uma classe diferente das outras, deixarei os comentários dentro do código para facilitar o entendimento e a visualização.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import javax.swing.JOptionPane; //import necessário para usar o JOptionPane
 
public class CadastraPessoa {
 
    public static void main(String[] args) {
 
        Pessoa objPessoa = new Pessoa(); //Declaração e instanciação do objeto da classe Pessoa.
 
        //O comando abaixo declara uma variável local de tipo inteira (int) chamada 'opcao' que guardo um número digitado pelo usuário. Para isso é usado o comando JOptionPane.showInputDialog que serve justamente para pedir um valor para o usuário. Como o JOptionPane trabalha com String e a variável opção é inteira, foi necessário usar o comando Integer.parseInt para transformar em inteiro o valor que foi recebido como String. Os '\n' utilizados servem para colocar quebras de linha.
        int opcao = Integer.parseInt(JOptionPane.showInputDialog("Digite a opção: \n\n1. Pessoa física\n2. Pessoa Jurídica"));
 
        //Os comandos abaixo declaram variáveis de tipo String e guardam o dado digitado pelo usuário no JOptionPane. Como as variáveis usadas abaixo são de tipo String, não é necessário usar o Integer.parseInt
        String nome = JOptionPane.showInputDialog("Digite o nome");
        String telefone = JOptionPane.showInputDialog("Digite o telefone");
        String endereco = JOptionPane.showInputDialog("Digite o endereço");
 
        //Abaixo temos o comando if que checa se o valor dentro da variável 'opcao' é 1. Se for será executado o código abaixo. Se não for, não será executado o bloco e outro comando é executado (neste caso, outro if que checa se a o valor em 'opcao' é 2.
        if (opcao == 1) {
            PF objPF = new PF();
 
            String RG = JOptionPane.showInputDialog("Digite o RG");
            String CPF = JOptionPane.showInputDialog("Digite o CPF");
 
            opcao = Integer.parseInt(JOptionPane.showInputDialog("Digite a opção:\n\n1. Amigos\n2. Parentes"));
            if (opcao == 1) {
                String blog = JOptionPane.showInputDialog("Digite o blog");
 
                //Por fim, abaixo é declarado e instanciado o objeto de classe Amigos. Dessa vez os valores são passados por parâmetros. Como podemos notar, os códigos anteriores pediram os dados para os usuários e armazenaram nas variáveis nome, telefone, endereco, RG, CPF e blog. Agora esses dados estão sendo passados por parâmetros já na instanciação do objeto. Aqui notamos como funciona a hierarquia em Java e também como o comando super() trabalha, já que primeiro são passados os parâmetros para os atributos da classe Pessoa (nome, telefone, endereco), depois para a classe PF (RG, CPF) e, por fim, para a classe Amigos (blog)
                Amigos objAmigos = new Amigos(nome,telefone,endereco,RG,CPF,blog);
            }
            if (opcao == 2) {
                String email = JOptionPane.showInputDialog("Digite o e-mail");
                Parentes objParentes = new Parentes(nome,telefone,endereco,RG,CPF,email);
            }
        }
 
        if (opcao == 2) {
            String CNPJ = JOptionPane.showInputDialog("Digite o CNPJ");
            String IE = JOptionPane.showInputDialog("Digite a Inscrição Estadual");
            PJ objPJ = new PJ(nome,telefone,endereco,CNPJ,IE);
        }
    }
}
Bom proveitos a todos.

Postado por às
Marcadores: ,

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)