SCJP - Declarações e
Controle de Acesso
Anderson Ledo
Danilo Torres

Objetivos
Declarar Classes e Interfaces;
Desenvolver Interfaces e Classes Abstratas;
Usar tipos primitivos, arrays, enums e identificadores legais;
Usar métodos estáticos, JavaBeans e VarArgs.

Identificadores e JavaBeans

Identificadores permitidos
Devem ser compostos apenas de caracteres Unicode,
números, símbolos de moedas e caracteres de ligação (como
os _underscores_ ). As regras que você precisa saber sobre
identificadors são:
Devem começar com uma letra, cifrão ($), ou underscores
(_).
Números não são permitidos no início do identificador
apenas.
Na prática, não há limite no tamanho do identificador.
Não se pode usar palavras reservadas de Java como
identificadores
São case-sensitive . FOO, Foo, fOO, FoO, foo são
identificadores diferentes

Identificadores permitidos e não
permitidos
Permitidos Não Permitidos
int _a; int :b;
int $c; int a-d;
int _____2_w; int e#;
int _$; int .f;
int $; int 7g;
int $$$$2$$$; int a$%b;
int meu_identif_3; int void;
int repeat; int do;
int void2; int volatile;
int strictfp;

Lista das palavras reservadas
true, false e null também não
podem ser usadas. São literais.

Convenções de código
Há um documento chamado "Java Code Conventions" que
especifica as convenções de código que devem ser usadas em
programas Java. Mas somente algumas se aplicam aos testes
de certificação.
Classes: substantivos
Dog
Account
PrintWriter
Interfaces: adjetivos
Runnable
Serializable

Convenções de código
Métodos: verboSubst em camelCase
getBalance
doCalculation
setCustomerName
Variáveis: nomes curtos em camelCase
buttonWidth
accountBalance
myString
Constantes: letras em uppercase separadas por
underscore
MIN_HEIGHT

Convenções JavaBeans
Convenções de código usadas para tornar reusáveis os
componentes desenvolvidos na linguagem Java.
JavaBeans são classes Java que contém propriedades
(properties). Elas são inferidas através das convenções dos
nomes dos métodos e não através das variáveis de instância.

Convenções JavaBeans
Métodos getters/setters:
public void setMyValue(int v);
public int getMyValue();
public boolean getMyStatus();
Getters/Setters para booleanas:
public boolean isMyStatus();
public boolean getMyStatus();
public void setMyStatus(boolean s);
Listeners:
public void addMyListener(MyListener m);
public void removeMyListener(MyListener m);

Convenções JavaBeans
Assinaturas de métodos que desobedecem o padrão
JavaBeans:
void setCustomerName(String s);
public void modifyMyValue(int v);
public void addXListener(MyListener m);

Declaração de Classes

Declaração de Classes
A maioria dos programadores acham que conhecem todos os
modificadores, mas num estudo mais profundo encontram sutis
distinções, por isso, devemos ter conhecimentos mais sólidos
nesta seção.

Regras de Declaração
Deve haver apenas uma classe pública por código fonte;
Comentários podem aparecer em qualquer lugar;
Se houver uma classe pública em um arquivo, seu nome
deve ser o nome desta classe;
A declaração package deve estar na primeira linha do
código;
Declarações import devem vir entre as declarações de
pacote e classe;
Import e package se aplicam a todas as classes de um
arquivo;
Um arquivo pode conter mais de uma classe não-pública;
Um arquivo sem nenhuma classe pública pode ter qualquer
nome.

Exemplo
// arquivo Meetup.java
package osum.group.ufcg.jcert;
import ufcg.dsc.ccc.p2.Knowledge;
import ufcg.dsc.ccc.labp2.Exercise;
public class Meetup {
Knowledge k = new Knowlege();
}
class Discussion {
Exercise e = new Exercise();
}

Modificadores e Declaração de Classe
Modificadores de acesso:
public
protected
private
Modificadores não referentes ao acesso:
strictfp
final
abstract
...

Controle de Acesso
Uma classe A tem acesso a outra classe B quando:
Cria uma instância da classe B;
Estende a classe B;
Acessa alguns métodos e variáveis dentro da classe B
(dependendo do controle de acesso destas
propriedades);
Uma classe pode ter acesso default ou public ;

Acesso Default
package cert;
class Beverage { }
Não possui modificador de acesso em sua declaração;
A classe Blah só pode ser vista dentro do pacote cert;
package exam.stuff;
import cert.Beverage;
class Tea extends Beverage { } // Erro de
// compilação

Acesso público
package cert;
public class Beverage { }
Todas as classes do universo Java podem acessar uma
classe pública;
Ainda assim, é necessário importar uma classe para usá-la.
package exam.stuff;
import cert.Beverage;
class Tea extends Beverage { } // OK!

Outros modificadores (não referentes
ao acesso)
Uma classe pode ser modificada através das palavras
reservadas:
final;
abstract;
strictfp.

Modificador strictfp
Não é necessário saber como strictfp funciona;
Pode modificar tanto classe quanto método;
Seu uso indica que qualquer método da classe está em
conformidade com o padrão IEEE 754;
Pode ser usado com conjunto com os outros modificadores
sem problemas para classes e com algumas restrições para
métodos.

Modificador final
Indica que uma classe não pode ser estendida.
Por que fazer uma classe final ?
Se desejar garantia que nenhum método será
sobrescrito;
Muitas classe Java são 'final', p. ex.: String;
Cuidado ao fazer uma classe final, lembre-se que ela acaba
com um fundamental princípio de OO: estensibilidade.

Modificador abstract
Uma classe abstrata nunca pode ser instanciada;
Se apenas um método for abstrato, a classe deve ser
abstrata;
abstract class Car {
private double price;
private String model;
// ...
public abstract void goFast();
public abstract void goUpHill();
}

Combinação de modificadores
public final strictfp class MyClass{
//OK!
}
public abstract class MyOtherClass{
strictfp void calculate(){
//OK!
}
}
public abstract class ThisHasAProblem{
abstract strictfp myMethod();
//erro de compilação
}

Combinação de Modificadores
No geral, pode-se combinar modificadores na declaração
de uma classe. Por exemplo:
public abstract class Car { ... }
public abstract strictfp class Car { ... }
final class Car { ... }
Mas não se pode misturar alguns modificadores, como:
final abstract class Car { ... } // Erro de
// compilação

Acesso e hierarquia de pacotes
======== osum/ufcg/WholeGroup.java ==========
package osum.ufcg;
class WholeGroup {
JCertGroup jcg = new JCertGroup();
//Este código compila?
}
====== osum/ufcg/jcert/JCertGroup.java =====
package osum.ufcg.jcert;
class JCertGroup {
// ...
}

Acesso e hierarquia de pacotes
======== osum/ufcg/WholeGroup.java ==========
package osum.ufcg;
import osum.ufcg.jcert.*;
class WholeGroup {
JCertGroup jcg = new JCertGroup();
//Agora ele compila!!!
}
====== osum/ufcg/jcert/JCertGroup.java =====
package osum.ufcg.jcert;
public class JCertGroup {
// ...
}

Declaração de Interfaces

Declaração de Interfaces
Uma interface declara um contrato que define o que um
objeto que a implementa deve fazer, mas não como.
Uma interface define um comportamento que não precisa
estar associado a uma hierarquia de objetos. É
semanticamente mais "frouxa". Ex.: interface Bounceable
-> Bounceable <-

Relacionamento entre interfaces e classes

Declaração de Interfaces
Todos os métodos são implicitamente public e abstract ;
Todos os atributos são implicitamente public , static e final
(são constantes).
Métodos não podem ser static;
Interfaces não podem ser declaradas strictfp , final ou native
Podem estender outras interfaces (uma ou mais)
Não pode implementar outra interface ou classe
Deve ser declarada com a palavra chave "interface"
Podem ser usadas polimorficamente (fica para a reunião 2).

Entendendo...
public abstract interface MembroJCert
extends MembroGrupo {
public static final String
listaDeEmail = "jcert@googlegroups";
public abstract int getIdade();
public abstract String getNome();
public abstract List<String> getPerguntas();
}
Os únicos modificadores de acesso permitidos são public e
abstract. Por isso...
Interfaces não podem ser
declaradas strictfp, final ou native

... e enxugando.
//esta declaração é equivalente à anterior
public interface MembroJCert extends MembroGrupo {
String listaDeEmail = "jcert@googlegroups";
int getIdade();
String getNome();
List<String> getPerguntas();
}
Lembre-se!
Todos os métodos são
implicitamente public e abstract ;
Todos os atributos são
implicitamente public , static e final (são constantes).

