Um array é sempre um objeto e, portanto, uma referência. Para se utilizar um array, é necessário “new”:

                            int idades[] = new int[10];
                        

                                    idades[5] = 10;
                                

                            class Conta {
                                private double saldo;
                                private double limite; //Só é relevante para conta
                                // ...
                            }
                            

• O controle de acesso é implementado em Java por Modificadores de Acesso (ou visibilidade) e se aplica a atributos e métodos.
• private
• (default)
• protected
• public


• Na orientação a objetos, é prática quase que obrigatória proteger atributos de classe com private.
• Desta forma, toda conversa de um objeto com outro é feita por troca de mensagens, isto é, acessando seus métodos

class Cliente {
    private String nome;
    private String endereco;
    private String cpf;
    private int idade;
    public void mudaCPF(String cpf) {
        if (validaCPF(cpf))
        	this.cpf = cpf;
    }
    private boolean validaCPF(String cpf) {
        // série de regras aqui, falha caso não seja válido
    }
    // ..
}
                        

• Quando criarmos duas contas, qual será o valor do totalDeContas de cada uma delas?
• Um
• Se modificarmos para static:

private static int totalDeContas;
                            

• Ele passa a não ser mais um atributo de cada objeto, e sim um atributo da classe, a informação fica guardada pela classe, não é mais individual para cada objeto.

• Para acessarmos um atributo estático, não usamos a palavra chave this, mas sim o nome da classe:

class Conta {
    private static int totalDeContas;
    //...
    Conta() {
        Conta.totalDeContas = Conta.totalDeContas + 1;
    }
}
                            

• Já que o atributo é privado, precisamos de um getter para ele!

public static int getTotalDeContas() {
        return Conta.totalDeContas;
}
                            

int total = Conta.getTotalDeContas();
                            

1. Clone o projeto https://github.com/aula-java/heranca-1
2. Remova toda a repetição de código através do mecanismo de herança. Faça o teste unitário passar.
3. Adicione o método abaixo na classe Gerente:

                        public String getNome() {
                            return "Gerente " + nome;
                        }
                            

• Para funcionar, altere a visibilidade do atributo nome da superclasse de privado (private) para protegido (protected)
• Corrija o teste unitário para que ele passe.
4. Crie uma classe Diretor que herda de Funcionario.
• Adicione o método getNome que retorna "Diretor " + nome
• Crie um TestCase de Diretor para verificar se o nome está correto.

• A boa prática de programação diz que o código comum a diversas classes deve ser colocado em uma classe-base (Template pattern)


• Esta classe nunca será instanciada diretamente, e seu código só poderá ser utilizado através de herança


• Então, esta classe deve ser criada como sendo abstrata (abstract)

• Representam um conceito abstrato (modelo)
• Não deve ser instanciada (gerar um objeto)
• Servem apenas para permitir a derivação de novas classes
• Identificamos uma classe como abstrata pelo palavra reservada abstract

Exemplo:

public abstract class nomeClasse { ... }
                                

Podem conter métodos concretos:
• Usados através das subclasses

Podem conter métodos abstratos:
• Identificados pela palavra reservada abstract
• Nunca serão chamados
• Não possuem implementação (definem apenas a interface)
• Devem ser obrigatoriamente implementados na classe filha
• Padronização no comportamento das classes filhas
• Não podem ser declarados como private
• Não podem ser declarados como final
• Não podem ser declarados como static
• Herdados pelas classes filhas

• Quando não estamos interessados em uma referência genérica da classe como funcionário, que pode ser qualquer posição dentro de uma empresa.
• Quando pretendemos criar um comportamento padrão (métodos) em uma superclasse que:
• Permita reescrever alguns métodos específicos da subclasse (se necessário). Esses métodos são definidos na superclasse, mas não podem ser usados por objetos dela.
• Obriga a definir alguns métodos específicos na subclasse (herda a responsabilidade de implementar métodos - todas subclasses devem implementar todos os métodos abstratos da superclasse).

1. Altere o projeto sobre Polimorfismo.
2. Torne a classe Funcionário abstrata
3. Corrija os testes unitários
4. Transforme o método Funcionario.setSalario() como abstrato.
5. Faça todas as alterações no código para que funcione os testes unitários
6. Transforme o método Funcionario.getBonificacao() como abstrato.
7. O que aconteceu? Qual a diferença com relação a alteração do método setSalario()? Escreva no código a discussão.

• São classes abstratas “puras”
• São “contratos” que definem o que a classe poderá fazer, mas não dizem nada sobre a maneira como será feito
• Implementação fica a cargo das classes que utilizam a interface
• Assim como a abstrata não pode ser instanciada
• Ela só expõe o que o objeto deve fazer, e não como ele faz, nem o que ele tem. Como ele faz vai ser definido em uma implementação dessa interface.

Podemos ter métodos concretos em interfaces a partir do Java 8 usando o modificador default. Eles serão "herdados" por todos que implementarem essa interface.
Esse recurso, chamado default method, permite evoluir uma interface sem quebrar compatibilidade.

• Definir um comportamento que pode ser implementado por qualquer classe, independentemente da sua hierarquia de classes.


• Captura de similaridades entre classes não relacionadas, sem ser obrigado a criar artificialmente uma relação de herança entre elas.


• Declaração de métodos que uma ou mais classes esperam implementar

• Diferença entre classes abstratas e interfaces: é que uma classe filha pode herdar de apenas uma única classe (abstrata ou não) enquanto qualquer classe pode implementar várias interfaces simultaneamente


• Mecanismo “simplificado” de implementação de herança múltipla em Java


• Interfaces podem ser úteis para implementação de bibliotecas de constantes (pois todos os atributos devem ser declarados como static e final)

• Declaradas através da palavra-chave interface e o modificador de acesso public


• Não tem construtor


• Não tem variáveis de instância (a não ser constantes estáticas)


• Todos os métodos são abstratos e públicos (a classe que implementa a interface deve implementar todos os métodos definidos na interface)


• Não pode ter métodos estáticos

• Uma classe que implementar a interface deve implementar todos os métodos definidos na interface


• Uma classe pode implementar interfaces múltiplas. Ex: class Tile extends Rectangle implements Cloneable, Comparable


• Uma interface pode estender outras interfaces


• Uma interface não pode implementar outras interfaces