Notas de Aula 03: Organização por Pacotes e Encapsulamento. c Objetivos da aula: Apresentar o conceito de pacotes Aprofundar no conceito de encapsulamento Introduzir os níveis de acessibilidades de atributos e métodos Apresentar o uso de construtores. Recordando... Na aula passada criamos uma classe Carro, na qual havia alguns atributos e métodos. Na classe que usamos para instanciar e testar um objeto da classe Carro, que chamamos de classe Aula02, iniciamos diretamente os atributos do objeto meucarro, logo após instanciá-lo. Entretanto, esta NÃO é a forma mais adequada de fazer isso. De fato, ao projetarmos uma classe, devemos ter em mente que o conceito de encapsulamento é muito importante na POO. Isto significa que os métodos da classe devem ser os únicos responsáveis pelo acesso aos atributos da classe. Isso esconde o modo de funcionamento da classe, privilegiando o uso da interface da classe como forma única de acesso, o que facilita o teste, a manutenção e a reusabilidade das mesmas. Antes de nos aprofundarmos neste tema, se faz necessário apresentar um conceito preliminar de pacotes. O que é um Pacote? Ao desenvolver um sistema, o número de classes que passarão a existir cresce tanto que, identificar o uso de um método ou uma classe, pode exigir um tempo demasiado de busca e compreensão. Os modelos de sistemas utilizam os pacotes para agrupar as classes em função de sua categoria ou objetivo. Por exemplo, podemos criar um pacote somente com as classes de entidades concretas (Pessoa, Carro, etc.) e um outro pacote com as classes de entidades abstratas (ConectorBancoDados,
GerenciadorProcessos, etc.). Então, para este exemplo, temos a criação de um pacote entidade e dois subpacotes, concreta e abstrata. A criação de pacotes e subpacotes é uma tarefa do projetista e é representado na UML assim: Na UML e em Java, nomes de pacotes são escritos com letras minúsculas e sem espaços (mesmo para nomes compostos) ou caracteres especiais. Uma boa prática é criar níveis de pacotes com a seguinte estrutura: br.com.<nomeorganizacao >.<pacote>.<subpacote>.classe; Este tipo de organização permite, por exemplo, Classes com nomes iguais em pacotes diferentes. Em Java, os pacotes (e subpacotes) são definidos pela instrução package. Todas as classes pertencentes a um package conseguem acessar as operações disponíveis uma das outras. Quando uma classe a ser utilizada não está no mesmo package, então é necessário importá-la (comando import). O código abaixo ilustra a classe Gerenciador que faz parte do subpacote abstrata. A classe Gerenciador faz referência à classe Pessoa que faz parte de outro pacote e portanto teve de ser importada. package entidade.abstrata; import entidade.concreta.pessoa; public class Gerenciador { public static void main(string[] args) { ConectorBD bd = new ConectorBD(); Pessoa pessoa = new Pessoa();
Na verdade, você já utilizou classes de outros pacotes. A classe Scanner, responsável pela leitura de dados, faz parte do pacote java.util. Uma forma mais adequada Para evitarmos iniciar os atributos da classe fora da mesma, devemos criar métodos na própria classe que façam esse acesso, tanto de escrita quando de leitura, sempre que necessário. Podemos alterar a classe Carro, introduzindo um método configurarcarro, que seja responsável pela iniciação dos atributos. Entretanto, como passar os valores que desejamos para os atributos do carro? A resposta é: através de argumentos no método. Ao enviarmos uma mensagem para um objeto da classe Carro através do método configurarcarro, devemos especificar os valores desejados para o carro (que chamamos de parâmetros correspondentes aos argumentos). Ou seja, o método configurarcarro deve estar apto a receber esses parâmetros como argumentos e atribuí-los aos atributos do carro (por vezes os termos parâmetros e argumentos são usados indiferentemente, mas argumentos são tipos formais e parâmetros são valores reais). Agora, o método passar a ter a seguinte assinatura: <TipoRetorno> <nomemetodoinfinitivo>(tipoa <nomevar1>, TipoB <nomevar2>,..., TipoN <nomevarx> ) onde TipoN pode ser qualquer tipo primitivo ou classe existente. O código a seguir prepara o método configurarcarro para receber os argumentos desejados para a classe Carro: void configurarcarro(string c, boolean e) { cor = c; motorestado = e; Na classe Principal, para realizar a chamada do método, agora devemos passar os parâmetros adequados aos argumentos, da seguinte forma: meucarro.configurarcarro("azul",false); Edite, compile e teste o funcionamento da alteração do código.
Na parte de Exercícios da aula passada foram criados o atributo rotacaomotor e os métodos acelerar e desacelerar. Estes métodos também podem ser reescritos para receber como parâmetros os valores a serem somados ou subtraídos do atributo rotacaomotor. O código dos métodos acelerar e desacelerar fica assim: void acelerar(int parcela) { rotacaomotor += parcela; System.out.println("O motor foi acelerado para "+ rotacaomotor); void desacelerar(int parcela) { rotacaomotor -= parcela; System.out.println("O motor foi desacelerado para "+ rotacaomotor ); E as chamadas dos métodos na classe principal ficam assim: System.out.println("---------"); System.out.println("Acelerando o motor..."); meucarro.acelerar(80); System.out.println("---------"); System.out.println("Desacelerando o motor..."); meucarro.desacelerar(120); Edite, compile e teste o funcionamento da alteração do código. Acessibilidade De fato, a correção feita no código da classe Carro foi positiva, mas não impede o uso indevido dos atributos por uma classe externa. Para tanto, devemos utilizar o recurso de definir a acessibilidade do elemento (classe, atributo ou método). Fazemos isso, em Java, usando as palavras reservadas public, private, package e protected na declaração. Os atributos e métodos public (+) constituem a interface da classe e são acessíveis a qualquer método de qualquer classe externa. Os atributos e
métodos private (-) são de acesso exclusivo dos métodos da classe. Os de acessibilidade protected (#) são passíveis de acesso por métodos de classes que herdem da classe que os definiu (trabalharemos esse conceito mais adiante). O nível package, que é assumido como padrão quando nenhum nível de acessibilidade é explicitamente definido (o que é o caso do nosso exemplo da aula passada), define o atributo ou método como acessível para qualquer método de classe dentro do mesmo pacote (este conceito também será trabalhado mais adiante). No nosso caso, desejamos restringir o acesso aos atributos da classe Carro. Para tanto, vamos defini-los como private. Altere assim o código: private String marca; private String cor; private boolean motorestado; private int rotacaomotor; Agora tente acessar os atributos como feito na aula passada... Pois é, a linguagem impede o acesso dessa forma, pois ela passou a ser errada. Getters e Setters Além de passarmos parâmetros para os métodos de uma classe durante uma mensagem, podemos também receber dados dos métodos chamados. Uma forma de fazê-lo é definir um valor de retorno para um método chamado. Os campos private de uma classe só podem ser manipulados por métodos dessa classe. Qualquer objeto de outra classe (um cliente, portanto), que deseje acessar um campo private da classe servidora, deve chamar os métodos public que a esta ofereça para manipular seus campos private. As classes
costumam oferecer métodos public para permitir aos clientes da classe configurar (set - atribuir) ou obter (get - obter) valores das variáveis private. Os nomes desses métodos não precisam começar com set ou get, mas essa convenção de atribuição de nomes é altamente recomendada em Java. Por exemplo, podemos criar um método getrotacaomotor que retorne o valor do atributo rotacaomotor. Assim: int getrotacaomotor () { return rotacaomotor; Para chamarmos o método, poderíamos usar este código: System.out.println("Rotacao do motor = " + meucarro. getrotacaomotor () ); Da mesma forma, caso quiséssemos criar um método setrotacaomotor que configurasse o valor do atributo rotacaomotor, ele seria assim: void setrotacaomotor (int r) { rotacaomotor = r; e a atribuição de uma valor à rotação teria, portanto, a seguinte sintaxe: meucarro.setrotacaomotor (1000) Operador this Quando criamos os métodos parametrizados, declaramos os argumentos com nomes que remetam aos atributos da classe. Fazendo dessa forma, ficou claro que o argumento é uma variável e o atributo é outra, como, por exemplo, no método configurarcarro. void configurarcarro(string m, String c, boolean e) { marca =m; cor = c; motorestado = e;
No método acima estamos lidando com seis variáveis (três argumentos do método e três atributos da classe). Esta forma, entretanto, não favorece a compreensão, na medida que alguns nomes de argumentos são bastante esclarecedores do seu conteúdo e criar um sinônimo pode ser indesejável. Porém, razões sintáticas nos fizeram utilizar os sinônimos, pois se o argumento m, por exemplo, fosse chamado marca, teríamos o comando de atribuição: marca = marca; que não seria corretamente compreendido pelo compilador. Neste caso estamos diante de uma sobrecarga de nome e o compilador resolve isso escolhendo a referência mais próxima (a que foi definida por último). Portanto, a variável marca referenciada nesse comando não seria o atributo da classe e sim o argumento do método (o último definido). Soluciona-se isso usando o operador this, que faz referência ao objeto atual (objeto corrente ao tempo da execução). Assim o trecho de programa anterior poderia ser mais elegantemente definido assim: void configurarcarro(string marca, String cor, boolean estadomotor) { this.marca = marca; this.cor = cor; Construtores this.estadomotor = estadomotor; A criação do método configurarcarro foi uma boa ideia para melhorar o encapsulamento da classe. Entretanto, ainda não é a melhor forma de iniciar os valores dos atributos. Melhor seria utilizarmos um método especial, que chamamos Construtor. O construtor de uma classe é um método automaticamente chamado quando instanciamos um objeto dessa classe. Em Java, o método construtor tem o mesmo nome da classe e é chamado quando usamos o comando new. Reparando bem, no exemplo da classe carro temos: new Carro(); o que sugere que estamos chamando um método chamado Carro (o uso dos parêntesis é um indicativo disso). Entretanto onde está este método que não foi declarado? A resposta é que a linguagem pressupõe que toda classe tem um construtor padrão (default),
que não possui argumentos e inicia os atributos numéricos com zero e os atributos lógicos com false. Entretanto, podemos definir explicitamente o construtor da classe, fazendo com que ele seja responsável pela iniciação de atributos da classe com valores distintos dos valores padrão. Assim, podemos ter: public Carro () { marca = "Palio"; cor = "azul"; motorestado = true; rotacaomotor = 1000; O problema com essa solução é que o objeto vai ter os atributos iniciados sempre com os mesmos valores, o que não é muito flexível. Podemos melhorar isso! Para tanto, ao invés do construtor padrão, podemos criar um construtor parametrizado. Assim, esse novo construtor vai receber valores como parâmetros e será responsável pela iniciação de atributos da classe com valores passados pelo objeto que chamou o construtor. Assim, podemos ter: public Carro (String marca, String cor, boolean estadomotor, int rotacaomotor) { this.marca = marca; this.cor = cor; this.estadomotor = estadomotor; this.rotacaomotor = rotacaomotor; A chamada desse construtor, na classe Principal, poderia ser assim: Carro meucarro = new ( Siena, Branco, true, 1200);
Exercícios 1) Crie métodos set e get para todos os atributos private da classe Carro. 2) Modifique o método configurarcarro para que inicie a rotação de acordo com o estado passado como argumento: 0 (para motor desligado) ou 1000 (para motor ligado). 3) Para a classe Quadrado, criada no exercício da aula passada, crie também métodos get e set para o atributo lado. Não permita que o cliente da classe passe um valor negativo para o atributo lado. 4) Crie uma classe Livro, que possua atributos para nome, autor, edição, editora e ano de publicação. Os atributos devem ser privados e devem possuir métodos de acesso. Deve haver um método que imprima os atributos correntes do livro. Deve haver um construtor padrão que inicie os atributos com o valor desconhecido e a seguir invoque um método privado que imprima uma mensagem de saudação com os atributos correntes. Adicionalmente, crie um programa principal que instancie diferentes livros chamando os diferentes os métodos get e set dos atributos que se fizerem necessários.