Declaração Interfaces - Otimize-TI

DECLARÇÕES
E
CONTROLE DE ACESSO
• Declarar Classes e Interfaces;
• Desenvolver Interfaces e Classes Abstract;
• Usar Primitivos, Arrays, Enums e Identificadores
Legais;
• Usar Métodos Static, Nomeação JavaBeans;
• Exercícios;
 O que é um programa em Java ? É principalmente
uma coleção de objetos falando com outros objetos por
meio da invocação do métodos uns dos outros.
 Classe – Um modelo que descreve os tipos de estado
e de comportamento que os objetos do seu tipo podem
ter.
 Objeto – é uma instância de uma determinada classe. Essa
instância terá o próprio estado e terá acesso a todos os
comportamentos definidos pela classe da qual foi criada.
(Ex: new CidadeVO();)
 Estado – Cada objeto terá o seu conjunto único de variáveis de
instância conforme definido na classe. Coletivamente, os valores
atribuídos às variáveis de instância de um objeto compõem o
estado do objeto.
 Método (COMPORTAMENTO) – ao criar uma classe o
programador cria métodos para essa classe. É nos métodos que a
lógica da classe é armazenada. Nos métodos, o verdadeiro
trabalho é realizado.
 Identificadores – Todos os componentes de Java – classes,
variáveis e métodos - precisam de nomes, esses nomes são
conhecidos como identificadores.
 Herança – Permite ao código definido em uma classe ser
reutilizado em outras classes. (SuperClasses, SubClasses, Ex:
SuperVO, CidadeVO);
 Interfaces - É uma espécie de superclasse 100% abstract que
define os métodos que uma subclasse deve suportar.
OBS: abstract é a forma de obrigar métodos ou classes a serem
implementadas em suas classes filhas.
Identificadores Abordados na Certificação:
 Identificadores Legais
 Convenções de Código Java da Sun
 Padrões de nomeação JavaBeans
Regras dos Identificadores Legais:
 Devem começar com letras. (Ex: _a, $c, cont); Não podem começar
com números.
 Depois do primeiro caractere pode conter combinação de letras,
caracteres de moedas, de conexão (_), e números.
 Não há limite para número de caracteres de um identificador.
 Não se pode usar uma palavra-chave Java como identificador .(Ex:
final, double, int, ...).
 Os identificadores Java são case sensitive, ou seja, foo e Foo, são
diferentes.
A Sun Criou um conjunto de padrões de programação
para Java e publicou esse padrões em um documento
chamado “Convenções de Código Java”. Veremos essas
convenções a seguir.
Ops!!! – As questões do exame não seguem as
convenções de código, devido a limitações do
programa de provas que usado para ministrar o exame
internacionalmente.
Exemplo de Código:
Class Wombat implements Runnable {
private int i;
public synchronized void run() {
if (i%5 != 0) { i++; }
for (int x=0; x<5; x++; i++)
{ if (x > 1) thread.yield(); }
System.out.print(i + “ ”);
}
Public static void main(String[] args) {
Wombat n = new Wombat();
for ( int x=100; x>0; --x) { new thread(n).start();}
}}
O único padrão que é seguido tanto quanto possível no exame
real é o dos padrões de nomeação. Como:
• Classes e interfaces - Primeira letra maiúscula e, se várias
palavras forem escritas juntas a primeira letra de cada palavra
deve ser maiúscula (formato inglês de “camelCase”). Para Classes
os nomes devem ser substantivos. Ex: Impressora, Conta, ...
• Métodos - A primeira letra deve ser minúscula, o formato
camelCase deve ser usado. Ex: getBalanco, getNomeCliente;
• Variáveis – segue as mesmas regras dos métodos.
• Constantes: São criadas marcando-se variáveis como static e
final. Devem ser nomeadas usando-se letras maiúsculas e (_)
como separador de palavras. Ex: ALTURA_MINIMA;
JavaBeans são classes Java que têm propriedades. Propriedades
são como variáveis de instância private. Sendo assim a única
maneira pela qual podem ser acessadas de fora da sua classe é
através de métodos da classe. (setter , getter); Segue as Regras de
nomeação de propriedades JavaBeans para o exame:
• getSize() prefixo get, seguido pela primeira letra maiúscula;
• Boolean – get ou is. Ex: getMaior(); ou isMaior();
• setSize() prefixo set, seguido pela primeira letra maiúscula;
• public void setNomeAluno(String nome){...};
• public String getNomeAluno () {..}
Escrevendo código Java estamos escrevendo classes ou
interfaces. Dentro dessas classes temos variáveis e
métodos, onde a forma como isso tudo é escrito pode
afetar drasticamente o comportamento do código. Uma
prova disso são métodos do tipo public ou do tipo
private, ambos podem causar grandes diferenças na
execução do código.
 Deve existir somente uma classe public em cada arquivo de código-fonte.
 Os comentários podem aparecer em qualquer lugar do código-fonte. São
independentes de quaisquer regra.
 Se houver uma classe public no arquivo o nome do arquivo deve ser o mesmo
da classe. Ex: public class Cidade{}, Cidade.java;
 Declaração de pacote deve estar na primeira linha do código-fonte, e as
importações logo abaixo.
 Um arquivo pode ter mais de uma classe não-public.
 Arquivos que não possuam classes public podem ter o nome diferente das
classes do arquivo.
Seque a declaração de uma Classe simples.
Ex: class minhaClasse{ }
É possível adicionar modificadores antes da declaração da classe.
Ex: public classe MinhaClasse {}
Existem duas categoria de modificadores:
 De acesso: public, protected, private;
 Que não se referem a acesso: strictfp, final, abstract;
Quando dizemos que uma classe A tem acesso a uma classe B,
estamos dizendo que, a classe A pode instanciar a Classe B, pode
estender a classe B, pode também acessar a classe B, dependendo
do controle de acesso dos métodos e variáveis dessa classe.
Consiste em a classe não possuir modificadores precedendo-a na declaração.
Ex: class Estado{}
É um acesso restrito ao nível de pacote, onde uma classe com acesso default só
pode ser vista (acessada) por classes de dentro do mesmo pacote. Ex:
package financeiro;
class ContasPagar {}
Observe o segundo arquivo:
package venda;
import financeiro.ContasPagar;
class Venda extends ContasPagar { }
Erro: Can`t acess class financeiro.ContasPagar. Class or interface must be
public, in same package, or an acessible member class.
A declaração de uma classe com a palavra-chave public dá a todas
as classes de acesso, de todos os pacotes, acesso público à classe.
Sendo indispensável ainda a importação dessa classe.
Considerando o exemplo anterior (Acesso Default), como
poderíamos corrigir o erro apresentado:
package financeiro;
public class ContasPagar {}
package venda;
import financeiro.ContasPagar;
class Venda extends ContasPagar { }
O programado pode modificar uma classe usando as
palavras-chave final, abstract, ou strictfp. Esse
modificadores existem em adição a qualquer controle
de acesso. Então é possível declarar uma classe como
public e final ao mesmo tempo. Mas não é sempre que
isso ocorre. É possivel marcar uma classe como final e
strictfp ao mesmo tempo, mais nunca, marcar uma
classe como final e abstract.
Considerações strictfp => página 8.
Usando na declaração de sua classe a palavra-chave
final , você está classificando sua classe em questão a
não permitir que ela possa ser subclassificada. Em
outras palavras jamais outra classe poderá estender
uma classe final. Caso o faça ocorrerá uma exceção.
Por que criar uma classe final ? Para uma garantia
absoluta de que nenhum dos métodos dessa classe
jamais vai ser substituído. Um exemplo disso são as
classes das bibliotecas fundamentais do Java, como a
classe String. Sendo assim use final para segurança.
Uma classe definida com abstract nunca poderá ser
instanciada. Sua única função é ser estendia
(subclassificada).
abstract class Carro {
private String cor;
private String chassi;
public abstract void PotenciaMotor();
public abstract void VelociadadeMaxima();
}
Uma interface é um contrato. Você está definindo o
que a classe pode fazer, sem mencionar nada sobre
como a classe o fará.
Uma interface pode ser implementada por qualquer
classe, de qualquer árvore de herança. Podendo assim
definir que duas classes implemente a mesma
interface.
Considere uma interface, sendo uma classe 100%
abstract.
Verificar figura página 11.
Regras para declaração de métodos e variáveis em uma interface:
 Todos os métodos são implicitamente public e abstract;
 As interfaces só podem declarar constantes e não variáveis de
instância. Assim toda variável deve ser definida public, static e final;
 Já que os métodos são abstract, ele não podem ser marcados como
final, native, strictfp ou synchronized;
 Uma interface pode estender uma ou mais interfaces diferente;
 Uma interface não pode estender nada que não seja outra interface;
 Um interface não pode implementar outra interface ou classe;
 Uma interface deve ser declarada com a palavra-chave interface;
Exemplo de declaração de uma interface:
public abstract interface CidadeInterface { }
O modificador abstract é considerado redundante, as interfaces são
implicitamente abstract.
O modificador public na declaração da interface é
obrigatório de você deseja que ela tenha acesso público
e não o default.
Já os modificadores public e abstract nos métodos é
redundante já que todos os métodos de uma interface
são implicitamente public e abstract.
Verificar exemplos página 12;
Ao colocar uma constante em uma interface, você está
garantindo que todas as classes que implementarem
essa interface terão acesso a essa constante.
Discutir código página 13;
Modificadores de Acesso:
 public;
 protect;
 default;
 private;
Modificadores não referente a Acesso.
Declarando Enums.
Quando um método ou variável é declarado public , isso
significa que todas as outras classes, independente do
pacote ao qual pertençam, podem acessar o membro em
questão (Assumindo-se que a própria classe esteja
visível). Ex:
Existem três formas de acessar um método:
 Invocando um método declarado na mesma classe;
 Invocando um método usando uma referência da
classe;
 Invocando um método herdado;
Ex:
package venda;
import basico.*;
class Venda {
public static void main (String[] args) {
Cidade c = new Cidade();
c.incluir();
}
}
package basico;
public class Cidade {
public void incluir() {
System.out.println(“DADOS INCLUIDOS”);
}
}
Membros marcados como private não podem se
acessados por código em nenhuma outra classe que não
aquela na qual o membro private foi declarado.
Ex:
package basico;
public class Cidade {
private void incluir() {
System.out.println(“DADOS INCLUIDOS”);
}
}
package venda;
import basico.*;
class Venda {
public static void main (String[] args) {
Cidade c = new Cidade();
c.incluir();
}
}
Erro: cannot find symbol
Symbol : method incluir()
E se uma subclasse tentasse herdar um membro private
da sua superclasse ? Quando um membro é declarado
private, uma subclasse não pode herdar dele.
Assim uma subclasse não pode ver, usar e nem sequer
pensar nos membros private da sua superclasse.
Os níveis de controle de acesso protect e default são quse
idênticos, mas com uma diferença fundamental. Um
membro default só pode ser acessado se a classe que o
estiver acessando pertencer ao mesmo pacote, enquanto
que um membro protect pode ser acessado (atráves da
herança) por uma subclasse mesmo se a subclasse estiver
em um pacote diferente.
Exemplo página 19.
Quando criamos uma variável de instância protect, ela se
torna acessível para todas as classes do pacote onde está a
classe na qual ela foi criada, bem como herdável por
quaisquer subclasses de fora do pacote, ou seja,
subclasses da classe onde foi criada a variável terão
acesso a essa variável, podendo essas subclasses estarem
fora do pacote da mesma.
Exemplo página 20 e 21.
Quando uma subclasse, de fora do pacote herda um
membro protect, esse membro torna-se essencialmente
private dentro da subclasse, de forma tal que apenas a
subclasse e as suas subclasses podem acessá-los.
Pacote A
Parente
protect variável x
Pacote B
herda
Filho
private variável x
Sobrinho
new Filho();
x não é acessível
Exemplo de código usando Default:
package basico;
public class Cidade {
int x = 9;
}
package basico;
public Estado extends Cidade{
static public void main(String[] args) {
System.out.println(“variavel x = ” + x);
}
}
Se mudarmos o pacote da segunda classe, ocorre o seguinte erro de compilação:
Estado. Java:4: Undefined variable: x
System.out.println(“variavel x = ” + x);
1 error
A palabra-chave final impede que um método possa ser
substituído em uma subclasse, e frequentemente é
usada para forçar os recursos API de um método.
Exemplo disso é a classe String, nã0 é possível
subclassificar essa classe, ou seus métodos, devido a
argumentos final em seus métodos.
Esse argumento pode ser usado também em variáveis,
quando isso ocorre essa variável passar a não poder ser
alterada, quanto ao seu valor.
É um método declarado, mas não implementado. Um método
é marcado como abstract quando se quer forçar as subclasses
a fornecer a implementação deste.
Ex: public abstract void doIt();
Obs: É inválido ter um único método abstract que seja em
uma classe que não seja declarada explicitamente como
abstract. Porem o inverso é permitido, ou seja, possuir uma
classe abstract e dentro dela possuir métodos que não sejam
abstract.
A primera subclasse concreta (não-abstract) de uma classe
abstract deve implementar todos os métodos abstract da
superclasse. Exemplo página 25.
A palavra-chave synchronized indica que um método só
pode ser acessado por um thread de cada vez. Essa
questão será tratada no capítulo 9.
Basta apenas saber que esse modificador só pode ser
aplicado a métodos – não a variáveis, nem classes, apenas
a métodos.
Ex: public synchronized Record retrieveUserInfo
(int id){}
O modificador native indica que o método está sendo
implementado dependente da plataforma,
freqüentemente em C.
Não é necessário saber como usar métodos nativos para o
exame, apenas saber que native é um modificador e que
native só pode ser aplicado a métodos – não a classes,
nem variáveis, apenas a métodos.
Existem dois tipo de variáveis em Java:
 primitivos – um primitivo pode ser de oito tipos
diferente: char, boolean, byte, short, int, long, double ou
float. Uma vez declarado o seu TIPO primitivo não pode
nunca ser alterado, embora seu valor possa se modificar.
 variáveis de referência – são usadas para se referir a um
objeto. Esse contexto será melhor abordado no capítulo
2.
byte b;
boolean isNovo;
int x, y, z;
Object o;
Dog minhaNovaReferencia;
String s1, s2, s3;
São definidas dentro da classe porem fora de qualquer
método, e só são inicializados quando a classe é
instânciada.
class Pessoa {
// Defini campo (variáveis de instância) para a
// instância de Pessoa.
private String nome;
private String sobrenome;
private String enreco;
}
Para o exame você precisa saber que as variáveis de
instância:
 podem usar todos os níveis de acesso;
 podem ser marcadas como final e transient;
 não podem ser marcadas como: abstract,
sinchronized, strictfp, native, static.
São aquelas variáveis declaradas dentro de um método.
Isso significa que a variável não é apensa inicializada
dentro do método, mas também declarada dentro dele.
Ela é inicializada e destruída quando o método inicia e
logo após quando ele é finalizado.
Declarar uma variável com a palavra-chave final
impossibilita a reutilização dessa variável depois de ela
ter sido inicializada com um valor explícito. Isso
significa, que depois que uma variável final receber um
valor, esse valor não poderá ser alterado novamente.
Se marcar uma variável de instância como transient, você
está dizendo à JVM para ignorar essa variável quando
você tentar serializar o objeto que a contém.
Serialização foi adicionada ao exame na versão 5 do Java,
e será estudado no capítulo 5.
Diz à JVM que um thread que acesse a variável deve
sempre reconciliar a sua cópia private da variável com a
cópia master presente na memória. Como é que é? Não
se preocupe no exame tudo que você precisa saber é que ,
assim como transient, esse modificador só pode ser
aplicado a variáveis de instância.
É usado para criar variáveis e métodos que irão existir
independentemente de quaisquer instância criadas para
a classe. Membros static existem antes mesmo de você
criar uma nova instância de uma classe.
Permite restringir uma variável para ter um de apenas
uns poucos valores pré-definidos, em outras palavras, um
valor de uma lista enumerada.
Ex:
enum Cafe {PEQUENO, MEDIO, GRANDE}
Para pegar o valor, será necessário:
Cafe cf = Cafe.PEQUENO;
Um ENUM pode ser declarado como as suas próprias
classes separadas, ou como membros de classes, mas não
podem ser declarados dentro de um método. Isso pode
modificar a forma como acessar um ENUM.
Exemplo página 36 e 37.
Página 44 – Teste Individual (9 Questões).