Estas declarações são todas
equivalentes...
int x = 1;
public int x = 1;
static int x = 1;
public static int x = 1;
static final int x = 1;
public final int x = 1;
public static final int x = 1;
//lembre-se de que, implicitamente, todas as
//variáveis em uma interface são public,
//static e final. A omissão desse //identificadores deixa o código mais
limpo.

Atenção com as constantes...
interface Foo {
boolean BAR = true;
void go();
}
class Zip implements Foo {
public void go(){
BAR = false;
//erro de compilação! ;)
}
}

Atenção com as constantes...
interface Quadrupede {
int NUM_PATAS = 4;
}
interface Bipede {
int NUM_PATAS = 2;
}
class Animal implements Quadrupede, Bipede {
int quantasPatas(){
return NUM_PATAS;
//Erro de compilação: valor ambíguo.
//Alternativa: Bipede.NUM_PATAS
}
}

Declaração de Membros de
Classe

Modificadores de Acesso
public
protected
default
private

Há dois tipos de acesso...
Através do operador 'ponto' (.)
O código do método de uma classe pode acessar um
membro de outra classe;
Através de herança:
Uma subclasse pode herdar um membro de sua
superclasse.

Como saber se tenho acesso a um
membro de alguma classe?
Primeiramente, olhe para o nível de acesso da classe;
Se a classe não for acessível, então nenhum membro
estará acessível;
Depois, olhe para o nível de acesso de cada membro,
individualmente.

Membros public
Se um método ou variável forem declarados public,
isso significa que todas as classes podem acessá-los
(assumindo que a própria classe está visível).

Comparação entre acesso por herança
ou pelo operador (.)

Membros private
Membros marcados como private só podem ser acessados por
código dentro da classe que foi declarado.

Uma subclasse herda métodos
privados?
public class Car {
private void goFast() { /*...*/ }
}
public class SportCar extends Car {
private void goFast() {
// este método não foi sobrescrito.
}
}

Qual a diferença entre membros
protected e default?
Um membro default pode ser acessado apenas se a classe
que está acessando pertencer ao mesmo pacote.
Um membro protected pode ser acessado (através de herança)
mesmo que a subclasse esteja num pacote diferente.
Resumindo:
default = acessado pelos elementos do mesmo pacote
protected = acesso default + acessado pelas subclasses

A subclasse enxerga um membro
protected apenas através de herança...
package cert;
public class Parent {
protected int x = 10;
}
package other;
class Child extends Parent {
public void testIt() {
System.out.println("x = " + x); // OK
Parent ref = new Parent();
System.out.println("ref.x = " + ref.x);
// Erro de compilação
}
}

Detalhes de protected
Uma vez que uma subclasse (em pacotes distintos da
superclasse) herda um membro protected , este membro se
torna privado para qualquer código fora da subclasse, com
exceção de subclasses da subclasse. (oO)
Ou seja, membros protected só são acessíveis pelas classes
do mesmo pacote ou pelas classes de outros pacotes através
de herança.

Esclarecendo protected ...
package pack1;
public class Parent {
protected int x = 10;
}
package pack2;
class Child extends Parent {
// pode acessar 'x'...
public static void main(String[] args){
Child c = new Child();
c.x = 0; //aqui pode! =)
Parent p = new Parent();
p.x = 0; // aqui não! Erro!
}
}
package pack2;
class Cousin {
// não pode acessar 'x'...
}

Tudo junto e misturado...

E quanto a variáveis locais?
Modificadores de acesso podem ser aplicados em variáveis
locais?
private int valor = 0;
while(true){
valor++;
System.out.println(valor);
}
//Vai imprimir valores para sempre?
//Não, isto nem compila! Por quê?

E quanto a variáveis locais?
Modificadores de acesso podem ser aplicados em variáveis
locais? Não
De fato, apenas um modificador pode ser aplicado a variáveis
locais: final
final int valor = 0;
while(true){
valor++;
System.out.println(valor);
}
//Vai imprimir valores para sempre?
//Tb Não, isto nem compila! Por quê?

Resumo de modificadores de acesso

Modificadores de membro não
referentes a acesso

