Mesmo que se pareça com uma Novidade, a base da programação orientada a objetos é o objeto. Na vida real, todos os objetos têm uma série de características e comportamentos. Por exemplo, uma porta tem cor, forma, dimensões, material … (desfrute de uma série de recursos) e pode ser aberta, fechada … (tem um comportamento). Em programação orientada a objetos, um objeto é uma combinação de dados e rotinas específicos que podem operar com esses dados. Assim, os dois tipos de componentes de um objeto são:
- campos ou atributos: componentes de um objeto que armazenam dados. Eles também são chamados de variáveis de membro. Esses dados podem ser de tipo primitivo (
boolean, int, double, char...) ou, por sua vez, outro tipo de objeto (o que é chamado de agregação ou composição de objetos). A ideia é que um atributo representa uma determinada propriedade de um objeto. - rotinas ou métodos: é um componente de um objeto que realiza uma determinada ação ou tarefa com os atributos. Em princípio, todas as variáveis e rotinas de um programa Java devem pertencer a uma classe. De fato, em Java não há noção de programa principal e sub-rotinas não existem como unidades modulares independentes, mas sempre fazem parte de alguma classe.
9.1 classes
Uma classe representa o conjunto de objetos que compartilham uma estrutura e comportamento comuns. Uma classe é uma combinação específica de atributos e métodos e pode ser considerado um tipo de dados de qualquer tipo não primitivo. Assim, uma classe é uma espécie de modelo de objetos ou protótipo: Define os atributos que compõem esse tipo de objetos e métodos que podem ser usados para trabalhar com esses objetos. Embora, por outro lado, uma classe também pode ser composta de métodos estáticos que não precisam de objetos (como classes construídas em capítulos anteriores contendo um método estático main). A declaração de uma classe segue a seguinte sintaxe:
class IdentificadorClase { // Declaraciones de atributos y metodos ...}
Convenção dos programadores em Java: Os identificadores das classes devem ser simples , descritivo e substantivo e, no caso de nomes compostos, com a primeira letra de cada uma em letras maiúsculas. É conveniente usar as palavras completas e evitar acrônimos, a menos que a abreviação seja muito mais usada do que a forma não abreviada como no URL ou HTML.
9.2 Instâncias
Uma instância é Um elemento tangível (ocupa a memória durante a execução do programa) gerada a partir de uma definição de classe. Todos os objetos usados em um programa devem pertencer a uma determinada classe.
Embora o termo seja usado por vezes de forma imprecisa, um objeto é uma instância de uma classe predefinida em java ou declarada pelo usuário e referenciada por Uma variável que armazena seu endereço de memória. Quando Java não tem ponteiros, é simplesmente indicado que Java não tem ponteiros que o programador pode ver, já que todas as referências de objeto são, na verdade, ponteiros na representação interna.
em geral, acesso Em atributos é feito através do operador de pontos, que separa o identificador da referência do identificador de atributo (idReferencia.idAtributo). As chamadas para os métodos para executar as diferentes ações são realizadas separando os identificadores da referência e do método correspondente com o operador de pontos (idReferencia.idMetodo(parametros)).
simples Exemplo de classe e instância
O código a seguir mostra a declaração da classe Precio. A classe Precio consiste em um único atributo (euro) e dois métodos: um que atribui um valor ao atributo (pone) sem retornar qualquer valor e outro que retorna o valor do atributo (da).
/** * Ejemplo de declaracion de la clase Precio * double da() --> devuelve el valor almacenado en euros * void pone( double x ) --> almacena valor en euros */public class Precio { // Atributo o variable miembro public double euros; // Metodos public double da() { return this.euros; } public void pone(double x) { this.euros = x; }}
graficamente, uma classe pode ser representada como um retângulo.
Figura 9.1 Representação gráfica da classe Precio
O código anterior pode ser compilado:
$>javac Precio.java
Gerando o arquivo bytecodes Precio.class. Este arquivo não é diretamente executável pelo intérprete, já que o código-fonte não inclui nenhum método principal (main).Para testar o código anterior, outro arquivo pode ser construído com o código-fonte mostrado abaixo:
/** * Ejemplo de uso de la clase Precio */public class PruebaPrecio { public static void main (String args ) { Precio p; // Crea una referencia de la clase Precio p = new Precio(); // Crea el objeto de la clase Precio p.pone(56.8); // Llamada al metodo pone // que asigna 56.8 al atributo euros // Llamada al metodo da que devuelve el valor de euros System.out.println("Valor = " + p.da()); Precio q = new Precio(); // Crea una referencia y el objeto q.euros=75.6; // Asigna 75.6 al atributo euros System.out.println("Valor = " + q.euros); }}
Figura 9.2 Representação gráfica do Espaço de memória usado pelas referências e instâncias da classe Precio durante a execução do método main da classe PruebaPrecio
Explicação do exemplo anterior
Para poder trabalhar com objetos que você terá que seguir um processo de duas etapas. A primeira coisa a fazer o programa é criar uma referência ou ponteiro da classe Precio com o identificador p. Semelhante a como uma variável de um tipo primitivo é declarada, a declaração do identificador de referência é feita com a sintaxe:
identificadorClase identificadorReferencia;// En el ejemplo anterior: Precio p;
Figura 9.3 Criando a referência p
A referência ou ponteiro, p é como uma missão para armazenar o endereço de memória de (apontar A) Os componentes da instância ainda não foram criados ou referenciados. Neste momento, é dito que a referência p, renovado, armazena um endereço de memória nulo (que não corresponde a qualquer objeto) ou . A segunda etapa do processo para trabalhar com objetos leva à criação de uma nova instância referenciada por p, que é feito com a instrução:
Figura 9.4 Criando a nova instância da classe Precio Referenciado Por p
Esta operação também é chamada de instanciação. Embora as duas operações anteriores (criação da referência e criação da instância referenciada) possam ser realizadas em conjunto na mesma linha de código:
identificadorClase identificadorReferencia = new identificadorClase();// En el codigo del ejemplo anterior: Precio q = new Precio();
Figura 9.5 Criação da referência q e a nova instância da classe Precio referenciada por q
O resultado da execução do código anterior é duas novas instâncias da classe Precio referenciada, respectivamente, por p e q. O atributo euro de cada uma das novas instâncias da classe Precio é acessível através do identificador de referência e o operador de pontos (p.euros e ). Os métodos da e pone pertencente à classe Precio são acessíveis através do identificador do Referência e o operador de ponto (p.da() e p.pone(56.8) e q.da() e q.pone(75.6), respectivamente). No caso dos métodos, a instância pelo qual a chamada correspondente é feita atua como um parâmetro ou argumento implícito do método.
Se uma referência a outra é atribuída por uma instrução de atribuição, elas não são copiadas Os valores dos atributos, mas que uma única instância visava duas referências diferentes. Por exemplo:
q = p; // Ahora p y q referencian al mismo objeto
Figura 9.6 Resultado da atribuição de valores entre referências
Neste caso. O que acontece com a instância anteriormente referenciada por q? O referido exemplo é deixado sem referência (inacessível). Isso pode ser um problema em algumas linguagens de programação, como o caso de Pascal ou C, que usam variáveis dinâmicas e que precisam libertar explicitamente o espaço na memória reservada para as variáveis que vão parar de ser referenciada. O gerenciamento dinâmico da memória é geralmente uma tarefa complicada para o programador e muito dada à proliferação de erros de execução. Para evitar essas desvantagens, o Java permite que você crie tantos casos quanto desejado (com a única limitação da memória que é capaz de gerenciar o sistema), sem o programador ter que se preocupar em destruir ou libertá-los quando eles não são mais necessários.O ambiente de execução do Java elimina automaticamente instâncias quando detecta que não serão usadas (quando pararem de ser referenciadas). Este processo é chamado de coleta de lixo ou coleta (coleta de lixo).
9.3 Modificadores de visibilidade
O modificador Indica que o componente do O método é acessível fora do código da classe à qual o componente através do operador do ponto pertence. O modificador private Indica que o componente só é acessível através dos métodos da própria classe. O modificador protegido será visto mais tarde. No código a seguir, o atributo é declarado euros com o modificador private.
/** * Ejemplo de declaracion de la clase PrecioPrivado * double da() --> devuelve el valor almacenado en euros * void pone( double x ) --> almacena valor en euros * euros --> Atributo de acceso privado */public class PrecioPrivado { // Atributo o variable miembro private double euros; private double euros; // Metodos publicos public double da() { return this.euros; } public void pone(double x) { this.euros = x; }}
Se outro código for construído que tente use diretamente o atributo euros:
/** * Ejemplo de uso de la clase PrecioPrivado * double da() --> devuelve el valor almacenado en euros * void pone( double x ) --> almacena valor en euros * euros --> Atributo de acceso privado */public class PruebaPrecioPrivado { public static void main (String args ) { PrecioPrivado p = new PrecioPrivado(); // Crea instancia p.pone(56.8); // Asigna 56.8 a euros System.out.println("Valor = " + p.da()); // Asigna 75.6 a euros - ERROR p.euros=75.6; System.out.println("Valor = " + p.euros); // Tambien ERROR }}
Um erro de compilação ocorrerá:
$>javac PruebaPrecioPrivado.javapruebaPrecioPrivado.java:15: euros has private access in precioPrivado p.euros=75.6; ^ pruebaPrecioPrivado.java:16: euros has private access in precioPrivado System.out.println("Valor = " + p.euros); ^
Desde o atributo euros só é acessível através dos métodos de método da e pone
Usando o modificador private serve para implementar uma das características de programação orientadas a objetos: a ocultação de informações ou encapsulamento. Estritamente falando, a declaração como um público de um atributo de uma aula não respeita este princípio da ocultação de informações. Declando-os como privados, você não tem acesso direto aos atributos do objeto fora do código de classe correspondente e só pode ser acessado indiretamente através dos métodos fornecidos pela própria classe. Uma das vantagens práticas de forçar o uso de um método para modificar o valor de um atributo é garantir a consistência da operação. Por exemplo, um método que atribua valor ao atributo euros de um objeto da classe Precio pode garantir que um valor negativo não será Atribuído.
9.4 Classes aninhadas e internas
Uma classe B pode ser definida como membro de outra classe A. A estrutura sintática é a seguinte:
class ClaseA { ... class ClaseB { ... }}
Diz-se que é uma determinada classe na ClaseA. A classe aninhada só pode ser usada dentro da classe do contêiner. Este tipo de aulas é construído apenas quando a classe aninhada é usada apenas ou faz sentido dentro da classe do contêiner. A classe aninhada pode ser declarada como static. Nesse caso, a classe aninhada é chamada de classe aninhada estática. Caso contrário, é chamado de classe interna.
9.5 A instância do operador de
O operador instanceof retorna true ou false se um objeto pertencer ou não uma determinada classe. Sintaxe: