• Save
UFCG.JCert Reunião 1 - Declarações e Controle de Acesso
Upcoming SlideShare
Loading in...5
×
 

UFCG.JCert Reunião 1 - Declarações e Controle de Acesso

on

  • 1,624 views

 

Statistics

Views

Total Views
1,624
Views on SlideShare
1,619
Embed Views
5

Actions

Likes
1
Downloads
0
Comments
0

3 Embeds 5

http://www.slideshare.net 2
http://www.slideee.com 2
http://webcache.googleusercontent.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

UFCG.JCert Reunião 1 - Declarações e Controle de Acesso UFCG.JCert Reunião 1 - Declarações e Controle de Acesso Presentation Transcript

  • 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