Métodos final
Previne que um método seja sobrescrito por uma subclasse.
class SuperClass {
public final void showSample() {
// ...
}
}
class SubClass extends SuperClass {
public void showSample() {
// Erro de compilação
// Tenta sobrescrever um método final
}
}

Argumentos final
Os valores de variáveis primitivas não podem ser modificados
dentro do corpo do método.
public Record getRecord(
int fileNumber, final int recordNumber) {}
As referências a objetos não podem ser modificadas, os
objetos sim.
public Record getRecord(
int fileNumber, final Owner recordOwner) {}

Métodos abstratos
É um método que foi declarado, mas não foi implementado.
public abstract void showSample();
Uma classe que contém algum método abstrato deve ser
necessariamente abstrata.
public class IlegalClass {
// Erro de compilação
public abstract void doIt();
}

Métodos abstratos
Qualquer subclasse que herde uma classe abstrata deve
implementar todos os métodos abstratos de sua
superclasse, a não ser que a própria classe seja abstrata.
Regra geral: 'A primeira subclasse concreta de uma classe
abstrata deve implementar todos os métodos abstratos da
superclasse.'

Exemplificando...
public abstract class Vehicle {
public abstract void goUpHill();
}
public abstract class Car extends Vehicle {
public abstract void goUpHill();
// ainda abstrato
public void doCarThings() { }
}
public class Mini extends Car {
public void goUpHill() { }
}

Métodos synchronized
Significa que o método só pode ser acessado por uma thread
por vez.
Esta palavra reservada só pode ser aplicada a métodos.
Exemplo:
public synchronized Record geUserInfo(int id) {}
Mais na Reunião 9!

Métodos Nativos (native )
Indica que o método é implementado em código
dependente de plataforma (geralmente em C);
Pode ser aplicado somente a métodos;
O método tem corpo semelhante a um método abstrato (;)
Não é necessário saber como usar...
Exemplos:
public native String method1(String s); public native void
method2();

Métodos strictfp
Força números de ponto flutuante a aderirem ao padrão
IEEE 754;
Pode modificar classes e métodos;
Uma variável nunca pode ser declarada como strictfp.

VarArgs
OK!
void doStuff(int... x) { }
void doStuff2(char c, int... x) { }
void doStuff3(Animal... animal) { }
Ilegais!
void doStuff4(int x...) { }
void doStuff5(int... x, char... y) { }
void doStuff6(String... s, byte b) { }

VarArgs - Explicações
Para declarar um método usando VarArgs, você segue o
tipo com (...), um espaço, e então o nome do array que
carregará os parâmetros recebidos;
É legal haver outros parâmetros na assinatura do método;
Só deve haver um var-arg por método.
O var-arg deve ser o último parâmetro na assinatura do
método.

Declarações de Construtores
class Foo2 {
// legal constructors
Foo2() { }
private Foo2(byte b) { }
Foo2(int x) { }
Foo2(int x, int... y) { }
// ilegal constructors
void Foo2() {}
Foo() { }
Foo2(short s);
static Foo2(float f) { }
final Foo2(long x) { }
abstract Foo2(char c) { }
Foo2(int... x, int t) { }
}

Declaração de Variáveis
Primitivas
char, boolean, byte, short, int, long, double, float;
Variáveis de Referência
acesso a um objeto
Não vamos nos aprofundar, assunto de P2 =)

Números Primitivos

Variável de Instância
Pode usar qualquer um dos níveis de acesso;
Pode ser:
final ;
transient ;
Não pode ser:
abstract;
synchronized;
strictfp;
native;
static (seria variável de classe).

Exemplificando...
//Pode...
public Object myVar;
private Object mySecretVar;
protected Object myLegacyVar;
Object myDefaultVar;
private final myFinalVar;
protected transient myTransientVar;
//Não pode...
private double strictfp result;
private synchronized Resource resource;
private native Object platformDependentObj;
private abstract Object lazyInstantiatedObj;

Comparação de modificadores entre
variáveis e métodos

Variáveis Locais
Têm escopo restrito aos métodos nos quais são
declaradas;
O tempo de vida delas acaba quando o método acabar de
ser computado;
Podem confundir-se com variáveis de instância quando os
nomes coincidem;
class TestServer {
public void logIn(){
int count = 10;
}
public void doSomething(int i){
count = i; //Erro de compilação
}
}

