Baixe Certificação Java SCJP 5 e outras Notas de estudo em PDF para Informática, somente na Docsity!
Revisão Certificação Java 5
Kathy Sierra
Capitulo 1 –Declaração e Controle de Acesso
Identificadores Legais
Os identificadores legais em java, só podem começar por uma letra, $ ou _. Apenas isso
qualquer forma diferente o código não é compilado. Claro que o uso das palavras chaves
não é permitido.
Convenção da Sun
É apenas uma forma organizada de você desenvolver sua sintaxe, porém nada ti obriga a
usar uma em particular, porém a convenção é a mais utilizada por todos os programadores
nato da linguaguem. Veja o seguinte:
Para:
Interface: as letras devem ser maiúsculas e as demais minúsculas se formar um nome
composto o inicio de cada nome deve ser maiúsculo.
Métodos: a primeira letra deve ser minúsculo e seguir o padrão JavaBeans que para obter
algo de um método você usa get, fazer algo setNome.
Variáveis - deve iniciar com letras minúsculas, exceto as declaradas como final e do tipo
enum que é recomendado ser em maiúsculo.
Java Bean Nomeação
A nomeação foi criada para ajudar desenvolvedores a criar componentes java de fácil
interpretação a outros programadores.
Boolean is ou get.
Chamada set – devem usar argumentos ou não e deve retornar um tipo void.
Obter get - não pode ter argumentos e deve retornar um tipo. E ser um método
public(set e get).
Classes
Uma class declarada como padrão(default) ela é pertence apenas aquele pacote(pasta)
aonde ela foi criada.
Não é possível acessar uma default class de um pacote diferente mesmo que ele
tenha um import:
package p;
class Ave{}
package A;
import p.Ave;
class Galo extends Ave{}
Esse codigo nao compila devido minha class Ave ser padrao daquele pacote, ela é dele e
ninguém pode usar (é igual a mulher do seu vizinho, logicamente é dele). A solução para
isso é declarar a class Ave como public assim ela estaria disponível para o mundo, ou seja,
para qualquer pacote. Quando uma class é public você pode importa-la para outro pacote
diferente.
package cap1.Fornecedor;
class Dept {
package cap1.Produto; import cap1.Fornecedor.Dept; public class Prod { public static void main(String[] args) { System. out .println("Produto fornecedor"); }
} /* esse codigo nao compila pois a Class Dept é default entao nao pode ser importada para outro package a nao ser aquele aonde foi declarada, cheio de pegadinha com isso nos simulados */
Class abstrata
As class abstratas elas nunca podem ser declaradas como FINAL , pois uma classes
abstrata ela deve ter alguém que a extenda. E :
Jamais usar FINAL E ABSTRACT juntos tanto para classes quanto para método
abstract.
Uma class abstrata pode ter 1 ou nenhum método abstrato, porem se uma class
concreta tiver um método abstrato, ela deve ser declarada como abstract.
Para se entender de abstrato é aquilo que não real exemplo: veiculo pode ser
qualquer coisa moto, carro, avião. Por isso que não se criar instancia new de
objetos de uma classe abstrata.
Só se cria instancia de uma class quando é algo real. Como Galinha, Carro. Isso ai
posso criar um objeto e fazer dele o que quiser: dar nome, cor, idade etc.
abstract class Lopes{
void setIdade(int d);
package cap1.Carros;
public abstract class Celta {
} package cap1.cliente; import cap1.Carros.Celta; class Cli extends Celta{ public static void main(String args[]){ System. out .println("funfou"); } } /* observe que importei uma class de outro pacote, ela sendo publica e extends a ela*/
/* apesar dela ser static agora, ela só é vista nesse pacote acesso ta - default*/
package cap1.Carros;
public abstract class Aviao { public static String nome ="Boing"; } package cap1.cliente; import cap1.Carros.Aviao; public class Pass extends Aviao{
public static void main(String[] args) { System. out .println( nome ); } } /* Agora sim funciona, percebe como a Sun vai sacanear com isso ne? to errando bastante questoes de declaracao de escopo e fundamentos devido a essa falta de atenção*/
class Bike{
void cor();
class Boy extends Bike{
void cor(){}
public static void main(String ar[]){
new Boy().cor();
/* isso aqui nao compila o metodo da class Bike nao é abstract
deve ser, pq usei ; no final da instrução do método*/
abstract class Bike{
abstract void cor();
class Boy extends Bike{
void cor(){}
public static void main(String ar[]){
new Boy().cor();
/* esse aqui funciona de qualquer forma na implementacao do metodo tanto
com o controle de acesso public ou default so nao pode ser menos restrito
ou seja, um private*/
Interface
É apenas um contrato feito entre class e a interface que ela vai implementar. As interface
serve para o caso do seguinte: Minha class Ferrari ou seja meu carro Ferrari ele vai ser o
único entre outros 10 carros de luxo que vai ter efeitos especiais no painel. Então fazemos
um contrato com a interface que vai prestar esse serviço de adaptar isso a minha Ferrari.
E minha class Ferrari vai cumprir todas as regras da Interface.
interface Efeitos{
void setPiscar();
void setFarol();
class Ferrari implements Efeitos{
void setPiscar(){} //não compila o método deve ser declarado como public
void setFarol(){}//
uma interface é 100% abstrata e não pode ter de maneira nenhuma FINAL em nenhum
métodos dela. A diferença entre interfaces e class abstrata é que nas interfaces não posso
ter momento nenhum um método que não seja abstrato. Mas posso ter variáveis, desde
que seja constante.
As constantes são public static e final
As interfaces são sempre public e abstract implicitamente
O método que implementa a interface deve declarar explicitamente como public
os métodos implementados, senão gera o erro de compilação.
O valor de uma constante após a definição ele não pode ser mais alterado é o
mesmo que você se trancar em um quarto e mandar jogar a chave fora, ai já era
logicamente.
Não temos em interface acesso default, todos são definidos implicitamente de
acordo com que for. Método: public e abstract e variaveis – public static e final.
Interfaces não implementa outra apenas a entende. (extends)
Interfaces são implementadas por classes. E jamais ela implementa uma classe.
A única coisa que interface faz é estender a outra e ser implementada por uma class
concreta.
Class abstrata pode passar a implementação de uma interface para a próxima class
concreta.
package cap1;
public interface Veiculo { int x =10;
package cap1;
public class Carro implements Veiculo{ public void setNome(String n){ n="celta"; System. out .println(n); } public void setPlaca(int p){ p=2568; System. out .println(p); } public static void main(String[] args) { System. out .println( x );// new Carro().setNome("celta"); new Carro().setPlaca(25); }
Modificadores de acesso
É que controla o nível de acesso entre os membros de uma class. Ele pode ser: public,
default, private e protect. Importante falar aqui que uma classe só pode ser default ou
public.
O importante está no nível da class se ela está disponível para outra class visualizar
ela então seu membros(métodos e variáveis) está disponível também para ela, claro
aqueles que for marcado.
//a class B não tem acesso aos membros da class A se declaradas em package diferentes
class A{
public int a=10;
class B{
A i = new A();
i.a;
Observe que as duas têm acesso padrão mais nenhuma conhece a outra, A nem sabe que B
existe pq ela é padrão.(lembrando que elas tanto em package diferentes).
Quando um membro é declarado com public todas as classes têm acesso a ele
mesmo fora do package(claro tem q importar). Lembrando que a class deve ser
public caso contrario nada feito.
Os private pertence aquela mesma class ninguém poderá ver a não ser que seja da
class o qual foi declarado. “o capital na sua conta bancaria é private a somente
você tem acesso certo?”. Pense nisso quando ver algo declarado em uma class
private.
class Conta{
private double real = 1000.0000.000;
protected e default
sao bastante parecidos e confudem muito. Se ligue na idéia deles:
o protected você pode ter acesso ao membro de uma class mesmo que ela esteja fora do
pacote atual, isso através de herança.
default não é possível ter acesso ao membro de outro pacote a não ser q seja aquele que foi
declarado,. Default = = membro é deste pacote e ninguém vai usa-lo, se quiser que entre no
pacote.
Mesmo com uma class public se o membro for default ele não pode ser usado em
outra classes de outros pacotes.
Para um protected não faz diferença se o membro declarado como protected está
fora do pacote, ele é acessado da mesma forma, através da herança.
package cert;
class Ot{
protected int x=9;
int z = 10;
package oth;
import cert.*;
class Her extends Ot{
System.out.println(x);
Lembrando que variáveis de pacotes diferentes(so marcadas como protected) nao sao
herdadas, entao ai nada foi herdado, porem a subclass visualiza o membro de uma class que
esta em outro pacote. Porem o membro z não é visualizado ele nem existe para class Her.
As variáveis locais elas não recebem nenhum modificador de acesso alem de
FINAL. Mas Por que? Simples se elas são locais apenas aquele método ou bloco
então não precisa ter nenhum dos outros modificadores, elas só vão existir ali. Um
exemplo são as variáveis usando em uma instrução for. Ela existe enquanto o for
retorna true. Após isso elas são destruídas.
package cap1.Other; public class Prim { protected static int num = 20; }
package cap1; import cap1.Other.Prim; public class Protect extends Prim{ public static void main(String[] args) { System. out .println( num ); } } /* aqui ele herdou ops visualiza o membro/ / com membro protected nao posso criar uma instancia para acessar o membro protegido assim: Prim p = new Prim(); p.num; / /isso eh invalido para membros protegido o codigo nao compila*/
package cap1;
public class Peca { protected int codPeca=1452; } package cap1.Carros; import cap1.Peca; public class Vectra extends Peca{
public static void main(String[] args) {
System. out .println(codPeca); } }
Exemplos com DEFAULT
package cap1;
class Defau { static int x = 10; } /class que pertence ao pacote/
package cap1.Carros; import cap1.Defau; public class Fau extends Defau{
public static void main(String[] args) { System. out .println(x); } } /* observe que ele nem importa a minha class que eh somente do pacote dela*/ ............................... package cap1;
public class Defau { static int x = 10; } /minha class eh public disponivel para todos, porem o membro so pode ser visto nesse pacote/
package cap1.Carros; import cap1.Defau; public class Fau extends Defau{
public static void main(String[] args) { System. out .println( x ); } } /a class eh importada pq ela eh public porem o membro nao posso acessa- lo de um pacote diferente, somente aonde ele foi declarado isso nao compila/ Exception in thread "main" java.lang.Error: Unresolved compilation problem: The field Defau.x is not visible
As Variaveis Locais – nao podem ter modificadores de Acesso
package cap1;
public class VarLoca {
public static void main(String[] args) { private int x=10; public int z=20; System. out .println(x + z); } } /* isso nao compila as variaveis locais ela pertence somente aquele escopo aonde foi declarada entao nao se pode usar nenhum tipo de modificador de acesso*/
package cap1;
public class VarComp {
public static void main(String[] args) { final int x = 10; System. out .println(x); } } /* isso compila e imprime o resultado, as variaveis locais so podem receber um
- modificador, que é FINAL, pois ele nao eh de acesso e sim modificador de classe
- nao esquecer esse detalhe*/
Métodos FINAIS
O que for declarado como final significa que é uma constante e que não pode ser mudada..
no caso de métodos eles não podem ser subscrito em uma subclass.
package cap1;
public class Fin extends F{ public void setF(){} public static void main(String[] args) { Fin fi = new Fin(); fi.setF(); }
class F{ public final void setF(){System. out .println("final");} } /* isso nao compila tentei subscrever um metodo final*/ .................... package cap1;
public class ArgMet { public void setArg(int x, final int num){ System. out .println(x + " " + num); } public static void main(String[] args) { new ArgMet().setArg(20,30); } } /* esse codigo compila tranquilo, um ponto aqui eh que variaveis de argumentos eh semelhante a variaveis locais, elas nao podem receber nenhum modificador de acesso, apenas os modificadores referente a nao acesso como final*/
package cap1; public class TentARg { public void muda(final int num){ num=50; System. out .println(num); } public static void main(String[] args) { new TentARg().muda(22); } }
***Abstract e Static não se dão bem!!
package cap1;
public abstract class StaticAbt { abstract static void setA(); public static void main(String[] args) {
/* metodo abstratos nao podem ser static*/ ............. package cap1;
public class Varabt { abstract String s = "camilo"; public static void main(String[] args) {
}
/abstract so para metodos e class nada de variaveis/
Métodos Synchronized – É usado para sincronização de métodos e bloco de códigos.
Métodos nativos - é usado para apenas métodos. Lembrando que é um modificador.
Métodos Strictfp - ele força os pontos flutuantes no padrão IEEE 754. O uso desse
modificador é em classes e métodos.
Var-args
Ele permite receber inúmero valores via parâmetro de um tipo declarado.
void x(int...g){}
Posso receber inúmeros parâmetros do tipo int.
Argumento é aquilo que é passado explicitamente. void setI(10);
Parâmetro passo o tipo do que pode receber. Void setD(int a);
Na lista de parâmetros o var-args deve vim sempre por ultimo.
Construtores
Eles são sempre chamados quando um objeto é construído. Não possui nenhum tipo de
retorno. E deve ter o mesmo nome da class.
Não pode ser marcados como static, final nem abstract.
Pode receber um modificador de acesso como protected.
class C{
C(String s){}
class D extends C{
public static void main(){}
/*isso nao compila, o compilador chama super() implicitamente
porem ela nao encontra o contrutor da super s/ argumentos*/
class C{
C(String s){}
class D extends C{
public static void main(){
D(){
super("S");
/nao compila construtor sendo chamado dentro do metodo/
class C{
C(String s){}
class D extends C{
D(){
super("S");
public static void main(){
/* aqui compila */
class C{
C(String s){}
class D extends C{
static D(){
super("S");
public static void main(){
/* não compila um construtor nao pode recber, final, static ou abstract*/
class C{
C(String s){}
class D extends C{
D(){
this();
Enum
É um tipo especial de class.
Os membros de uma enum são constantes.
Pode ser declarado tanto fora quanto dentro da class
Não é valido declarar uma enum dentro de um método.
Os enums são static e final.
enum Coffe{BIG,HUGE}
class Cafe{
public static void main(String args[]){
Coffe c = Coffe.BIG; //a forma de declaracao eh crucial
System.out.println(c);
class EnuClass{
enum Tam{M(10),P(20),G(30);
Tam(int a){
tam=a;
}//fim do contrutor
private int tam;
public int getTam(){
return tam;
}//fim da class especial do tipo enum
public static void main(String args[]){
Tam t = Tam.P;
System.out.println(t+" "+t.getTam());//exibe P 20
import java.util.Scanner;
class ModaLoja{
enum idade{INFANTIL(1),ADULTO(2),JOVEM(3);
idade(int a){
cod=a;
private int cod;
public int getSec(){
return cod;
public static void main(String args[]){
Scanner dados = new Scanner(System.in);
idade id= idade.ADULTO;
System.out.println("Escolha a secao 1 - INFANTIL 2 -ADULTO 3 - JOVEM");
int sec = dados.nextInt();
if(sec==id.getSec()){//se for 2
System.out.println("Voce esta na secao de " + idade.ADULTO);
}}} /* bem complexo esse, mas bem interessante*/
CAPITULO 2
Herança
promove a reutilização de códigos
para usar o polimorfismo
códigos mais claros
o uso de herança previne a duplicação do código.
Por exemplo: em alguns programas fazer a modificação em um lugar teria que rastrear os
outros pontos para alterar também. Com herança isso é quebrado.
Toda subclasse(+ especializada) ela herda os métodos da superclasse.
Exemplo:
class Game{
public void inicio(){
System.out.println("comecou o jogo");
class Mortal extends{
public void sub(){
System.out.println("jogo mortal");
class GameTest{
public static void main(String args[]){
Mortal jogador = new Mortal();
jogador.inicio();
jogador.sub();
obs.: é impresso os dois métodos, porem o ponto chave aqui é que a subclasse herdou o
método da superclasse implicitamente.
class Pc extends Fabrica{
public static void setFa(){System.out.println("fabrica static sub");}
public static void main(String args[]){
Fabrica f = new Pc();
f.setFa();
/* observe aqui que metodos static nao sao herdados, e quando ele chama, é o metodo
da superclass do tipo da variavel e nao do objeto*/
Métodos subscritos
- sempre que tiver uma classe que método de uma superclasse posso subscrever o método
Motivos: é definir um comportamento especifico a determinado tipo de subclasse.
Os métodos abstratos são os mesmo métodos subscritos. Porém nunca sobrecarregados.
Só é possível referenciar a objetos do tipo que a super classe conheça. Você não vai indicar
uma pessoa ou dar referencia boas de uma pessoa para uma vaga de emprego se você
nunca viu e nem conhece essa pessoa certo? Nas classes funciona da mesma forma.
Exemplo:
class Animal{
public void eat(){
System.out.println("class generic");
public class Cavalo extends Animal{
public void eat(){
System.out.println("raça mangalarga");
class AnimalTest{
public static void main(String args[]){
Animal a = new Animal();
Animal b = Cavalo();
a.eat();//class generic
b.eat();//raça mangalarga
o código acima imprime os dois método porem primeiro ele imprime um que é do tipo
animal que é um objeto da classe animal e o segundo é do tipo animal porem é um objeto
da classe Cavalo.Ai ele executa o segundo método, bom ai estamos dizendo também que a
class cavalo É-UM Animal, ou seja ela recebe todas as características de um da class
animal que esteja disponível.
O código abaixo o que está em comentário, caso fosse removido // teríamos problemas na
compilação pois foi definido um método do tipo animal sendo que a class não possui esse
método. Veja:
public class Animal
public void printYour(){
System.out.println("chamei a super class");
class Horse extends Animal{
public void printYour(){
super.printYour();// chama a superclass
public void buck(){}
public class TestAnimal
public static void main(String args[]){
Animal a = new Animal();
Animal b = new Horse();//referencia animal, mais eh um objeto horse
Animal c = new Horse();
a.eat();//chamo o método da classe referente
b.eat();
//dar erro pq a class animal nao tem o metodo buck e sim a class horse.
//c eh um objeto horse mais nao referente a classe animal.
//c.buck(); // esse método não temos no tipo da class animal
Regras a seguir:
O novo método (nível de acesso)pode ser alterado desde que seja menos restritivo
do que substituto.
Não posso trocar um public para um protected porem o inverso é
permitido.(Protected Public)
Tipo de retorno dever ser o mesmo
A lista de argumentos deve ser igual como no método subscrito, senão gera uma
sobrecarga.