Variáveis Locais
As vezes é preciso distinguir variáveis de instância de variáveis
locais.
class Foo {
int size = 27;
public void setSize(int size){
size = size;
//Atribuição sem efeito, mas compilável.
}
}
Para produzir o efeito desejado, usa-se a palavra reservada
"this" a fim de referenciar a variável de instância.
this.size = size;

Variáveis Locais
Outro caso, conhecido como "shadowing".
class TestServer{
int count = 9;
public void logIn(){
int count = 10;
System.out.println("count is " + count);
}
public void count(){
System.out.println("count is " + count);
}
public static void main (String[] args){
new TestServer().logIn();
new TestServer().count();
}
}
Output: Count is 10
Count is 9

Declaração de Arrays
Arrays são variáveis com múltiplos objetos do mesmo tipo. Ou
múltiplos objetos com subtipos do mesmo tipo.
Quais das declarações abaixo são permitidas?
int[] key;
int numbers[];
Thread [][] myThreads;
Object [][] myObjects [];

Declaração de Arrays
Arrays são variáveis com múltiplos objetos do mesmo tipo. Ou
múltiplos objetos com subtipos do mesmo tipo.
int[] key;
int numbers[];
Thread [][] myThreads;
Object [][] myObjects [];
//As declarações acima são todas permitidas
//Abaixo, uma não permitida
int[5] scores;
//O tamanho não pode ser declarado antes da instanciação

Declarações "final"
Relembrando!
Variáveis "final" são constantes;
Classes "final" são folha. Não podem ser estendidas;
Métodos "final" são folha. Não podem ser sobrescritos;

Transientes e Voláteis
Variáveis transientes são ignoradas na serialização dos
objetos. (mais na reunião 6).
Variáveis voláteis serão revisitadas na reunião 9
(concorrência).
Agora, só precisamos saber como podem ser declaradas:
//Certo volatile int v1; transient int t1;
//Errado int volatile v2; int transient t2;

Variáveis e métodos estáticos
static pode ser aplicada a:
métodos
variáveis
uma classe aninhada dentro de outra classe, mas não
dentro de um método (mais na reunião 8)
blocos de inicialização
Mas não podem ser aplicadas a:
construtores
classes não ainhadas
interfaces
métodos e variáveis de instância de classes aninhadas
variáveis locais

Declarando Enumerações
Prepare-se! Não é todo dia que
você ver isso... Respire um pouco...

Enums
Quando você quer que uma variável tenha poucos valores pré-
definidos;
Testar esses valores pode ser complicado, e bugs podem ser
introduzidos facilmente;
Enumerações resolvem isso facilmente.
//enums não podem ser privados ou protegidos
enum TamanhoCafezinho {
MEDIO, GRANDE, EXAGERADO
}
TamanhoCafezinho tdc = TamanhoCafezzinho.EXAGERADO;

Enums
Também podem ser declarados dentro de uma classe... como
membros da classe. Mas, nunca dentro de métodos!
class MeuCafe{
enum Tamanho { EXAGERADO, MTO_EXAGERADO};
//o ';' é opcional
Tamanho t;
}
public class Test{
public static void main(String[] args){
MeuCafe mc = new MeuCafe();
mc.t = MeuCafe.Tamanho.EXAGERADO;
//Note que a o nome da classe
//continente é necessário
}
}

Enums: construtores, métodos e
variávais
Uma enumeração também pode ter construtores, métodos e
variáveis
enum TamanhoCafezinho {
MEDIO(0.5), GRANDE(1.0), EXAGERADO(1.5);
TamanhoCafezinho(float preco){
this.preco = preco;
}
private float preco;
public float getPreco(){ return preco;}
}

Enums: definindo comportamentos
específicos
Você também pode definir comportamentos específicos para
um enum sobreescrevendo métodos. Veja como:
enum TamanhoCafezinho {
MEDIO(0.5f),
GRANDE(1.0f),
EXAGERADO(1.5f){
public float getPreco(){
return 1000.0f;//se o cliente for mto rico ;)
}
};
TamanhoCafezinho(float preco){
this.preco = preco;
}
private float preco;
public float getPreco(){ return preco;}
}

Questões

Referências
1. Kathy Sierra e Bert Bates, SCJP Sun Certified Programmer
for Java 6 Exam 310-065
2. Palavras reservadas, http://java.sun.
com/docs/books/tutorial/java/nutsandbolts/_keywords.html