Certificacao Java SCJP 5

Certificao JAVA Reviso Certificao Java 5 Kathy Sierra Capitulo 1 Declarao e Controle de Acesso Identificadores Legais
Os identificadores legais em java, s podem comear por uma letra, $ ou _. Apenas isso qualquer forma diferente o cdigo no compilado. Claro que o uso das palavras chaves no permitido. Conveno da Sun apenas uma forma organizada de voc desenvolver sua sintaxe, porm nada ti obriga a usar uma em particular, porm a conveno a mais utilizada por todos os programadores nato da linguaguem. Veja o seguinte: Para: Interface: as letras devem ser maisculas e as demais minsculas se formar um nome composto o inicio de cada nome deve ser maisculo. Mtodos: a primeira letra deve ser minsculo e seguir o padro JavaBeans que para obter algo de um mtodo voc usa get, fazer algo setNome. Variveis - deve iniciar com letras minsculas, exceto as declaradas como final e do tipo enum que recomendado ser em maisculo. Java Bean Nomeao A nomeao foi criada para ajudar desenvolvedores a criar componentes java de fcil interpretao a outros programadores. Boolean is ou get. Chamada set devem usar argumentos ou no e deve retornar um tipo void. Obter get - no pode ter argumentos e deve retornar um tipo. E ser um mtodo public(set e get). Classes Uma class declarada como padro(default) ela pertence apenas aquele pacote(pasta) aonde ela foi criada. No possvel 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 ningum pode usar ( igual a mulher do seu vizinho, logicamente dele). A soluo para isso declarar a class Ave como public assim ela estaria disponvel para o mundo, ou seja, Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
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 algum que a extenda. E : Jamais usar FINAL E ABSTRACT juntos tanto para classes quanto para mtodo abstract. Uma class abstrata pode ter 1 ou nenhum mtodo abstrato, porem se uma class concreta tiver um mtodo abstrato, ela deve ser declarada como abstract. Para se entender de abstrato aquilo que no real exemplo: veiculo pode ser qualquer coisa moto, carro, avio. Por isso que no 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*/
Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA Se ligue:

package cap1.Produto; import cap1.Fornecedor.*; public class Prod { public static void main(String[] args) { System.out.println("Produto fornecedor"); } } /* essa funciona observe que coloque * na importao informando que vou importar todas as classes visiveis. */ a sintaxe abaixo no compila package cap1.Carros; abstract class Moto { int z=10; } package cap1.cliente; import cap1.Carros.Moto; public class Honda extends Moto{ public static void main(String[] args) { } } Exception in thread "main" java.lang.Error: Unresolved compilation problem: Descubra porque... muita ateno nesse momento....
PEDAGINHAS DO EXAME:
package cap1.Carros; public abstract class Aviao { 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); } } /* isso nao compila a variavel nome da class abstract nao eh static e to tentando acessa-la dentro de um metodo static*/ package cap1.Carros; public abstract class Aviao { 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); }}
Certificao JAVA
/* apesar dela ser static agora, ela s vista nesse pacote acesso 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 ateno*/
4
ta -
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 instruo do mtodo*/ 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. Ento fazemos um contrato com a interface que vai prestar esse servio de adaptar isso a minha Ferrari. E minha class Ferrari vai cumprir todas as regras da Interface.
Certificao JAVA interface Efeitos{ void setPiscar(); void setFarol(); } class Ferrari implements Efeitos{ void setPiscar(){} //no compila o mtodo deve ser declarado como public void setFarol(){}// }
uma interface 100% abstrata e no pode ter de maneira nenhuma FINAL em nenhum mtodos dela. A diferena entre interfaces e class abstrata que nas interfaces no posso ter momento nenhum um mtodo que no seja abstrato. Mas posso ter variveis, desde que seja constante. As constantes so public static e final As interfaces so sempre public e abstract implicitamente O mtodo que implementa a interface deve declarar explicitamente como public os mtodos implementados, seno gera o erro de compilao. O valor de uma constante aps a definio ele no pode ser mais alterado o mesmo que voc se trancar em um quarto e mandar jogar a chave fora, ai j era logicamente. No temos em interface acesso default, todos so definidos implicitamente de acordo com que for. Mtodo: public e abstract e variaveis public static e final. Interfaces no implementa outra apenas a entende. (extends) Interfaces so 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 implementao de uma interface para a prxima 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);//10 new Carro().setNome("celta"); new Carro().setPlaca(25); } }
Certificao JAVA
/* observe que implementei os metodo e acessei minha variavel x - public static e final */ o cdigo abaixo no compila coloquei minha interface com default e tento acessa-la me outro pacote veja. package cap1.inter; interface Moda { String r = "roupa"; } package cap1; public class Loja implements Moda{ public static void main(String args[]){ System.out.println(r); } } Exception in thread "main" java.lang.Error: Unresolved compilation problem: r cannot be resolved Para resolver esse problema devo fazer isso: package cap1.inter; public interface Moda { String r = "roupa"; } package cap1; import cap1.inter.Moda; public class Loja implements Moda{ public static void main(String args[]){ System.out.println(r); } } ............ Observe que isso tambm no compila: package cap1.inter; interface Moda { String r = "roupa"; } /* default nivel de acesso da minha interface*/ package cap1; import cap1.inter.Moda; public class Loja implements Moda{ public static void main(String args[]){ System.out.println(r); } }
Certificao JAVA Modificadores de acesso
que controla o nvel 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 nvel da class se ela est disponvel para outra class visualizar ela ento seu membros(mtodos e variveis) est disponvel tambm para ela, claro aqueles que for marcado. //a class B no 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 tm acesso padro mais nenhuma conhece a outra, A nem sabe que B existe pq ela padro.(lembrando que elas tanto em package diferentes). Quando um membro declarado com public todas as classes tm 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 ningum poder ver a no 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 idia deles: o protected voc pode ter acesso ao membro de uma class mesmo que ela esteja fora do pacote atual, isso atravs de herana. default no possvel ter acesso ao membro de outro pacote a no ser q seja aquele que foi declarado,. Default = = membro deste pacote e ningum vai usa-lo, se quiser que entre no pacote. Mesmo com uma class public se o membro for default ele no pode ser usado em outra classes de outros pacotes. Para um protected no faz diferena se o membro declarado como protected est fora do pacote, ele acessado da mesma forma, atravs da herana.
Certificao JAVA 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 variveis 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 no visualizado ele nem existe para class Her. As variveis locais elas no recebem nenhum modificador de acesso alem de FINAL. Mas Por que? Simples se elas so locais apenas aquele mtodo ou bloco ento no precisa ter nenhum dos outros modificadores, elas s vo existir ali. Um exemplo so as variveis usando em uma instruo for. Ela existe enquanto o for retorna true. Aps isso elas so destrudas.
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); } }
Certificao JAVA
/* nesse aqui uma pegadinha minha variavel nao static e to tentado acessa-la atraves de um metodo static*/ Exception in thread "main" java.lang.Error: Unresolved compilation problem: Cannot make a static reference to the non-static field codPeca
............................................................
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) { Peca p = new Peca(); System.out.println(p.codPeca); } } /* nessa aqui crie uma referencia a instancia para acessar um membro protegido e isso no valido*/cdigo no compila observe o exemplo abaixo mesmo pacote e a varivel foi herdada. package cap1; public class Mem { static int a=10; } package cap1; public class MemTest extends Mem { public static void main(String[] args) { System.out.println(a); } }
.........................................................
package cap1.Other; public class Vava { static int e=20;//sou apenas deste pacote. } package cap1.inter; import cap1.Other.Vava; public class Vv extends Vava{ public static void main(String[] args) { System.out.println(e); } } /* pacotes diferentes, e a variavel nao foi herdada pq nao ta com protected */ /* as variaveis de instancia e metodos sao membros da classe*/
Certificao JAVA 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); }
10
} /* 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 acessalo 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*/
Certificao JAVA
package cap1; public class VarComp { public static void main(String[] args) { final int x = 10; System.out.println(x); }
11
} /* 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*/
Mtodos FINAIS O que for declarado como final significa que uma constante e que no pode ser mudada.. no caso de mtodos eles no 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); } }
Certificao JAVA
/* esse aqui ja nao compila variavel no args nao pode ser alterada * pq eh final*/
12
Mtodos Abstract So mtodos que foi declarado porem no possui implementaes dele. Devem ser implementados pela primeira class concreta que extends a class abstract do mtodo. Ele so deve existir em uma class abstract. So subscritos e no sobrecargados. Uma class abstract pode ter 1 ou nenhum mtodo abstrato Mas se a class tiver pelo menos 1 mtodo abstrato eh obrigatrio ela ser abstract.
package cap1; public abstract class Abt { public void noAbt(){} public static void main(String[] args) { } } /* compila normal eh uma class abstract porem sem nenhum metodo nao h problema nenhum aqui */ ............... package cap1; public class Noabt { public abstract void chama(); public static void main(String[] args) { } } /* isso aqui nao compila metodo abstract em uma class concreta nao rola*/ .................... package cap1; public abstract class PriAbt { abstract private void setP(); } class Pri extends PriAbt{ private void setP(){} public static void main(String args[]){ } } /* pode parecer que ta implementado mais na verdade nao ta, o metodo da class Pri eh dela e nao tem nada ver com o metodo da abstracta que privado, e esse cdigo nao compila devido abstract & private
jamais,
como abstract e final tb nao permitido */ Lembre-se sempre dos modificadores de acesso default eh aplicado tb com classes abstract nada muda.. referente a ser concreta ou abstract.
Certificao JAVA ***Abstract e Static no se do 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*/
13
Mtodos Synchronized usado para sincronizao de mtodos e bloco de cdigos. Mtodos nativos - usado para apenas mtodos. Lembrando que um modificador. Mtodos Strictfp - ele fora os pontos flutuantes no padro IEEE 754. O uso desse modificador em classes e mtodos.
Var-args
Ele permite receber inmero valores via parmetro de um tipo declarado. void x(int...g){} Posso receber inmeros parmetros do tipo int. Argumento aquilo que passado explicitamente. void setI(10); Parmetro passo o tipo do que pode receber. Void setD(int a); Na lista de parmetros o var-args deve vim sempre por ultimo. Construtores Eles so sempre chamados quando um objeto construdo. No possui nenhum tipo de retorno. E deve ter o mesmo nome da class. No 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*/
Certificao JAVA 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(){ } } /* no compila um construtor nao pode recber, final, static ou abstract*/ class C{ C(String s){} } class D extends C{ D(){ this(); } Material desenvolvido Camilo Lopes - Resumo de Estudo
14
Certificao JAVA public static void main(){ } } /* um construtor chamado ele mesmo recusividade e tb a chamada super nao pode entrar ai ja que nao posso ter this e super no mesmo bloco do construtor*/ class C{
15
C(String s){this();} } /* kd o construtor sem argumentos? isso nao compila*/ Variveis Primitivos so as tradicionais como int, float, double etc. uma vez declarado seu tipo jamais pode ser modificado. Variveis de referencia so usadas para se referir a um objeto. E seu tipo no pode ser modificado nunca. Lembrando que pode se referir a um objeto que passa no teste -um . Exemplo : Cachorro extends Animal{} posso referencia minha varivel de referencia para cachorro e para animal j que cachorro passa no teste -UM. Class Animal{} Class Cachorro extends Animal{} Animal s = new Cachorro(); // minha variavel de referencia s, -UM objeto cachorro do tipo Animal. String s1, s2; Estou me referenciando ao mesmo objeto ou seja String. Variveis de instancia Elas esto dentro de uma class, porem fora de qualquer mtodo e s inicializadas com o valor padro ou no quando uma instancia da classe criada. Arrays So nada mais que objetos de um tipo que armazena elementos de um determinado tipo, mais no fundo sempre so objetos. int array[] = new int[3];//instancie meu array que vai receber elemento do tipo int. int []outro;//aqui eh declaracao e nao cria o array propriamente dito. Variveis transient a varivel ignorada para serializao do objeto. Transient = = ignore essa varivel. So aplicado a VARIVEIS DE INSTANCIA. Variveis volatile - aplicado tambm somente a VARIVEIS DE INSTANCIA. Mtodos e variveis static Quando se cria variveis para serem usadas independente de ter uma instancia dessa class. Um membro static so pode acessar outro membro static jamais uma variveis de instancia da class diretamente.
Certificao JAVA Enum um tipo especial de class. Os membros de uma enum so constantes. Pode ser declarado tanto fora quanto dentro da class No valido declarar uma enum dentro de um mtodo. Os enums so 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); } }
16
.............................................
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*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA CAPITULO 2 Herana promove a reutilizao de cdigos para usar o polimorfismo cdigos mais claros o uso de herana previne a duplicao do cdigo.
17
Por exemplo: em alguns programas fazer a modificao em um lugar teria que rastrear os outros pontos para alterar tambm. Com herana isso quebrado. Toda subclasse(+ especializada) ela herda os mtodos 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 mtodos, porem o ponto chave aqui que a subclasse herdou o mtodo da superclasse implicitamente.
Certificao JAVA Relacionamento -UM - conceito baseado na herana de classes ou implementao de interfaces. Esse item um tipo desse outro Exemplo:
18
carro UM veiculo.(carro um tipo de veiculo). Ferrari UM carro.(Ferrari um tipo de carro). No conceito de herana sempre vamos usar o relacionamento -UM, na sintaxe que vimos anteriormente vimos que a class Mortal -UM jogo da class me Game. class Fami{ public void setF(){System.out.println("Minha familia ");} public static void main (String adas[]){ Tio t = new Tio(); t.setF(); } } class Sob extends Fami{} class Tio extends Sob{/*ele herda tb os metodos da super da super*/} - excetos: private. final quer dizer que no pode ser subcrito, porem herdado. static - no so herdado mais visveis para subclass. Polimorfismo muitas Formas - permite programar no geral. quando uma mesma mensagem enviada para um ou vrios objetos, porem os resultados diferente da temos o polimorfismo. Sabemos que todos os animais corre, porem cada um de uma maneira diferente(cavalo, coelho). Sabemos tambm que o estoque armazena produtos, porem para cada empresa um produto diferente, de acordo com o ramo da empresa. Polimorfismo X interface Interface no faz parte da hierarquia de classe ou seja, uma class no pode extends a uma interface mais pode implementa-la. Polimorfismo - faz parte da hierarquia de classe. Uma classe pode herdar atributos da classe me e pode implementar os mtodos.(marcados como abstract). class Fabrica{ public void setF(){System.out.println("FAbrica");} public static void setFa(){System.out.println(" fabrica static ");} } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA 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*/
19
Mtodos subscritos - sempre que tiver uma classe que mtodo de uma superclasse posso subscrever o mtodo Motivos: definir um comportamento especifico a determinado tipo de subclasse. Os mtodos abstratos so os mesmo mtodos subscritos. Porm nunca sobrecarregados. S possvel referenciar a objetos do tipo que a super classe conhea. Voc no 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("raa mangalarga"); } } class AnimalTest{ public static void main(String args[]){ Animal a = new Animal(); Animal b = Cavalo(); a.eat();//class generic b.eat();//raa mangalarga } } o cdigo acima imprime os dois mtodo 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 mtodo, bom ai estamos dizendo tambm que a
Certificao JAVA
20
class cavalo -UM Animal, ou seja ela recebe todas as caractersticas de um da class animal que esteja disponvel. O cdigo abaixo o que est em comentrio, caso fosse removido // teramos problemas na compilao pois foi definido um mtodo do tipo animal sendo que a class no possui esse mtodo. 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 mtodo 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 mtodo no temos no tipo da class animal } } Regras a seguir: O novo mtodo (nvel de acesso)pode ser alterado desde que seja menos restritivo do que substituto. No 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 mtodo subscrito, seno gera uma sobrecarga. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
21
Mtodos estticos no podem ser subscritos. Mais so redefinidos em tempo de execuo chamando o mtodo da superclass do tipo. Super() uma referencia a superclasse. O mtodo subscrito pode ou no lanar uma exceo menos restritiva que a da superclasse.
class DuvS{ public static void main(String args[]){ aviao b = new boing(); b.gol(); }} //super class aviao{ void gol(){ System.out.println("gol");} } //subclass class boing extends aviao{ void gol() throws Exception{} } /* isso nao compila o metodo subcrito ta lanando uma nova Exceo mais abragente, implicitamente o metodo da super lana uma exceo no verificada - RuntimeException*/
................................................................................... Para static isso tambm valido veja: Codigo abaixo tambm no compila.
class DuvS{ public static void main(String args[]){ aviao b = new boing(); b.gol(); }} class aviao{ static void gol(){ System.out.println("gol");} } class boing extends aviao{ static void gol() throws Exception{} }
............................................. J esses compila:

class DuvS{ public static void main(String args[]){ aviao b = new boing(); b.gol(); }} class aviao{ static void gol(){ System.out.println("gol");} } class boing extends aviao{ static void gol() throws RuntimeException{} } //to lanando uma exceo do mesmo tipo da superclass
Certificao JAVA
class DuvS{ public static void main(String args[]){ aviao b = new boing(); b.gol(); }} class aviao{ static void gol() throws Exception{ System.out.println("gol");} } class boing extends aviao{ static void gol() {} } /* isso valido, mesmo que a superclass lance uma excecao a subclasse nao obrigado a lanar, ja que dessa forma implicitamente a subclass lanca RuntimeException*/
22
Mtodos Sobrecarregados Possibilita usar o nome de um mtodo em uma classe varias vezes porem com argumentos diferentes. Exemplo: posso ter dois arquivos com mesmo nome, porem tipo diferentes em formato.(Word, Excel,pdf). Os mtodos sobrecarregados Podem: alterar o tipo de retorno alterar o modificador de acesso(private, protected) ser sobrecarregado na mesma classe ou subclasse. O tipo a que o objeto referenciado que determina qual mtodo ser sobrecarregado. Animal cavalo = new horse(); // objeto horse mais uma referencia a class animal. No subscrito o tipo do objeto. - quando executado o mtodo do objeto e no da referencia. class TV{ public void setMs(TV t){System.out.println("TV");} } class Us extends TV{ //realizando sobrecarga public void setMs(Us u){System.out.println("usuario tv sobrecarregado");} } class LojaTv{ public static void main(String args[]){ TV t = new TV(); t.setMs(t); TV t1 = new Us(); t1.setMs(t1); //ele chama TV Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //na sobrecarga o que vale o tipo e nao objeto criado do //tipo Us }} Para chamar a verso sobrecarrega preciso criar uma varivel de referencia do tipo Us. Outro exemplo que pode confundir: class Teclado{ public void cor(){System.out.println("preto - teclado");} public void cor(String a){System.out.println("teclado " + a);} public static void main(String args[]){ Teclado t = new Teclado(); t.cor(); Teclado c = new Mouse(); c.cor(); //apesar de ter ocorrido uma sobrecarga ele chama o do //objeto ja que o metodo sobrecarregado foi subscrito na //super class Teclado cc = new Mouse(); cc.cor("Verde"); }} class Mouse extends Teclado{ public void cor(){System.out.println("Azul - mouse");} public void cor(String a){System.out.println("mouse "+ a);} } /* ele herda tudo da superclass*/ /* pontos analisar: - metodo cor sobrecarregado na superclass - metodo cor subcrito na subclass */ ..................................................
package cap1; public class Shop { public void setInfo(){System.out.println("Secao de infomatica");} public void setInfo(String secao){System.out.println("Secao " +secao);} public static void main(String[] args) { Shop s = new Shop(); s.setInfo(); s.setInfo("Eletronicos"); Shop sp = new CliInfo(); sp.setInfo("Roupa"); }
23
} class CliInfo extends Shop{ public void setInfo(){System.out.println("cliente esta subscrito");} public void setInfo(String s){System.out.println("novo met " + s);} } /* observe que alterei o nome da variavel do objeto e nao teve problema isso valido, so nao posso alterar o tipo senao eh uma sobrecarga*/
Certificao JAVA
24
Converso de variveis de referencia

Dog d = (Dog)Animal;//para dog converso Aqui estou convertendo a variavel de referencia porque antes disto ela fez: For(Animal animal: array){ Animal.MakeNoise(); If(animal instanceof Dog) Animal.playDead(); //animal nao tem esse mtodo por isso tive que converter para Dog ........................................... class Faunabr{} class Gira extends Faunabr{} class FaunaTest{ public static void main(String args[]){ Faunabr fb = new Faunabr(); Faunabr f = (Gira)fb;//compila mas lanca uma exececao //so compila pq ta na mesma arvore de herana //pq uma fauna nao pode ser uma gira } } ................................................. class Pais{} class Brasil extends Pais{} class PaisT{ public static void main(String args[]){ Pais pb = new Brasil(); Pais p = (Brasil)pb; //isso compila ja que pb um objeto Brasil }} /* lembre-se o que pode ser alterado eh o objeto e nao o tipo dele. ja que pb eh do tipo Pais e referencia a um objeto Brasil posso converter explicitamente pb para Brasil */
Certificao JAVA /* nao compila se o tipo nao fazer parte da arvore de herana*/ /* lanca uma exceo quando tento converter algo impossivel ex: Pais em Brasil:
25
Pais pb = new Pais(); Pais p = (Brasil)pb; isso compila pq os tipos da na arvore de heranca mais na hora de conversao a jvm nao consegue e lana uma exceo ClassCastException*/ .............................................................
public class Capital { public void setName(){System.out.println("Capital");} public static void main(String[] args) { Capital c = new Salvador(); c.setName();//chama da subclass Capital c1 =(Capital) c; //isso eh mesmo que o codigo acima ja que Salvador -uma capital //ele chama o metodo da class Salvador ja que ela subscreve o metodo da Capital c1.setName(); //codigo acima pode ser feito assim mesma coisa Capital c2 = c; //tipo do objeto c2.setName(); Capital c3 = new Capital(); c3.setName();//imrprime da class Capital } } class Salvador extends Capital{ public void setName(){System.out.println("CApital Salvador");} }
Abaixo cdigo que no compila e lana excees:

public class Cidade { public void setName(){System.out.println("Cidade ");} public static void main(String[] args) { Cidade cd = new Cidade(); cd.setName(); //isso compila normal Cidade cd1 = (Valenca)cd; //ja aqui tambm compila porem eh lancada uma exceo //uma cidade nao pode ser Valenca - lembrar que nao posso alterar o tipo de referencia cd1.setName(); } //o fator de compilar que faz parte da mesma arvore de herana } class Valenca extends Cidade{ public void setIdade(){ System.out.println("Mais de 450 anos");} public void setName(){System.out.println("Cidade Valenca");} }
Certificao JAVA
......................... public class Cidade2 { public void setName(){System.out.println("Cidade ");}
26
public static void main(String[] args) { Cidade2 cd = new Feira(); cd.setIdade(); //isso nao compila setIdade, eh um metodo que so tem na class //Feira, entao Cidade2 nao tem por isso que nao compila } } class Feira extends Cidade2{ public void setIdade(){ System.out.println("Mais de 450 anos");} public void setName(){System.out.println("Cidade Feira");} } public class Cidade2 { public void setName(){System.out.println("Cidade ");} public static void main(String[] args) { Cidade2 cd = new Cidade2(); Cidade2 cd2 = (Object)cd; cd2.setName(); //isso nao eh valido ja que nao posso converter para um tipo mais Generico //lembrar que Cidade2 extends a Object } } class Feira extends Cidade2{ public void setIdade(){ System.out.println("Mais de 450 anos");} public void setName(){System.out.println("Cidade Feira");} } Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from Object to Cidade2 ................ public class Cidade2 { public void setName(){System.out.println("Cidade ");} public static void main(String[] args) { Cidade2 cd = new Cidade2(); Cidade2 cd2 = (Feira)cd; //compila vai.. ja que Feira, e Cidade2 est na mesma arvore de herana //porem uma exceo eh lanada em tempo de execucao nao posso converter //uma Cidade em Feira } } class Feira extends Cidade2{ public void setIdade(){ System.out.println("Mais de 450 anos");} public void setName(){System.out.println("Cidade Feira");} } Exception in thread "main" java.lang.ClassCastException:
Certificao JAVA Interface
27
fazemos um contrato com a JVM que todos os mtodos vlidos definido na interface deve ser implementado. Fornecer implementao concreta para todos mtodos da interface marcado como abstract. Seguir as regras de sobrecarga Manter assinatura e o mesmo tipo de retorno(regra de subscrito). Se a classe que implementa for abstrata ela no tem obrigao de implementar todos os mtodos da interface. class vendas implements Loja{ //mtodos aqui } obs.: uma classe pode implementar 2 ou mais interface. class venda implements Loja, comisso{} Lembre-se sempre disso: uma interface jamais vai implementar outra. Uma interface jamais vai implementar uma class Interface no extends a class. interface empregado{ public void setNome(); public String getNome(); } abstract class Venda implements empregado{ string nome; public void setNome(){ nome = "camilo";}} ....................................... interface coca{ void setN(); }
Certificao JAVA interface fanta{ void setN(); } class Clic implements coca,fanta{ public void setN(){System.out.println("Fanta");} public void setN(){System.out.println("Conta");} public static void main(String args[]){ }} /* isso nao compila, devido as duas interfaces ter metodos iguais e quando a class Clic herda eles, so herda 1, nao posso ter dois metodos iguais na mesma class*/ /* se a linha 8 ou 9 for removida ele roda tranquilex*/
28
As interfaces - no possui construtores por no fazer parte da arvores de herana j que eles no pode ser herdado por class.
Tipos de retorno
quando alteramos uma lista de argumentos de um mtodo estamos sobrecarregando, portanto o tipo de retorno valido, no com a super classe. Array um tipo valido de retorno public String []go(){ return new String[]{Camilo,lu}; } void nao pode retornar nenhum tipo de retorno. Retorno a objetos em um mtodo que tenha um tipo de retorno a referencia a um objeto voc pode retorna a qualquer tipo de objeto. public Animal getAnimal(){ return new horse(); // desde que horse extends a Animal. Perceba a diferenca entre os codigos abaixo: O primeiro no compila porque no posso dizer que short -UM int, ele pode ser convertido implicitamente para um int. Agora eu posso dizer que uma subclass -UM subtipo da superclass. A sacada ai o tipo de retorno funciona para objetos do mtodo porem para primitivos apenas o return. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
29
class VarRetur{ int inte(){ return (short)127; } } class vvv extends VarRetur{ short inte(){ return 7; } } /* nao compila isso short nao -UM int, apenas convertido*/ .............................................................. //aqui compila tranqilo... class VarRetur{ VarRetur inte(){ return new VarRetur(); } } class vvv extends VarRetur{ vvv inte(){ return new vvv(); } }
..................................................
Construtores
Serve para inicializar o estado das variveis de instancia. Toda class possui um construtor. Construtores pode usar qualquer modificador de acesso, ate o private . Obs.: os construtores privados somente cdigos dessa class possui acesso.
class PrivateConst{ private PrivateConst(){ } } class PvtC extends PrivateConst{ PvtC(){} } /* nao compila pois a subclasse ta chamando implicitamente(super()) um construtor q ela nao deveria nem conhcer*/
Construtores sobrecarregados
Construtores so chamados apenas por outros construtores jamais por um mtodo. Lembrese eles no so herdados por uma subclasse. Serve para fornecer alternativas do estado inicial e uma varivel de instancia por exemplo: O cliente pode fornecer o nome do cachorro ou o programa pode sugerir um. Isso acontece muito quando vamos cria um e-mail no ato do cadastro o sistema oferece uma sugesto para e-mail. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
class Cotr{ Cotr(){ } } class Cot extends Cotr{ Cot(int z){} } /*implicitamente super()*/
30
........................................... No compila:
class Cotr{ Cotr(int z){ } } class Cot extends Cotr{ Cot(int z){} } /*ele tem uma chamada implicitamente super() mais a superclass nao tem nenhum construtor sem argumento*/
Estticos - static
Garante que somente haver uma referencia a determinada varivel na memria. Static no quer dizer que a varivel ou mtodo no pode ter seu valor alterado (no caso como final). O static permite acessar algo diretamente sem a necessidade de instanciar um objeto. Quando os mtodos ou variveis no so static necessrio criar objetos da classe, ou seja, instanciar.(usar o new). Criando uma instancia: Empresa funcionrio = new Empresa(); // criei um objeto funcionrio da classe empresa.
Exemplo legal. class ClassEstatic{ ///variavel static public static int contador = 0; //variavel de instancia public int outrocontador = 0; //mtodo static Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA public static void incrementa(){ contador++; System.out.println("contador static " + contador); } public void incrementaOutro(){ outrocontador++; System.out.println("contador nao static " + outrocontador); }} class TestStatic{ public static void main(String args[]){ ClassEstatic c1 = new ClassEstatic(); c1.incrementa(); c1.incrementaOutro(); ClassEstatic c2 = new ClassEstatic(); c2.incrementa(); c2.incrementaOutro();
31
/*observe que na saida meu static sofre alterao pq ele recebe o valor e permanece, o nao static ele a cada objeto criado eh zerado o seu valor*/ /*isso pq a varivel no static o valor dela ta disponivel para todos que eh static*/ } }
//posso acessar direto as variaveis static class TestStatic2{ public static void main(String args[]){ ClassEstatic.incrementa(); ClassEstatic c2 = new ClassEstatic(); c2.incrementaOutro(); } }//lembre-se que static nao pode acessar um metodo non-static diretamente
.................................................
class Hip{ static void doSt(){System.out.println("a");}} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA class Jaca extends Hip{ static void doSt(){System.out.println("b");} public static void main(String arg[]){ Jaca.doSt(); Hip j = new Jaca(); // chamado da superclass j.doSt();}}/* o metodos static nao sao subscritos, eles so redefinidos*/
class Membtatic{ static int a=9; int z=5; public static void main(String ar[]){ Membtatic m = new Membtatic(); System.out.println(z); } } //nao compila variavel de instancia sendo referenciado dentro de um // contexto static ......................................
32
CAPITULO 3 Converso de tipos primitivos
A converso ela permite a transformao de valores primitivos de um tipo para outro, de modo explicito ou implcito. Explicito- necessrio que o programador informe ao compilador. Implcito - voc no precisa informar nada ao compilador. Ex.: posso converter um int em long, pois potencialmente long aceita um int mais o inverso deve ser feito de forma explicita.(cast). Voc pode colocar na caixa de TV 20 uma de 20 ou uma menor, jamais uma acima de 20(29,32 etc). O uso das variveis Em java temos a opo de inicializar uma varivel local ou deix-la sem inicializar, porem depende do tipo desta varivel. - variveis locais - antes de serem utilizadas devem possuir um valor de acordo com o seu tipo. - variveis instancia - elas pertence a toda classe e podem ser utilizada com o valor padro adquirido pelo tipo da mesma. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
33
As variveis de instancia refere-se a um objeto recebe um valor padro do tipo da varivel. NULL= significa que a varivel de referencia no foi atribudo nenhum objeto na pilha. J que NULL apenas se refere-se a objeto String.(array[]). static void main(String args[]){} um mtodo da classe. Obs.: pode criar variveis locais e no inicializar e o programa no emitir o erro na compilao, desde que a varivel local no seja utilizada no escopo da declarao. Referencias de objetos locais Quando duas variveis refere-se ao mesmo objeto alterao em um dos 2, vai refletir na outra varivel.
class ReferObjt{ public static void main(String args[]){ Integer i = new Integer(10); Integer j=i; System.out.println(i); System.out.println(j); i+=20; //sera que j ta referenciado ao novo valor de i? System.out.println(i);//imprime 30 System.out.println(j);//imprime o valor 10 } //o fato aqui que wrapper sao finais.. apenas o uso do autoboxing que //ocultou isso na linha i+=20 ele cria outro objeto wrapper para referenciar a esse novo valor } //agora veja esse exemplo class ObjtRefe{ static void metodo(int[] a){ a[1]=5; } public static void main(String ar[]){ int[]objt = {2,1}; for(int a : objt) System.out.print(a +" "); metodo(objt); System.out.println(); for(int a : objt) System.out.print(a +" "); } } /* aqui as coisas eh diferente objetos array sao multaveis alterei o array passado dentro do metodo e refletiu na referencia original*/ //isso funciona para qualquer array multavel, lembre String sao imutaveis //entao nao funciona
Certificao JAVA OBJETOS STRING Os objetos string so inalterveis.
34
Em strings quando se tem duas variveis apontando para o mesmo objeto a JVM atualizara apenas a varivel de referencia. String a = Camilo; String d=a; Se uma alterao ocorre, apenas a vai sofrer alterao, d no sofrer nada. Passando variveis de referencia de objeto Uma varivel de referencia significa que est se passando uma copia dos bits. Passar por valor - significa passar uma copia da varivel o mtodo chamado NO pode alterar a varivel que a chamou variveis de referncia de objetos o mtodo chamado PODE alterar o objeto que a varivel referencia.
class DuvObjtRe{ int array[] = new int[2]; static void go(int [] a){ a[1]=5;} public static void main(String ar[]){ go(new DuvObjtRe().array); for(int z:new DuvObjtRe().array) System.out.println(z); } } //imprime 0,0 devido ser acessado por uma NEW instancia da class //e nao a instancia que foi passada no metodo
.........................................................
class DuvObjtRe{ int array[] = new int[2]; static void go(int [] a){ a[1]=5;} public static void main(String ar[]){ DuvObjtRe b =new DuvObjtRe(); go(b.array); for(int z:b.array) System.out.println(z); } } //agora sim ele imprime com alteracao no objeto original //se ligar nisso para nao errar sao detalhes //que sao facilmente esquecidos
Certificao JAVA ARRAY
35
So objetos que armazena diversas variveis do mesmo tipo . - pode ser primitivo ou de objeto. Mas um array sempre ser um objeto na PILHA. Pode ser criado: int[] array; int array[]; para definir o tamanho do array o objeto deve ser instanciado (criado - new) na pilha. Invlido: int[5] array ; valido: int[] array = new int [10]; array objetos segue a mesma sintaxe. Thread[] array = new Thread[3]; Um array deve ter sempre um tamanho quando for construdo. Sintaxe invalida: int[] carlist = new int[]; // no compila.kd o tamanho? Array multidimensionais So array dentro de array. int[][] array = new int[3][]; Obs: linhas e colunas na verdade um tabela(matriz). Inicializando array objetos Um array de objetos na verdade, ele no armazena objetos, apenas armazena uma referencia a ele. importante lembrar que referencia a objetos sem atribuio sempre ser nulas implicitamente.
class ArryIntege{ public static void main(String args[]){ Integer [] array = new Integer[4]; System.out.println(array[0]);//null impresso
Certificao JAVA
array[1]=1; System.out.println(array[1]); System.out.println(array[0]+2); //lanca uma exceo NullPointException } }
36
NullPointerException
chama um mtodo com referencia nula.
Animal[] pets = new Animal[3]; //aqui tem um objeto na pilha, com trs referencias nulas do tipo Animal, porem no tem nenhum objeto animal. pets[2] = new animal; pets[1] = new animal; Agora tenho dois novos objetos Animal na Pilha. No permitido um valor negativo para ndice de um array. Erros de array causam excees de tempo de execuo e no erros de compilador. Vlidas: int[][] array = new int[3][]; array[0] = new int[4]; //primeiro elemento do array est em um array int de quatro elemento. class biarray{ public static void main(String args[]){ int[][] z = new int[2][]; z[0]=new int[2]; z[1]=new int[1]; z[0][1]=2; z[1][0]=4; System.out.println(z[1][0]);//imprime 4. System.out.println(z[0][0]);//imprime 0 }} /* exemplo massa*/
invlidos
class arrbi{ public static void main(String args[]){ int[] ar = new int[2][]; //invalido a dimensao do array Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA int z[]=[1]new int;//a posicao do colchetes deve vim apos new ou int. }} Loop Array
37
length a nica varivel publica que fornece a quantidade de elementos de um array, ou seja, o seu tamanho. Dog[]array = new Dog[6];//array de 6 referencia ao objeto de Dog. For(int x=0;x<array.length;x++){ array[x] = new dog[]; Atalhos para array Um array pode ser criado e inicializado na sua construo. int[] array = {6,9,8}; O tamanho do array a quantidade de elementos dentro do array. c/ objetos no diferente: Dog puppy = new Dog(Fred);//objeto criado Dog[]array = {puppy,newDog(lupy), new Dog(aiko)}; Pode ser o mesmo que: String [] array = { Fred, lupy,aiko}; Array annimo Criar e inicializar o array. Em um array annimo no pode especificar o tamanho, pois o mesmo est entre virgula. int[] array = new int[]{4,7,2}; Vantagem pode ser usado para um array just-in-time. class foo{ void array(int[] somearray){ //usa o parmetro } public static void main(string [] args){ foo f = new foo(); f.array(new int[] {7,8,6}); //chamo o mtodo e passo por paramento os valores do meu array annimo . }
Certificao JAVA Array de referencia a objetos
38
Se o tipo do array for uma classe podera inserir nele objetos da sub-classe, usando o recurso -UM. class animal{} class cavalo extends animal{} animal[] array = {new cavalo(), new animal()}; Array Interface Quando um array declarado como interface, seus elementos podem fazer referencia apenas as classes que implementa a interface. interface jogo{ void inicio(); } class samurai implements jogo{ public void inicio(){ //implementa os metodos} } class golf{} class test{ public static void main(string [] args){ jogo[] array = new jogo[3]; array[0] = new samurai[]; array[1] = new golf(); // erro golf no implementa a interface jogo e no extends ........................................................ interface JJ{} class Ja extends Jh implements JJ{} class Jh{} class Jtest{ public static void main(String ar[]){ JJ[] array = new JJ[3]; array[0]=new Ja(); //array[1]=new Jh(); //Jh nao implementa a interface apenas Ja }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA Atribuies vlidas e invlidas de referencia objetos de array. Se declarar um array int, a varivel de referencia poder ser um array int. int[] a; int[] b = new int[2]; char[]c = new char[3]; a = b; //valido pq b int e no um array a = c; //invalido para c um char diferente array. As atribuies so aplicadas quando um array -UM MEMBRO.
39
Por exemplo, cavalo um array que pode ser atribudo em Animal, porem Ferrari no pode ser UM-MEMBRO da classe Animal ou interface. class Carro {} class Corsa extends Carro{ static Carro[] car; public void car(Corsa[]c){ }
public static void main(String args[]){ new Corsa().car(car); }} /* isso nao compila o metodo so pode receber corsa[] ou alguma objeto que passe no teste -UM da class corsa. e carro eh um tipo super de corsa.. nem todo carro um corsa */
class iniarray{ iniarray[] ar = new iniarray[2]; public static void main(String args[]){ int [] b = new int[1]; byte x=2;//o valor byte pode ser inserido dentro de um array. b[0]=x; int r[] = new int[0]; char c[] = new char[0]; //r=c;// isso nao compila tipos de objetos diferentes r=b; //isso compila, tipos de objetos iguais Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //r[0]=b;// isso nao compila tipo primitivo com tipo de objeto[] r[0]=b[0] // isso sim System.out.println(new iniarray().ar[0]); System.out.println(b[0]); System.out.println(r[0]); }} Bloco de inicializao - executado quando a classe criada pela primeira vez, ou uma instancia criada. o No possui nomes o No possui argumentos o No retorna a nada Ordem de execuo: 1. static 2. bloco instancia da classe; 3. instancia depois do construtor; class bloco{ {System.out.println("camilo");}//instancia bloco(){ System.out.println("bloco construtor"); } static{System.out.println("lopes static");}
40
public static void main(String args[]){ new bloco(); }} /* olha ordem 1 - static 2 - bloco de instancia(antes de o cdigo do construtor executar); 3 - construtores*/ 2 instancia roda sempre quando se dar um new. Os blocos de Inicializao pode lanar Excees> ExceptionInIninitalizationError um exemplo bsico. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA static int[] array = new int[2]; static{array[3]=4;} lana ExceptionInIninitalizationError e ArrayIndexOutBoundsException .
41
Usando a class Wrapper

- fornecer converso de tipos primitivos em objetos String e virse-versa. o nome do tipo primitivo sempre representado com a letra MINSCULA, exceto para int = Integer e char = Character. Uma class Wrapper: - possui dois construtores 1 primitivo (boolean,byte, double) 2 String exceto o Char - Character que tem apenas o primitivo char. Exemplos: Float f1 = new Float(3.14f);//args com tipo primitivo float Float f2 = new Float("3.14f");//args string Character c1 = new Character('c'); xxxValue() exemplo: intValue, shortValue()
serve para converter o valor de um objeto em um tipo primitivo.
Integer i2 = new Integer(42); double d = i2.doubleValue(); // aqui eh a converso do Objeto Integer para double Float f2 = new Float(3.14f); short s = f2.shortValue();//converso do valor do objeto para tipo primitivo short. xxxValue() parsexxx(String) Wrapper valueOf(String) Converso de objeto Wrapper para primitivo Converso String para primitivo Converso String para Wrapper
parseXXX(), e valueOf() usa o argumento String. valueOf() -> converso de String para Wrapper. Exemplos: double d4 = Double.parseDouble("3.14"); //converto de String para double
Certificao JAVA
42
Double d5 = double.valueOf("3.14"); //converto de String em um objeto class Wrapper toString() - permite uma representao significativa de um objeto. A mesma encontra-se na classe primordial Object. Obs.: as class Wrapper so marcadas como final automaticamente. xxValue() objt primitivo Float objt = new Float(3.85f); int c=objt.intValue(); X parseXx(String) String primitivo int it = Double.parseDouble(3.14);
Exemplo de resumo com as diferenas. class Warp { public static void main(String args[]){ Integer os = new Integer(100);//objeto aqui long a = os.longValue(); //usei acima o xxvalue()//aqui de objeto para um primitivo System.out.println(a); double b = double.parseDouble("3.14");//string aqui System.out.println(b); ///usei o parsexxx() convertendo de String para um tipo primitivo Double db = Double.valueOf("3.87");//string aqui System.out.println(db); //aqui usei valueOf convertendo o string para objeto }}
public class ValuWrap{ public static void main(String args[]){ //convertendo de Wrapper para primitivo Integer i = new Integer(50); int it = i.intValue(); Short s =20; System.out.println("int " +it); System.out.println("short " +s); //wrapper --> primitivo - long Long l=70L; long lo = l.longValue(); System.out.println("Long "+lo); } }
Certificao JAVA AutoBoxing - torna-se + conveniente o uso das classes wrapper.
43
Quando usar == != ? - quando os tipos primitivos de uma classe wrapper forem: Boolean, Byte, Character, Short e Integer. Usa Wrapper adequado para a combinao de conjuntos. Quando quizer que seu conjunto(quando chega Collection vai ver a essncia disso aqui) armazene objetos e primitivos, usa o warppers. - as variveis de referencia wrapper podem ser nulas, por ser objetos. NullPointerException. class Boxing2{ static Integer x;//aqui eu crio se tiver um valor public static void main(String [] args){ doStuf(x); } static void doStuf(int z){ int z2 = 5; System.out.println(z2 + z); } } /*compila porem lana um NullPointerException devido o valor x nao refere-se a nenhum objeto Integer, ento ele nao abre nenhum valor*/ class UseBox{ public static void main(String args[]){ UseBox u = new UseBox(); u.go(5); //chmada ao metodo } boolean go(Integer i){ Boolean ifso = true; //crio um objeto com true Short s = 300; //crio um Short com um valor if(ifso){ System.out.println(++s); //abre, incrementa, encapsula novamente } else{ System.out.println(s); } return !ifso; //se for falso o teste do if } } /*imprime na saida 301*/ //convertir de Wrapper para primitivo xxxvalue //i.shortValue()
Certificao JAVA Sobrecarregado da maneira difcil MTODOS class EasyOver{ static void go(int x){System.out.print("int ");} static void go(long x){System.out.print("long ");} static void go(double x){System.out.print("double ");} public static void main(String [] args){ byte b = 5; short s = 5; long l = 5; float f = 5.0f; go(b); go(s); go(l); go(f); }}
44
No exemplo anterior observamos que no mtodo no temos nenhum args do tipo byte, short e float porem a JVM, ela usou o mtodo menor e AMPLIOU para um maior. Ento short, byte implicitamente convertido para um tipo int. class NoAmplia{ static void go(Integer a){} public static void main (String ddd[]){ go(new Long(5)); } } /* nao posso colocar um Long dentro de um Integer*/ /* o mesmo que tentar colocar uma carreta em uma garagem para um carro impossivel sao objetos diferentes*/
Boxing == e equals
Com objetos wrappers deve se tomar cuidado ao usar = = e equals. = = eles funciona como igualdade ate 127. equals verifica se os valores dos objetos wrapper so iguais.
class WrapTrue{ public static void main(String args[]){ Integer i=10; Integer j=10; Integer m = new Integer(10); System.out.println(i==j);//valor System.out.println(m==j);//objetos System.out.println(i.equals(m));//valor } } true false true
Certificao JAVA
class Autobox{ public static void main(String args[]){ //aqui crio dois objetos com mesmo valor Integer g = new Integer(8); Integer h = new Integer(8); System.out.println(g==h);//true System.out.println(g.equals(h)); //true //aqui economizo memoria tenho dois objetos com mesmo valor primitivo //java 5 funciona normal Integer a=5; Integer c=5; System.out.println(a==c); Boolean v= new Boolean("true"); boolean t=true; Boolean m = new Boolean(t); System.out.println(v==t);//true System.out.println(v==m);//false dois objetos no help com mesmo valor. System.out.println(v.equals(m));//true } }
45
............................................
class Equ{ public static void main(String args[]){ Integer i = new Integer(5); Long ii = new Long(5); int j=5; Integer k = new Integer(5); int m=5; System.out.println(i.equals(k));//true System.out.println(i==j);//true System.out.println(i==k);//false System.out.println(m==k); //true m se refere-se k System.out.println(j.equals(m));//false nao sao do mesmo tipo }//tipos primtivos compara com = = } /* as classes String e Wrapper sobrescreverm o metodo equals*/ /* coidgo nao compila pq to tentando comparar tipos diferentes com equals*/
Sobrecarga com BOXING e Var-args - O boxing um recurso recm criado do java 5, os elaboradores preferiram manter os cdigos existente, a AMPLIAO mais preferida ou seja tem mais prioridade que BOXING e que var-args. static void go(Byte x,); static void go(byte y); //esse metodo chamado ------------------------class AddBoxing{ static void go(Integer x){System.out.println("Integer ");} static void go(long x){System.out.println("long ");} public static void main(String [] args){ int i = 5; go(i); //ele chama o long devido ampliar para o maior }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA E BOXING e VAR-ARGS quem tem mais prioridade? O boxing tem mais preferncia de prioridade que os var-args. - os var-args um mtodo de captura total.(vai se abordado l na frente). class BoxorVar{ static void go(Byte x, Byte y){System.out.println("Byte, Byte ");} static void go(byte...x){System.out.println("byte...");}
46
public static void main(String [] args){ byte b= 5; go(b,b);//aqui ele chama o meu boxing devido ter preferencia maior que meu vararg //a saida em Byte, Byte } } ..................
class SobreCarg{ static void go(Integer x){System.out.println("autoboxing "+x);} static void go(int...x){System.out.println("var args"+x);} public static void main(String args[]){ go(5); } } autoboxing 5
Ampliando Variveis de Referencia - em variveis de referencia (objetos) a ampliao de herana, ou seja, -UM. class Animal{static void eat(){}} class Dog extends Animal{ public static void main(String args[]){ Dog d = new Dog(); d.go(d);//eh valido devido d ser um dog.. e dog ser um animal } void go(Animal a){ System.out.println("dog eh um animal ampliado com sucesso"); } //aqui eu tenho um objeto animal //entao qualquer classe q herde animal pode chamar esse metodo } o cdigo permitido sem problemas pois Dog um animal, ento tudo que animal faz dog tambm faz. Houve AMPLIAO de dog para animal. - a ampliao permitida da class que extends a class pai. Uma class Wrapper no possvel ampliar, pois no valido dizer que Short -UM Integer.
Certificao JAVA class Dog4{ public static void main(String[] camilo){ Dog4 d= new Dog4(); d.test(new Integer(5)); } void test(Long x){} } //no possvel nenhuma class wrapper pode ser apliada um Short no eh um Integer. Sobrecarga na Combinao de ampliao com BOXING No possvel ampliar e depois fazer boxing(objeto). Porem o compilador PODE fazer um BOXING seguida por uma operao de ampliao. Invlido: static void go(Long x){} byte b =5; go(b); // precisa ampliar para depois converter muita coisa par o compilador. ................................. class WindenBox{ static void go(Long x){System.out.println("Long");} public static void main(String[]args){ byte b=5; go(b); //precisa ampliar para depois fazer o boxing NAO VALIDO isso // muita coisa para o compilador. }} /*WindenBox.java:5: go(java.lang.Long) in WindenBox cannot be applied to (byte) go(b);*/ Vlido: class BoxWiden{ static void go(Object o){ Byte b2 = (Byte)o; System.out.println(b2); } public static void main(String [] args){ byte b= 5; go(b); }} //amplio para objeto(boxing) //imprime cinco normal
47
Certificao JAVA Sobrecarga em combinao com VAR-ARGS - possivel combinar var-args com ampliao ou com BOXING. static void Wid_var(long...x){} static void box_va(Integer...x){} int i = 5; Wid_var(5,5); box_va(5,5); class Varg{ static void wide_var(long...x){System.out.println("long...");} static void box_var(Integer...x){System.out.println("Integer");} public static void main(String args[]){ int i = 5; wide_var(i); box_var(i); }} //ele imprimi os dois metodo posso combinar var-args //com boxing e ampliar //entao eu ampliei 5 para var-args e depois para o boxing
48
Coletor de lixo uma soluo automtica em Java para o gerenciamento da memria. A coleta de lixo gira em todo objeto que no possa ser alcanado pelo programa. Esse objeto encontra-se na memria heap.(cuidado para no confudir, com pilha stack). public class GargabeTruck{ public static void main(String args[]){ StringBuffer sb = new StringBuffer("Ola"); // instancia meu objt e apontando System.out.println(sb); // imprimindo meu objt sb=null; // minha variavel nao aponta para nenhum objt //sujeito a coleta se o caminho do lixo passar }} //StringBuffer pertence a class object Exemplo 2: mostra o ponto que um objeto eh coletado public class Gargabe2{ public static void main(String args[]){ StringBuffer variavelreferencia = new StringBuffer("Rodando lixo"); StringBuffer variavelreferencia2 = new StringBuffer("Rodando lixo 2"); System.out.println(variavelreferencia); variavelreferencia = variavelreferencia2; // aqui minha variavel de referencia aponta para o objeto //ela nao eh alcanavel para coleta }}
Certificao JAVA Exemplo 3: mostra o tamanho da memria antes e depois do coletor se ele passar.
49
import java.util.Date; class Check{ public static void main(String [] args){ Runtime rt = Runtime.getRuntime(); System.out.println("total JVM memory " + rt.totalMemory()); System.out.println("LIVRE JVM memory " + rt.freeMemory()); Date d = null; for(int i=0;i<10000;i++){ d = new Date(); d = null; } System.out.println("depois de after memory = " + rt.freeMemory());//depois rt.gc(); System.out.println("depois after gc = " + rt.freeMemory()); }} class Coleta{ public void get(){ //apos execucacao do metodo objeto disponivel para coleta StringBuilder sb = new StringBuilder(); } public static void main (String args[]){ new Coleta().get(); Coleta c=null;//configurei para o valor null disponiel para coleta } } Mtodo finalize() um mtodo que no se pode contar para sua execuo. * qualquer objeto chamara o finalize() apenas uma vez. * o foco principal que informa ao cdigo q seja executado ate sua excluso(objeto) do heap. * qualquer exceo lanada por esse mtodo ignorado pelo coletor de lixo. * o modificador padro protected porem posso alterar apenas para public
Certificao JAVA CAPITULO 4 Operadores A precedncia de valores sempre ser avaliada a expresso da direita. int x=8; x += 2 + 5; COMPARAO os operadores de comparao sempre resultam em um valor booleano(true ou false). class CompareTest{ public static void main(String [] args){ boolean b = 100 > 99; System.out.println("o valor eh " + b); // imprime true por ser > } } no pode comparar tipos diferentes. Por exemplo, no posso perguntar se um boolean um char? temos uma exceo um valor flutuante pode se comparar com valores inteiros double int.
class DoubleInt{ public static void main(String ar[]){ int a=4; double b=4.0; System.out.println(a==b); //true } }
50
Nunca confundir = com = = so completamente diferente o = atribuio o = = comparao. import java.awt.Button; class CompareRef{ public static void main(String [] args){ Button a = new Button("exit"); //aqui eh outro objeto no heap com o mesmo valor do objt a Button b = new Button("exit"); Button c=a;//aqui referencia ao mesmo objeto System.out.println("is referece a = = b? " + (a = = b));//false System.out.println("is referece a = = c? " + (a= =c));//true }} Para os valores boolean voc pode usar = dentro de um if. boolean b = true; if(b = false); // ele recebe false no compara //invalido int x=1; if(x = 0)// x inteiro e no booleano. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA ENUMS Para enums pode usar o = = ou equals() para comparao das duas variveis. class EnumEqua2l{ enum Color{RED, BLUE} public static void main(String args[]){ Color c1 = Color.RED; Color c2 = Color.BLUE; if(c1= =c2){ System.out.println("= ="); } if(c1.equals(c2)){System.out.println("dot equals");} }}
enum Fest{CARNAVAL,SAOJOAO,NATAL} class Em{ public static void main(String args[]){ Fest f = Fest.NATAL; System.out.println(f.toString()); } } ...................... class Festa{ enum zorra{TIRADENTES,SOLDADO}; //static,public,protected. default - valido //abstract, final - invalido public static void main(String args[]){ System.out.println(zorra.SOLDADO); } } ..................... NO COMPILA class Enum{ final enum Pu {FUTEBOL, VOLEI,BOXE}; public static void main(String args[]){ System.out.println(Pu.BOXE==Pu.BOXE); Pu p = Pu.FUTEBOL; Pu p2 = Pu.FUTEBOL; System.out.println(p.equals(p2)); } } //nao compila olha o modificar de acesso de enum ........................................ class Enum{ abstract enum Pu {FUTEBOL, VOLEI,BOXE}; public static void main(String args[]){ System.out.println(Pu.BOXE==Pu.BOXE); Pu p = Pu.FUTEBOL; Pu p2 = Pu.FUTEBOL; System.out.println(p.equals(p2)); } } //nao compila olha o modificar de acesso de enum
51
Certificao JAVA
52
instanceof
este operador usado apenas para variveis de referencia de objeto para verificar se um objeto especifico de outro. class A{} class B extends A{ public static void main(String args[]){ A meuA = new B(); // um objeto de b do tipo A B meuB = new B(); m2(meuA); } public static void m2(A a){//esse metodo so recebe argumento que seja da classe pai if(a instanceof B) ((B)a).doStuf(); // converto o objeto 'a' em b } public static void doStuf(){ System.out.println(" 'a refere to a 'B'"); }} um objeto s vai ser especifico do outro se passar no teste -UM. bom lembrar que se uma class implementa uma interface ela faz parte do teste UM ento temos ai um instanceof valido: interface foo{} class a implements foo{} class b extends a{} a a = new a(); b b = new b(); a instanceof Foo b instanceof a b instanceof Foo;//implementao indiretamente Cdigo invalido para instanceof. class Cat{} class Dog{ public static void main(String[] args){ Dog d = new Dog();// novo objeto de dog System.out.println(d instanceof Cat); } } /* aqui dar pau ja q d nem conhece Cat*/ /* para ser verdadeiro teria que usar -UM.*/
Certificao JAVA
53
Os arrays so objetos em qualquer circunstancia e sempre ser uma instancia de Object. Concatenao de Strings O operador de + pode concatenar String e somar int, porem depende do valor a sua esquerda ou nvel de precedncia. String a = string; int b= 3; int c = 7; System.out.println(a + b + c); No cdigo acima ele no soma os inteiros por ter uma string a esquerda. System.out.println(x.foo() + 7); Nessa cdigo ele depende do resultado metodo para saber o que vai fazer concatenar ou somar. Acrscimo e decrscimo Aumenta ou diminui o valor de uma varivel. Uma regra interessante que o operador ps-fixado(i++) s incrementado aps a exibio do valor, enquanto no ser pre-incrementado(++i) o pr faz o inverso, realiza antes da varivel ser usada: Varivel FINAL Lembre-se que varivel final no pode ser alteradas, ento operadores de incremento ou diminuio gera um erro de compilao. final int x=5; x++; ..........
class TEstFinl{ static final int z; public static void main(String ar[]){ System.out.println(z ); } } /* nao compila variaveis declarada como final deve ter um valor padrao antes de seu uso*/ // elas nao recebe valor padro
Operador ternario usado para avaliar expresses booleanos de modo semelhante ao if. class Salary{ public static void main(String args[]){ int num = 3; String status =(num<2)?"per limit" : "false limite"; System.out.println("o result eh " + status); }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
54
Operadores lgicos de abreviao Serve para avaliar instrues com mais de uma expresso. && ele verifica as duas expresses uma sendo verdadeira ambas precisa ser verdadeira. Ele no verifica o segundo se o primeiro falso. | | ele verifica um dos dois operando, se o primeiro verdadeiro ele no avalia o segundo. class TestOr { public static void main(String args[]){ if((isIt(3)) || (isIt(7))){ System.out.println("result is true"); } if((isIt(6)) || (isIt(9))){ System.out.println("result is true"); } } public static boolean isIt(int i){ if(i < 5){ System.out.println("i < 5"); return true; } else{ System.out.println("i >= 5"); return false; }}} Operadores sem abreviao Esses operadores avaliam os dois lados das expresses. & mesmo se a primeira expresso for falsa ele avalia a segunda. | mesmo a primeira expresso sendo verdadeiro ele analisa a segunda. ^ avalia somente valores booleanos, ele avalia ambos operando. E se um for true retorna true. ! ele inverte o expresso se true passa a ser false. if(!(7= =5)){System.out.println(not equals);} // if 7 for diferente de 5 ele imprime.
class Oper{ public static void main(String args[]){ boolean b=false; System.out.println(b&&(3>5)); System.out.println(!b&&(5>3));//inverte apenas nessa expresso System.out.println(b); } } false true false
Certificao JAVA ...............................................................

public class OpeCirc { public static void main(String[] args) { boolean c=true; boolean d = false; System.out.println(c^d); System.out.println(d^c); System.out.println(false^false); } } //^ teste os dois operandos se 1 for true resultado sempre sera true independente da ordem
55
...............................
public class OpeOu { public static void main(String[] args) { System.out.println(2>3 | 4 >2); // testa os dois operando System.out.println(8>2 || 1<0);// a segunda expressao nunca eh avaliado //ja que a primeira true } } /* operadores que sempre avalisa a segunda expressao ^, |, & */
CAPITULO 5 Controle de Fluxo ,Excees e Assertivas Expressoes vlida com IF So podem aceitar valores booleanos Em java 0 = = false e 1 = = true nao valido. int trueInt =1; int falseInt =0; if(truInt = = true){} // invalido if(trueInt= = 1){} // valido A nica varivel que pode ser atribuda na instruo if booleana. boolean a = true if(a = false){} // valido //invalido if(x = 3){}
Switch
a maneira de simular varias instrues if O break opcional porem causa mudana no resultado na remoo dele. char, short,byte,int ou enum sao permitido no teste SWITCH no possvel compilar se o teste for: long, float e double. O valor do case deve ser constante.
Certificao JAVA final int a=1; //valido final int b;//invalido b = 2; Se uma varivel for menor que o tipo int convertido desde, siga a regra do tipo byte g =2; switch(g){ case 23://valido case 128: // invalido muito grande para um byte.
56
Cada case tem o valor nico. Boxing valido. Mais lembre-se que fazer o boxing o valor da varivel no valido mesmo que declare ela como final. Pois as classes wrapper no so consideradas como constantes. Ou seja no posso colocar a varivel wrapper como opo no meu case. switch(new Integer(4)){} Procure sempre por erros de sintaxe: case 0{} // omitiu os : switch(x){ 0 : {} // omitiu o case class BoxinVar{ public static void main(String args[]){ Integer x=1; final Integer x2=1; switch(x){ case x2:System.out.println("ok");//o valor aqui deve ser constante default: System.out.println("fim"); } }
} /* isso nao compila o meu case nao tem um valor constante mesmo que a variavel seja declarada como final*/ ..........................................................................................
class Swrap{ public static void main(String args[]){ Integer g=5; switch(g){ case 1: case 2: case 3: default: System.out.println("fim"); } }} //obseserve que meu case eh constante
Certificao JAVA
57
Break O importante que switch, ele funciona de cima para baixo, a partir de encontrar um case verdadeiro, ento tudo abaixo ser executado, na excluso do break. class sw1{ public static void main(String args[]){ int x = 3; switch(x){ case 1: System.out.println("x is equal to 1"); break; case 2: System.out.println("x is equal to 2"); break; case 3: System.out.println("x is equal to 3"); break; default: System.out.println("valor nao encontrado"); } }} quando o programa encontra a palavra-chave break ele sai do Switch. O processo sem o break chamado de passagem completa. O uso do break quando voc quer que apenas aquela instruo que for satisfatria seja executada. Aps a sada do switch o que estiver fora ser executada manualmente. Default se nenhuma instruo case for satisfatria A instruo default pode aparecer em, qualquer lugar e segue com a mesma regra do break ou sem o break. O default funciona com passagem completa por isso recomendvel o uso no final, porem no exame no pode acontece isso. Alguns exemplos: public class sw2{ public static void main(String args[]){ String s = "xyz"; switch(s.length()){ case 1: System.out.println("length is on"); break; case 2: System.out.println("length is two"); break; default: System.out.println("nao macth"); } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
58
}}/* aqui ele olha o tamanho do objeto string que possui 3 caracteres length() = = tamanho"*/ class swbyte{ public static void main(String args[]){ byte x = 3; switch(x){ case 1: System.out.println("x is equal to 1"); case 128: System.out.println("x eh 128"); }}} /*dar erro byte nao pode ser 128, valor muito grande para um byte swbyte.java:7: possible loss of precisi found : int required: byte case 128: ^ 1 error */ class Sbreak{ enum Color{RED, BLUE, WRITE} public static void main(String args[]){ Color c = Color.BLUE; switch(c){ case RED:System.out.println("red"); case BLUE:System.out.println("blue"); case WRITE:System.out.println("write"); default:System.out.println("Cor nao encontrada"); } }} /* aqui no usei o break, ento quando ele encontrou o case verdadeiro ele executou ele e todos os demais case e o default tb, que no funciona de uma forma diferente.*/ class SwDefault2{ public static void main(String args[]){ int y = 5; switch(y){ case 1: System.out.println("eh um"); case 2 : System.out.println("eh dois"); default:System.out.println("nao eh nenhum numero valido"); case 3: Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA System.out.println("eh tres");
59
}}} /* aqui ele procura o teste do switch se nao achar default nele.. e executa tudo baixo do default ou seja o case 3, executado pois temos uma passagem por completa, omitimos o uso do break. ................................................... class SwDefault{ public static void main(String args[]){ int y = 5; switch(y){ case 1: System.out.println("eh um"); case 2 : System.out.println("eh dois"); case 3: System.out.println("eh tres"); default:System.out.println("nao eh nenhum numero valido"); }}} . class SwBox{ public static void main(String [] lopes){ switch(new Integer(4)){ case 4:System.out.println("Boxing ok"); break; default: System.out.println("nada encontrado"); }}} /*lembre que valido apenas char,byte,short,int ao nao ser q ser convertido usando boxing*/ class SwBox2{ public static void main(String [] lopes){ switch(new Character('a')){ case 'a':System.out.println("Boxing ok"); break; default: System.out.println("nada encontrado"); }}} /*lembre que valido apenas char,byte,short,int ao n ser q ser convertido usando boxing*/ class SwChar{ public static void main(String args[]){ char z = 'a'; switch(z){ case 'a':System.out.println("is a"); break; case 'b':System.out.println("is b"); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA default: System.out.println("caracter nao encontrado"); } }} /*aqui eh sem o boxing*/ For bsico
60
Mais flexvel que o for aprimorado necessrio informar quantas vezes quiser saber que tem que executar as instrues do bloco do loop. Dentro da declarao possvel colocar mais de uma varivel S pode existir uma expresso TESTE. for(int x=0;(x>5),(y<2);x++){}//invalido As saidas foradas: break, return, exeo, System.exit(), o loop encerrado e no a interao. for(int x=0; x < 3;x++){ System.out.println("in loop"); return true; } return true; } break, return e System.exit() Possui diferenas entre o uso dos trs loop. Break ele sai do loop e executa a prxima instruo Return ele sai do loop e retorna ao mtodo chamador. System.exit() o programa interrompido e a JVM encerrada. As trs declaraes de um loop no so obrigatrias ausncia(trs) causa um loop infinito. int i =0; for(;i<10;){ i++; } As variveis precisam ser do mesmo tipo. Uma varivel apenas que utilizar dentro do loop pode cham-la fora. E uma declarada apenas dentro do loop no pode ser chamada fora do loop. As trs expresses so independentes da outra. No precisa operar sobre as mesmas variveis int b =3; for(int a=1;b!=1;System.out.println("intere")){ b=b-a; } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
61
For aprimorado Simplifica a tarefa de fazer um loop atravs de um array ou conjunto. Possui apenas dois componentes: declarao varivel de um tipo compatvel expresso avalia o loop. Pode ser: primitivo, objeto, ou array bidimensional. for(Declarao : expresao){} - for(String s : s){} NO COMPILA:
class ForEach{ public static void main(String args[]){ int[]array={1,2,3}; for(int[] a: array) System.out.println(a); } } /* nao compila ele me traz int e nao um array de int[]*/ //a cada iteracao eh um tipo primitivo int que vai ser //passado por isso que nao compila
......................... COMPILA
class ForEach{ public static void main(String args[]){ int[]array={1,2,3}; for(int a: array) System.out.println(a); } }
Break e Continue So usados para encerrar um loop interno ou apenas a interao atual. break encerra o loop e inicia a prxima linha. So pode ser usada dentro do loop e switch.
class BreakIf{ public static void main(String arg[]){ if(2==2) break; } }//nao compila ou swicth ou loop(for, while, do while)
continue encerra apenas a interao do loop atual, a prxima continua normalmente se for atendida. class ForContinue{ public static void main(String args[]){ for(int x=0;x<4;x++){ if(x= =3){ continue; } //so eh exibido quando if for falso System.out.println(x); }}} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
62
Instrues no rotuladas O comando break ele sai do loop. No permitido informar aonde o break sai do loop, porem no rotulada usa-se mais em loop no aninhados. Instrues rotuladas necessrio somente nas situaes de um loop aninhado, onde preciso indicar qual loop deseja encerrar. Por exemplo, tenho dois for e quero encerrar apenas o for interno s usar rotulo. class RotCont{ public static void main(String args[]){ lopes: for(int i=0;i<5;i++){ for(int j=0; j<5;j++){ System.out.println("hello"); continue lopes; }//fim do loop for interno System.out.println("outer");//nunca sera exibido pq ele pula }//fim do primeiro for System.out.println("good-bye"); } } /*observe o q acontece :ele pula a iterao de imprimir outer, e retorna para o inicio do rotulo que esta no primeiro for.*/ class BreakRotu{ public static void main(String args[]){ boolean istrue = true; //rotulo outer: for(int i=0;i<5;i++){ while(istrue){ System.out.println("hello"); break outer; //fim do for interno } //nunca sera impresso pq while eh true System.out.println("outer loop"); }//fim do loop for externo System.out.println("good-bye"); }} /*olha o que ele faz... ele imprime o hello e sai do for rotulado que i e imprime a proxima instruo apos o for que eh goodbye outer loop nunca ser impresso pq ta dentro do for*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
63
class BreakRot{ public static void main(String args[]){ rot: for(int x=0;x<4;x++){ if(x= =2){ break rot; } System.out.println(x); } System.out.println(y); }} /* observe que quando atingir 2 ele sai do for rotulado*/ class RotIdd{ public static void main(String args[]){ int id=15; rot: while(id<=21){ id++; if(id==16){ System.out.println("lincenca de motor"); continue rot; } System.out.println("year" + id);//linha 11 }} } /* observe que a linha 11 so eh executada se o if for false*/ /* quando eh true ele continua o bloco rotulado*/
Tratamento de Excees
Exceo uma ocorrncia que altera o fluxo do programa. As excees podem ocorrer por falhas de hardware, exausto de recursos e os erros. A palavra try e cacth serve para informar a JVM o que fazer quando ocorrer uma exceo. Os blocos catch deve aparecer aps o try isso um REQUISITO; entre os blocos no pode possui nenhuma instruo. Quando uma exceo identificada no try{} o restante do cdigo no executado e no h um retorno para o termino do cdigo. try - usada para indicar um bloco de cdigo que possa ocorrer uma exceo. finally - sempre ser executado depois do bloco try, se nenhuma exceo for lanada, em caso positivo ser lanado aps o bloco catch.. Mas independente esse bloco ser executado.(Exceto nos caso de encerratamento da jvm . System.exit()). catch serve para manipular as excees. valido ter try{} c/ finally sem o catch INVALIDO ter try sem catch ou finally. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
64
As excees a instancia de uma classe que tem a classe Exception na hierarquia de herana. Class error indica avisos que no ocorreria normalmente na JVM, por exemplo falta de MEMRIA. Porem ele compilado sem problema mesmos se no for manipulado(catch). Error no so excees pois no pertence a classe Exception.
Certificao JAVA
65
OBJECT Pai de todas as classes de excees THROWABLE Super class das excees verificadas
No so excees
ERROR
EXCEPTION
RUNTIMEEXCEPTION Super class Excees no verificadas
Certificao JAVA Veja alguns exemplos que fiz: class Lopes{ public void add(int a, int b) throws Exception{ if(b= =a) throw new Exception("os valores sao iguais"); System.out.println("os valores sao diferentes"); } } class TestLopes{ public static void main(String args[]){ Lopes in = new Lopes(); int a=5; int b=5; try{ in.add(a,b); } catch(Exception e){ System.out.printf(e.getMessage()); } }} //throw palavra chave que manda o java parar tudo e comear a jogar a bomba; //throws a palavra chave que trata uma bomba lanada, jogando-a para "tras"; exemplo 2: class Exce{ public static void main(String[] args){ int a=2; try{ if(a= =2) throw new Exception(); System.out.println("codigo sem excecao"); } catch(Exception e){ System.out.println("uma execao foi lancada"); }} }
66
Certificao JAVA exemplo 3: class Propag{ public static void main(String args[]){ Propag in = new Propag(); try{ in.reverse(""); } catch(Exception a){ System.out.println("ocorreu uma excecao"); } finally{ System.out.println("fim de execucao"); } } //o throws ele trata a bomba lanada void reverse(String a) throws Exception{ if(a.length()==0){ throw new Exception();//lanco a execao } }}
67
exemplo 4 class BadFood extends Exception{ void check(String fruta) throws BadFood{ if(fruta!="banana"){ throw new BadFood(); } System.out.println("alimento aceito"); }} class MyException{ public static void main(String args[]){ BadFood ob = new BadFood(); try{ ob.check("maca"); } catch(BadFood e){ System.out.println("ocorreu uma excecao"); } }} /*aqui eu criei minha prpria exceo*/
.......................... Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA import java.io.IOException; import java.io.FileReader; import java.io.BufferedReader; import java.io.File; import java.io.PrintWriter; class ArqExc{ public static void main (String args[]){ File f = new File("Ioex.txt"); try{ FileReader fr = new FileReader(f); BufferedReader br = new BufferedReader(fr); String s = br.readLine(); }catch(IOException e){ try{ f.createNewFile(); } catch(IOException z){} } finally{ System.out.println("aprendendo"); } }} /* esse codigo lanca uma execao pq nao encontra o arquivo porem ela trata criando o arquivo caso ele nao for encontrado, isso eh uma das essencia de tratamento de exees em codigo perigosos*/ ...........
import java.io.File; import java.io.PrintWriter; import java.io.IOException; class ArqV{ public static void main(String ar[]){ File f = new File("avioes.txt"); boolean b = f.exists(); if(b==false){ try{ PrintWriter pw = new PrintWriter(f); }catch(IOException e){e.printStackTrace();} } System.out.println(f.exists()); } }
68
Esse cdigo acima verifica se o arquivo existe antes de tentar criar, caso negativo o arquivo criado e no final exibe se ele foi criado ou no*/
Certificao JAVA
69
Assertion
usando na fase de desenvolvimento afim de manter tudo funcionando tanto com eles habilitado ou no. Assertion deve ser sempre true, nunca false, seno lanada uma exceo. Um uso bastante de assertion ter certeza que o valor testado jamais pode vai ser falso. Regras a seguir: Assertion no pode ser usado no lugar do if... Assertion no pode testar mtodos pblicos ou argumentos digitado pelo usurio No pode apresentar efeitos colaterais no programa. Ou seja,o seu programa deve rodar tanto com ele habilitado ou no. Assertion vem desabilitado por padro. Obs.: o fator de poder no usar, no quer dizer que no compila so no recomendado. Pois as probabilidades de ocorrer AssertionError so maiores. Verso 1.3 Java Na verso 1.3 assertion um identificador valido, a partir da verso 1.4 ele se tornou uma palavra-chave. javac source 1.3 minhaclass.java - compilei meu cdigo com assertion como identificador. javac -source 1.5 minhaclass.java compilei como palavra chave.(a partir 1.4)
Habilitando e desabilitando assertion

habilita java ea minha.java java enableassertion minhaclss.java desabilita java de classe.java java disableassertion classe.java outros comandos: java ea da:pacote.carro habilito no mbito geral e desabilito apenas em pacote.carro e seus subpacotes. java -ea da:pacote.classe.java desabilito apenas para a classe.java
Certificao JAVA
//tiver habilitado lana uma excecao AssertionError class Asert{ private static void setD(int z){ boolean b=true; assert(z>0):"valor invalido na linha 3"; assert(b=false); System.out.println(z); } public static void main(String args[]){ setD(1); } }
70
..................
class Assert{ //usando assertivas public static void main(String args[]){ int z=4; assert(z==2):"erro na linha 6"; System.out.println(true); } }
CAPITULO 6 Class String String em Java sempre so objetos. Os objetos String eles nunca poder ser alterado, aps ter recebido um valor. A varivel que o referencia altervel Um objeto sem referencia a ele perdido. x.concat(Camilo); //cad a referencia? x = x.concat(Lopes); //aqui com referencia. Pool onde fica uma string literal. A string literal o valor que a varivel referenciada recebe. Exemplos do uso da class String. class String1{ public static void main(String args[]){ String s = new String(); String s2=s; s="abc"; s=s.concat(" more stuf"); System.out.println(s);}} //s2 est referenciado a string s e nao a uma nova string que foi concatenada
Certificao JAVA class String2{ public static void main(String args[]){ String x = "java"; //String y; x=x.concat(" camilo"); x.toUpperCase();//perdido, sem referencia System.out.println(x + " " ); }} class String3{ public static void main(String args[]){ String s1 = "spring ";//criado objeto e referenciado por s1 String s2 = s1 + " summer"; s1.concat("fall");//foi criado um objeto porem perdido ng o referencia s2.concat(s1);//quem ta recebendo isso? s1+=" winter";//to concatenando criado um novo new objeto System.out.printf("%s %s ", s1,s2); }} .. class MetStrin{ public static void main(String args[]){ String s = new String("camilo"); String s2 = "neto "; //retorna o caractere da posio 2. System.out.println("metodo char At " + s.charAt(2)); //concatenada a string System.out.println("metodo concat " + s2.concat(" concat")); //compara String para ver se sao iguais independente se ta maiusc. ou minusc. System.out.println("metdo equalsIgnoreCase " + s.equalsIgnoreCase("CAMILO")); //retorna o tamanho da String System.out.println("metodo length " + s2.length()); //aonde tiver e vai ser O System.out.println(s2.replace('e','O')); System.out.println(s2.substring(1));//imprime da posicao 1 ate a ultima System.out.println(s.substring(1,4));//aqui ele retorna da posicao 1 ate a 3 System.out.println(s2.toString());//ele retorna o objeto em questao System.out.println(s.toUpperCase());//converte em maisculo //ele juntar os caracteres remove os espaos em brancos System.out.println(s2.trim() + "L"); }} charAt(3) concat() equalsIgnoreCase() length() replace(x,Z)
71
Retorna o caracter localizado no ndice especificado Anexa uma String ao final de outra (+ tambm funciona) Determina a igualdade de duas Strings, ignorando a caixa, true false Retorna o numero de caracteres de uma string Substitui as ocorrncias de um caracteres por um outro caracter
Certificao JAVA substring(begin,end) Retorna uma parte de uma string Retorna uma String com os caracteres em minusculo.(caixa baixa) toLowerCase() Retorna o valor de uma String ou mtodo. toString() Retorna uma String com os caracteres em maisculo(caixa alta). toUpperCase() Remove os espaos em branco no inicio ate o fim de Strings trim() /*length() = metodo; length = atributo sao != */ STRING BUILDER E STRINGBUFFER
72
Essas classes vieram para ti salvar a respeito de objetos perdidos na memria. O primeiro passo saber a diferena entre StringBuilder e StringBuffer a buffer os mtodos so sincronizados j a builder no. nica diferena essa, a sincronizao afeta o desempenho ento a buffer tendem a ser mais lento que a builder. Ah ento nunca vou usar a buffer nunca diga nunca vai usar sim quando Thread processos for prioridade no seu sistema. Lembre-se desse nome THREAD seu pesadelo. O uso dessas classes quando precisa usar, manipular muitas strings de caracteres, ai j sabe ne? Muitas perdidas na memria e isso no seria uma boa, por mais memria que voc tenha, alias sua maquina tenha ela finita. Ento entra em ao essas duas classes do tpico. Eu particularmente uso elas at se for para apenas uma String. StringBuilder sb = new StringBuilder(); sb.append(camilo); System.out.println(sb); A questao que StringXXX(buffer ou builder), elas operam sobre o valor de quem a chamou, do objeto que a chamou o mtodo. Algo que no faz a String usando o mtodo concat() dela, necessrio criar uma nova String para concatenar na class String. J aqui no vou precisar criar mais nenhum objeto alem de apenas um para representar, referencia a class StringBuilder. No mtodo append posso adicionar o que quiser: int, char, double, float. Os mtodo da class StringBuilder/Buffer: reverse() imprime de forma contraria insert(pos,algo) insere algo na posicao especificada delete(Begin,end) deleta algo na posicao inicio e fim. append(args) adiciona o elemento. Exemplos:
public class Sb { public static void main(String[] args) { StringBuilder sb = new StringBuilder(); sb.append("lopes"); System.out.println(sb); } } ..
Certificao JAVA
import static java.lang.System.out; public class Sb2 { public static void main(String[] args) { StringBuilder sb = new StringBuilder(); sb.append("neto"); sb.append(" java"); out.println(sb); } } /*observe que se depurar esse codigo meu objeto de StringBuilder nao tem * um valor literal ou seja neto, ele tem um codigo em hashCode gerado * pelo compilador*/ ............................... public class Sb3 { public static void main(String[] args) { StringBuilder sb =new StringBuilder(); sb.append("camilo"); sb.append(5); System.out.println(sb); System.out.println(sb.reverse()); }} /*imprime de forma reverse*/ ..................................... public class SbMet { public static void main(String[] args) { StringBuilder sb1= new StringBuilder("camilo"); //metodo que remove pelo indice 0 - 1 sb1.delete(2, 4); System.out.println(sb1); sb1.append(" medeiros"); //insere na posicao 2 uma exclamacao sb1.insert(2,"!"); System.out.println(sb1); sb1.append(" as mocas"); System.out.println(sb1.toString()); }} /*a vantangem de usar StringBuilder ou StringBuffer eh que nao tenho objeto perdidos na minha memria assim tenho uma otimizao */ .................................. public class StComp { public static void main(String[] args) { StringBuilder sb = new StringBuilder("camilo"); String s="camilo"; System.out.println(sb.equals(s));//false StringBuilder sb1 = new StringBuilder("camilo"); System.out.println(sb.equals(sb1));//false System.out.println(sb==sb1);//false } } StringXXXX nao subscrever o metodo equals() como a class String.
73
Certificao JAVA
public class SbEnca { public static void main(String[] args) { StringBuilder sb = new StringBuilder(); sb.append("camilo"); StringBuilder sa=sb.reverse().insert(2,"&"); System.out.println(sa); sa.append(8); System.out.println(sa.toString()); StringBuilder a=null; System.out.println(a); } } /*observe que esse codigo fez: adicionou "camilo" a StringBuilder sb e depois criou uma nova StrinBuilder denominada sa a qual vai receber o seguinte resultado: o reverso de sb e depois vai inserir na posicao dois reserva o caracter &*/
74
/* outro ponto a observar que o hashCode de sa e sb sao iguais devido o valor da String gerar o mesmo hashCode, se ta inverso isso nao afeta*/ /*sempre sb e sa serao equivalentes*/ j que sa recebe ou referencia(=) sb; ..................................... public class Nosb { public static void main(String[] args) { StringBuilder sb = new StringBuilder(); sb.append(10); sb.insert(1,"z"); System.out.println(sb); } } .. class sbui{ static public void main(String args[]){ StringBuilder s = new StringBuilder(); s.append("lopes"); System.out.println(s); }} . class Sgti{ static String gg; public static void main(String args[]){ //aqui nao imprime nada nao passei nada para meu String lembre-se //variaveis locais nao recebe valores padroes String ss = new String(); System.out.println(ss); System.out.println(gg); //imprime null, variaveis de instancia e static //recebem valores padrao }} .......................................................
Certificao JAVA
class Build{ public static void main(String ar[]){ StringBuilder sb = new StringBuilder("camilo"); //esta apontando para o mesmo local que sb StringBuilder sc=sb; System.out.println(sb.equals(sc)); System.out.println(sb==sc); }} ............................................................. class Bs{ StringBuilder za; static StringBuilder z; public static void main(String args[]){ StringBuilder sa = new StringBuilder(); Bs b = new Bs(); System.out.println(b.za); System.out.println(z); //AQUI imprime null duas vezes variaveis static e instancia inicializadas }} .. class TEsrStinB{ public static void main(String arg[]){ String s = "camilo"; StringBuilder sb = new StringBuilder("camilo"); StringBuilder sba = new StringBuilder("camilo"); StringBuilder sbb= new StringBuilder(sba); StringBuilder sbi= new StringBuilder(50); StringBuilder sbii= new StringBuilder(50); System.out.println(s.equals(sb));//false System.out.println(sba.equals(sb));//false; System.out.println(sbb.equals(sba));//false; System.out.println(s=="camilo");//true System.out.println(sbi.equals(sbii));//false; System.out.println(sbi==sbii);//false; } } /*objetos StringBuilder atua sobre o objeto que o chama nao cria novos entao ele retorna falso ate mesmo com outro tipo. So para lembrar que Stringbuilder sao String tb*/ Essas no compilam: public class Nosb { public static void main(String[] args) { StringBuilder sb="lopes"; System.out.println(sb); }} //nao instancie meu objeto Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from String to StringBuilder ....................................
75
Certificao JAVA
public class Nosb {
76
public static void main(String[] args) { StringBuilder sb; System.out.println(sb); } }Exception in thread "main" java.lang.Error: Unresolved compilation problem: The local variable sb may not have been initialized . public class Nosb { StringBuilder sb; public static void main(String[] args) { System.out.println(sb); } }Exception in thread "main" java.lang.Error: Unresolved compilation problem: Cannot make a static reference to the non-static field sb ................................................................. class CharAt{ public static void main(String arg[]){ String s ="car"; //lanca uma excecao posicao invalida System.out.println(s.charAt(3)); } } Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 3
Navegao de Arquivos e E/S Para a certificao java 5 necessrio apenas a E/S para caracteres e serializao. Classes necessrias: BufferedReader BufferedWriter uma classe mais especifica para leitura de arquivos uma forma mais especifica para escrever dados no arquivo.
PrintWriter possui novos mtodo como format(), printf() e append(). E aceita em seu args File,String e Writers. Stream, Readers e Writers - diferenas Existe diferena entre uma classe stream com uma Readeres e Writers sendo que a primeira usada ler e escrever bytes(serializao) j as outras classes usada para ler e escrever caracteres. Ento importante que a palavra stream tem a ver com serializao e no com objeto de E/S. File essa classe no usada para ler, ou inserir dados em um arquivo. E sim para criar arquivos vazios, apagar, criar diretrios, procurar arquivos. Aqui representamos os arquivos e no os dados dele.
Certificao JAVA import java.io.*; class Write1{ public static void main(String args[]){ try{ File file = new File("write1.txt"); //aqui nao crio o arquivo apenas o nome dele. boolean teste = false; System.out.println(file.exists()); // verifico se o arquivo existe ou nao teste = file.createNewFile(); // se criar o arquivo teste = true ; System.out.println(teste); //imprimo o valor de teste. System.out.println(file.exists()); //informo se existe } catch(IOException e){} } }
77
FileReader essa sim usada para ler caracteres de um arquivo. O mtodo read() permite ler caracteres isolados ou seja um por 1. FileWriter essa aqui usada para escrever dados dentro de um arquivo. O seu mtodo write() permite escrever caracteres($,2,!) ou String.
import java.io.*; class FileWrit{ public static void main(String args[]){ char[] on = new char[10];//crio um array para armazenar os caracteres int tam =0;//aqui eh o total de caracteres try{ File file = new File("FileWri.txt");//criei apenas o objeto FileWriter fw =new FileWriter(file);//crio um arquivo o qual o objeto file referencia fw.write("camilo\nlopes\n");//coloco dados dentro do meu arquivo fw.flush();//limpo antes de fechar fw.close();//fecho o arquivo //crio um objeto de leitura do arquivo q o objeto file referencia FileReader fr = new FileReader(file); //leio o arquivo inteiro e coloco o tamanho dentro de tam tam = fr.read(on); //imprimo o tam ate no maximo o tamanho do meu array System.out.println(tam + " "); for(char c : on)//imprimo o foi impresso dentro do arquivo exibo o array System.out.print(c); fr.close(); } catch(IOException e ){ System.out.print("Excecao ocorreu"); } }} ................................................... Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA import java.io.*; class BuFil{ public static void main(String args[]){ File f = new File("xx.txt"); try{ BufferedWriter br = new BufferedWriter(new FileWriter(f)); br.write("xx"); br.flush(); br.close(); }catch(IOException e){} }} /*isso aqui parece que nao compila mais funciona sim. observe que criei um objeto da class writer dentro do contrutor do meu BufferedReader caso contrario nao compila pq para usar BufferedWriter deve est encapsulado com FileWriter ou outra class que estenda a class Writer*/ ............................................ import java.io.File; import java.io.IOException; import java.io.FileWriter; import java.io.FileReader; import java.io.BufferedWriter; import java.io.BufferedReader; class Buffer{ public static void main(String args[]){ File f = new File("soso.txt");//onde colocar isso importante try{ FileWriter fw = new FileWriter(f); BufferedWriter bw = new BufferedWriter(fw); bw.write("camilo"); bw.newLine();//nova linha bw.write("rumo scjp 5.0"); bw.flush(); bw.close(); } catch(IOException e){e.printStackTrace();} //lendo try{ FileReader fr = new FileReader(f); BufferedReader br = new BufferedReader(fr); String s; //equanto tiver dados na linha imprima while((s=br.readLine())!=null){ System.out.println(s); } }catch(IOException e){} }}
78
Trabalhando com Diretrios e Arquivos

Certificao JAVA
79
Para trabalhar com diretrios (pastas) semelhante com arquivos, porm com algumas particularidades. Antes de mostrar essas particularidades importante ta bastante familiar com as classes que vimos no tpico anterior e saber principalmente que File ele no criar arquivo nem diretrios(disco rgido) ele apenas criar objetos que vai referencia a um arquivo ou diretrio caso ele for criado ou no. Veja o cdigo baixo criei um diretrio e dentro dele um arquivo e depois escrevi meu nome dentro do arquivo. import java.io.*; public class Dirt1{ public static void main(String args[]){ try{ //aqui dou o nome ao meu diretorio observe que nao extenso txt, doc //ai se trata de uma pasta File myDir = new File("mydir"); //isso aqui importante criei minha pasta - diretrio myDir.mkdir(); //aqui ja definir o nome do meu arquivo //dentro do diretorio olhe o nome do objeto myDir File myFile = new File(myDir, "certificacao.txt"); //crio o arquivo myFile.createNewFile(); //escrevo dentro do arquivo certificacao.txt PrintWriter pw = new PrintWriter(myFile); pw.println("camilo lopes de medeiros neto"); pw.flush(); pw.close(); } catch(IOException e){} }} CUIDADO: Diretrio no so subscrito, aps ter criado j era. Olhe o cdigo abaixo: import java.io.*; class DirErro{ public static void main(String args[]){ try{ File dir = new File("erro"); dir.mkdir(); //isso aqui nao adianta ele nao subescreve nao. File dir2 = new File("erro"); dir2.mkdir(); File arq = new File(dir,"arq.txt"); arq.createNewFile(); //gravo meu nome no arquivo usando a class BufferedWriter Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
80
FileWriter ler = new FileWriter(arq); BufferedWriter bw = new BufferedWriter(ler); bw.write("camilo"); bw.flush(); bw.close(); } catch(IOException e){} }} O ponto chave aqui o seguinte os arquivos so subscritos se voc cria dois arquivos do mesmo e o ultimo tiver vazio e o primeiro com dados ai ele vai ficar vazio se o ultimo subscrever o primeiro. J as pastas (diretrios) no so subscrita tenha isso em MENTE. Se omitir o mtodo mkdir(); lanada uma exceo, pois os diretrios no so criados automaticamente. isDirectory() e isFile() esses mtodos verifica a existncia de um diretrio e arquivo Se colocar um arquivo dentro de um diretrio que no existe ele no criado No possvel apagar um diretrio (pasta )com arquivo dentro dele. A sintaxe abaixo verifica se um arquivo e diretorio existem ou no. Nesse caso arquivo s vai existir caso o diretrio venha existir tambm. import java.io.*; class Verif{ public static void main(String lopes[]){ try{ //aqui dou o nome a minha pasta mais nao crio File existingDir = new File("existinDir"); //retorna a false pasta nao existe System.out.println(existingDir.isDirectory()); //dou o nome do meu arquivo na pasta caso ele for criado File existingFile = new File(existingDir,"existingFile.txt"); //retorna a false arquivo no existe System.out.println(existingFile.isFile()); //comeo a ler o arquivo FileReader fr = new FileReader(existingFile); BufferedReader br= new BufferedReader(fr); String s; //isso aqui show ele vai imprimindo ate o final do arquivo - null while((s=br.readLine())!=null) System.out.println(s); br.close(); }catch(IOException e){e.printStackTrace();} }}/* exibido na tela false pq nao criei nem o diretorio nem o arquivo e uma exceo lanada*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
81
O exemplo da pgina seguinte: criei um diretrio, criei dois arquivos dentro dele depois deletei 1, e tentei deletar o diretrio com um arquivo, e em seguida mudei o nome do arquivo e do diretrio. import java.io.*; class FileRe{ public static void main(String args[]){ try{ File delDir = new File("deldir"); delDir.mkdir(); File delFile1 = new File(delDir,"file1.txt"); delFile1.createNewFile(); File delFile2 = new File(delDir,"file2.txt"); delFile2.createNewFile(); //deleto o primeiro arquivo que criei file1.txt delFile1.delete(); //tento deletar a pasta delDir porem nao consigo pq tem 1 arquivo nela System.out.println("pasta deletada is " + delDir.delete()); //aqui informo o novo nome que vai receber meu arquivo File newName = new File(delDir,"new.txt"); //efetivamente aqui q ele recebe o nome q passei antes delFile2.renameTo(newName); //o novo nome do diretorio File newDir = new File("New"); //aqui ele recebe o novo nome delDir.renameTo(newDir); } catch(IOException e){} }} //lembre-se se a pasta nao existir ele nao vai nada, e nao lana //nenhum erro. Para realizar uma busca usamos o mtodo list() da class File o qual vamos lista arquivos e diretrios onde realizamos a busca. import java.io.*; class Busca{ public static void main(String args[]){ String[] files = new String[100]; File seach = new File("erro"); //minha variavel recebe arquivo ou diretorio dentro do objeto seach files = seach.list(); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA for(String fn : files) //vou imprimindo o for encontrando System.out.println("found " + fn); /*uma busca realizada tendo ponto como o diretorio ja criado*/ //ele busca e imprime na tela o que tem dentro do diretrio.(o nome do arq). }} Exemplo mais complexos:
package cap6.Datas; import java.io.File; import java.io.FileReader; import java.io.PrintWriter; import java.io.IOException; import java.io.BufferedReader; import java.util.Date; import java.util.Calendar; public class ArqDate { public static void main(String[] args) { Date d = new Date(); Calendar c = Calendar.getInstance(); //criando arquivos File f = new File("arqdate.txt"); try{ PrintWriter pw = new PrintWriter(f); pw.println("log"); pw.println("fe em deus"); System.out.println("arquivo gerado " + d.toString()); pw.close(); }catch(Exception e){e.printStackTrace();} c.add(Calendar.HOUR,2); Date d2=c.getTime();
82
//lendo o arquivo try{ FileReader fr = new FileReader(f); BufferedReader br = new BufferedReader(fr); String n = br.readLine(); br.close(); System.out.println("arquivo foi lido e fechado proxima leitura " + d2.toString()); }catch(Exception e){e.printStackTrace();} } } /*usando E/S e manipulao de datas*/
Serializao Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
83
Eita assunto sofredor, pode acreditar mais esse aqui, sofri bastante, chorei, gritei, xinguei, vontade de desistir mais conseguir capturar sua essncia, o que eu espero hehe. A serializao resume-se em um nico objetivo salvar, gravar, capturar o estado de um objeto. Ou seja eu tenho o objeto de uma classe e quero salvar seu estado uso serializao, pois quando quiser usar esse objeto com seu ultimo estado gravado somente ds-serializa-lo. Mas por que usar isso? Usar serializao permite o seguinte: voc cria o objeto ou uma varivel de instancia de uma class e quer gravar em um arquivo para futuramente utilizar esse objeto ou essa varivel com seu estado que foi gravado ento basta usar serializao, pelo seguinte: Lembre-se quando o construtor executado os valores so perdidos objeto = null, e os tipos primitivos seus valores padres. Com a serializao isso quebrado a partir que serializo um objeto ou uma varivel de instancia seu valor gravado, armazenado e futuramente posso obter esse valor atravs da desserializao. Um exemplo bsico do cdigo de serializao e des-serializao de objetos. import java.io.*; class Cat implements Serializable{} //1 class SerializeCat{ public static void main(String args[]){ Cat c = new Cat(); //aqui vou serializar meu objeto da class cat try{ FileOutputStream fo = new FileOutputStream("test.ser"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(c); // serializo objeto cat oo.close(); System.out.println("Class Cat - object serializado com sucesso"); } catch(Exception e){e.printStackTrace();} //des-serializo o objeto try{ FileInputStream fi = new FileInputStream("test.ser"); ObjectInputStream oi = new ObjectInputStream(fi); c =(Cat) oi.readObject();//4 oi.close(); System.out.println("agora ele foi des-serializado com sucesso"); }catch(Exception e){e.printStackTrace();} }} //1 criei uma class Cat que implementa a interface (marcadora) Serializable nao possui nenhum metodo a ser implementado //ObjectxxxStream a classe que possui o metodo magico de serializacao write e read - Object. //writeObject --> serializa objeto depois escreve o objeto ja serializado no arquivo Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
84
Esse exemplo abaixo que fiz que algumas excees em tempo de execuo que podem ocorrer: import java.io.*; class Camilo implements Serializable{} class CamiloSeria{ public static void main(String args[]){ Camilo objeto1 = new Camilo(); Camilo objeto2 = new Camilo(); try{ FileOutputStream fo = new FileOutputStream("Camiloser.txt"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(objeto1); System.out.println("objeto 1 serializado"); oo.close(); //ocorre uma excecao se a linha abaixo for executada //oo.writeObject(objeto2); } catch(Exception e){ System.out.println("o ocorreu uma exceo"); e.printStackTrace(); } //de-serializando um objeto try{ FileInputStream fi = new FileInputStream("Camiloser.txt"); ObjectInputStream oi = new ObjectInputStream(fi); objeto2 = (Camilo) oi.readObject(); //quem recebe um novo objeto serializado System.out.println(objeto2);//aqui imprime o objeto serializado oi.close(); // se for executado lanca uma exceo nao acha o arquivo //pois eu fechei ele na linha acima //objeto2=(Camilo) oi.readObject(); }catch(Exception e){ e.printStackTrace();} }} Olha essa class completa com objetos e tipo primitivo, grande porm fcil de entender desde que faa um debug nela!!! import java.io.*; public class SerializeDog{ public static void main(String args[]){ Collar c = new Collar(3); Dog d = new Dog(c,8); //olha isso aqui de extrema importancia /* o metodo getCollarSize depende do resultado de d.getCollar Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA o resultado c entao ele faz c.getCollarSize que o resultado 3. */ System.out.println("antes de: coolar eh " + d.getCollar().getCollarSize()); try{ FileOutputStream fo = new FileOutputStream("dog.ser"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(d);//serializo Dog oo.close(); } catch(Exception e){System.out.println("ocorreu uma excecao"); e.printStackTrace();} //des-serializa try{ FileInputStream fi = new FileInputStream("dog.ser"); ObjectInputStream oi = new ObjectInputStream(fi); d = (Dog) oi.readObject(); oi.close(); } catch(Exception e){e.printStackTrace();} System.out.println("depois de: serializado coolar eh " + d.getCollar().getCollarSize()); }} //class dog class Dog implements Serializable{ private Collar theCollar;//variavel de instancia private int dogSize; //construtor que recebe objeto e um int public Dog(Collar c,int s){ theCollar = c; dogSize = s; } public Collar getCollar(){return theCollar;} } //class collar class Collar implements Serializable{ private int collarSize; //construtor que recebe inteiro public Collar(int size){collarSize = size;} public int getCollarSize(){ return collarSize;} } Transient ignora o objeto ou varivel durante a serializao, isso aqui no vai serializado. Material desenvolvido Camilo Lopes - Resumo de Estudo
85
Certificao JAVA
86
NullPointException -- > ocorre no exemplo abaixo se os mtodos de writeObject e readObject for removidos, pois o nosso objeto Collar vai receber o valor null, quando for des-serializa j que a class Collar no eh serializada pois no implementa Serializable. import java.io.*; public class SerializeDog{ public static void main(String args[]){ Collar c = new Collar(3); Dog d = new Dog(c,8); //olha isso aqui de extrema importancia /* o metodo getCollarSize depende do resultado de d.getCollar o resultado c entao ele faz c.getCollarSize que o resultado 3. */ System.out.println("antes de: coolar eh " + d.getCollar().getCollarSize()); try{ FileOutputStream fo = new FileOutputStream("dog.ser"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(d);//serializo Dog oo.close(); } catch(Exception e){System.out.println("ocorreu uma excecao"); e.printStackTrace();} //des-serializa try{ FileInputStream fi = new FileInputStream("dog.ser"); ObjectInputStream oi = new ObjectInputStream(fi); d = (Dog) oi.readObject(); oi.close(); } catch(Exception e){e.printStackTrace();} System.out.println("depois de: serializado coolar eh " + d.getCollar().getCollarSize()); } } //class dog class Dog implements Serializable{ private transient Collar theCollar;//variavel de instancia private int dogSize; //construtor que recebe objeto e um int public Dog(Collar c,int s){ theCollar = c; dogSize = s; } public Collar getCollar(){return theCollar;} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //implementando o metodo private void writeObject(ObjectOutputStream oo){ try{ oo.defaultWriteObject();//aqui digo realize o processo normal de serializacao //aqui o tamanho do collar oo.writeInt(theCollar.getCollarSize()); }catch(Exception e){e.printStackTrace();} } //implementando o metodo read em relacao ao objeto dog private void readObject(ObjectInputStream oi){ try{ oi.defaultReadObject();//cuida da serializao normal //aqui o tamanho do colar serializado theCollar = new Collar(oi.readInt()); }catch(Exception e){e.printStackTrace();} }} //class collar class Collar{ private int collarSize; //construtor que recebe inteiro public Collar(int size){collarSize = size;} public int getCollarSize(){ return collarSize;} } /*esse processo manual de serializao quando temos alguma classe nao serializada entao necessario immplementar os metodo writeObject e reaObject, isso acontece pq nem tudo pode ser serilizavel a class object nao eh por exemplo lembre que a implementacao deve ser na classe que eh serializada ou seja dog neste caso - os metodos deve ser PRIVADOS - private caso coloque como publico a exceo permanece */ Alguns exemplos de reviso: import java.io.*; class Ex1 implements Serializable{ public int resultado; public Ex1(int c){ resultado = c; } public int getRes(){return resultado;} } class Exprin{ public static void main(String args[]){ Ex1 objt = new Ex1(3); Ex1 objt2= null; try{ Material desenvolvido Camilo Lopes - Resumo de Estudo
87
Certificao JAVA FileOutputStream fo = new FileOutputStream("ex1.txt"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(objt); System.out.println("objeto serializado " + objt.getRes()); oo.close(); }catch(Exception e){e.printStackTrace();} //des-serializando objeto try{ FileInputStream fi = new FileInputStream("ex1.txt"); ObjectInputStream oi = new ObjectInputStream(fi); objt2 = (Ex1)oi.readObject(); System.out.println("des-serializado " + objt2.getRes()); oi.close(); }catch(Exception e){e.printStackTrace();} }}
. import java.io.*; public class IntSer { public static void main(String[] args) { Integer i = new Integer(50); System.out.println("antes"+i); //salvando o estado do objeto try{ FileOutputStream f = new FileOutputStream("integ.txt"); ObjectOutputStream op = new ObjectOutputStream(f); op.writeInt(i); op.close(); }catch(Exception e){} i+=100; System.out.println("i alterado" + i); try{ FileInputStream fi = new FileInputStream("intg.txt"); ObjectInputStream oi = new ObjectInputStream(fi); i=oi.readInt(); System.out.println("depois " + i); oi.close(); }catch(Exception e){e.printStackTrace()} }
88
} /*caso o arquivo especificado na des-serializao nao exista ele nao des-serializado e so acontece a serializacao mais uma exceo lanada por o arquivo no existir*/
//observer que no to serializando a instancia da class ento no nem implementei minha interface serializable. O cdigo da pagina seguinte lana uma exceo.
import java.io.Serializable;
Certificao JAVA
import java.io.FileOutputStream; import java.io.ObjectOutputStream; import java.io.FileInputStream; import java.io.ObjectInputStream; class SerDuva //kd a implements Serializable?{ public static void main(String agr[]){ SerDuva a = new SerDuva(); try{ FileOutputStream fo = new FileOutputStream("integer.txt"); ObjectOutputStream os = new ObjectOutputStream(fo); os.writeObject(a); os.close(); }catch(Exception e){e.printStackTrace();} try{ FileInputStream ds = new FileInputStream("integer.txt"); ObjectInputStream os = new ObjectInputStream(ds); a=(SerDuva)os.readObject(); os.close(); }catch(Exception e){e.printStackTrace();} } }
89
Jamais vai conseguir serializar um objeto da class se ela no implements Serializable.
Herana e Serializao
Quando temos uma subclasse que herda tudo da sua class pai o que acontece com serializao? Bom ai temos uma pequena regra a seguir, se sua class PAI, implementar Serializable ento a sua subclasse implicitamente j faz serializable. Agora se sua classe PAI, no implementa Serializable e sua subclasse implementa ento apenas os objetos da sua subclasse vamos serializar o da class PAI infelizmente ter seus valores iniciais ou padro. Uma exemplo pratico: class Animal{} class Dog extends Animal implements Serializable{} no exemplo anterior apenas dog serializado. Um exemplo mais prtico: class Foo implements Serializable{ int num = 3; void Num(){num=10;} } a class Foo quando for serializada e rodar o mtodo Num() ela vai gravar o valor 10 para a varivel int que criamos e quando for des-serializada ideal que ela mantenha esse valor. TENHA EM MENTE: Um objeto des-serializado ns NO: Queremos que a inicializao normal rode. No queremos que os construtores rodem E no queremos que os valores explicitamente declarados seja atribudos Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
90
Na VERDADE queremos apenas um retorno do estado que foi gravado, serializado. Transient se marcar uma varivel com transient elas no sero restauradas ao seus estados originais, ou seja, como foi declarada e receber seu valor padro. Se for objeto null, se for int 0,double 0.0 etc. import java.io.*; class Animal { int weight = 42; } class Dogg extends Animal implements Serializable{ String name; Dogg(int w, String n){ name = n; weight = w; }} public class Super{ public static void main(String args[]){ Dogg d = new Dogg(35,"fido"); System.out.println("antes de : " + d.name + " " + d.weight); //comea a serializao de dog try{ FileOutputStream fo = new FileOutputStream("super.ser"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(d); oo.close(); } catch(Exception e){e.printStackTrace();} //des-serializa try{ FileInputStream fi = new FileInputStream("super.ser"); ObjectInputStream oi = new ObjectInputStream(fi); d =(Dogg) oi.readObject(); oi.close(); }catch(Exception e){e.printStackTrace();} System.out.println("depois de : " + d.name + " " + d.weight); } } /*a impressao aki eh 35 e 42, observe que a nossa class animal que a pai de dog ela nao eh serializable apenas dog, entao quando o objeto eh des-serializado ele retorna apenas o valor original e nao o estado da serializao.*/ /* a resoluo - eh colocar a class pai implements serializable*/ /* se usar transient ele retorna 35 e 0 pois o transient ignora tudo e so retorna Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA o valor padrao do tipo, objeto ou primitivo. mas animal deve implementar serializable para que o transient retorne caso contrario nao acontece nada exibe 42.*/ veja a diferena na classe abaixo: import java.io.*; class Amor implements Serializable{ int idade=28; } class GN extends Amor implements Serializable{ GN(int n){ idade=n; } } public class Gnpri{ public static void main(String[] lopes){ GN ef = new GN(19); System.out.printf("antes de seri... %d",ef.idade);
91
//serializando try{ FileOutputStream fo = new FileOutputStream("amor.ser"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(ef); oo.close(); }catch(Exception e){ e.printStackTrace();} //des-serializando try{ FileInputStream fi = new FileInputStream("amor.ser"); ObjectInputStream oi = new ObjectInputStream(fi); ef = ( GN) oi.readObject(); oi.close(); }catch(Exception e){e.printStackTrace();} System.out.printf("\nantes de seri... %d",ef.idade); } }
import java.io.*;
Certificao JAVA
class Trans implements Serializable{ transient int x=42; Trans(int a){ x=a; } public static void main(String args[]){ Trans t = new Trans(10); System.out.println(t.x); try{ FileOutputStream fo = new FileOutputStream("rn.xtt"); ObjectOutputStream oo = new ObjectOutputStream(fo); oo.writeObject(t); }catch(Exception e){e.printStackTrace();} try{ FileInputStream fi = new FileInputStream("rn.xtt"); ObjectInputStream oo = new ObjectInputStream(fi); t=(Trans)oo.readObject(); }catch(Exception e){e.printStackTrace();} System.out.println(t.x); }} .. package cap6.Datas; import java.io.FileOutputStream; import java.io.FileInputStream; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.util.Date; import java.util.Calendar; public class SeriData { public static void main(String[] args) { Integer g = new Integer(20); Date d = new Date(); Calendar c = Calendar.getInstance(); System.out.println("inicio da Serializacao " + d.toString()); try{ FileOutputStream f = new FileOutputStream("seridata.txt"); ObjectOutputStream oo = new ObjectOutputStream(f); oo.writeInt(g); oo.close(); }catch(Exception e){e.printStackTrace();} c.add(Calendar.YEAR, 1); Date d2 = c.getTime(); //de-serializando try{ FileInputStream fi = new FileInputStream("seridata.txt"); ObjectInputStream oi = new ObjectInputStream(fi); g = oi.readInt(); System.out.println("des-serializado " + g); System.out.println(d2.toString()); }catch(Exception e){e.printStackTrace();} }} /*aqui usei manipulacao de datas com Serializao imaginando que vim desserializar um objeto 1 ano apos*/
92
serializao no estar para static

Certificao JAVA
93
quando se diz isso no quer dizer que seu cdigo no vai compilar ou vai lanar alguma exceo caso tente serilizar uma varivel static. Simplemente diz que no possvel gravar o estado de uma varivel static. Mas pq? Devido a varivel static no ter objetos ela pertence a class. E as variveis de instancia pertencem a um objeto. Sabemos que static o valor da varivel compartilhado para todos ento.. se eu serializo 10, mas altero o valor para 20 na desserializacao ele retorna 20 j que no temos instancia nenhuma do static ele vai trazer o ultimo valor. Isso bastante importante olha a sintaxe baixo que fiz.
import java.io.*; class Doub{ static int z=2; } class Df extends Doub implements Serializable{ Df(int f){ z=f; } public static void main(String args[]){ File f = new File("as.txt"); Df df= new Df(50); try{ FileOutputStream fs = new FileOutputStream(f); ObjectOutputStream os = new ObjectOutputStream(fs); os.writeObject(z); os.writeObject(df); os.close(); }catch(Exception e){e.printStackTrace();} z=10; try{ FileInputStream ft = new FileInputStream(f); ObjectInputStream os = new ObjectInputStream(ft); int z = (Integer)os.readObject(); df=(Df)os.readObject(); System.out.println(z); System.out.println(df.z); }catch(Exception a){a.printStackTrace();} System.out.println(z); } } /*observe o problema com serializao static..*/ Dica: se remover implements Serializable o cdigo compilado mais em tempo de execuo lanada uma exceo devido no encontrar a interface serializable. class Df extends Doub {}
exemplo completo: Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
import java.io.Serializable; import java.io.FileOutputStream; import java.io.ObjectOutputStream; import java.io.FileInputStream; import java.io.ObjectInputStream; class DuviSer { public static void main(String args[]){ Dog d = new Dog(); try{ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("ss.txt")); os.writeObject(d); os.close(); }catch(Exception e){e.printStackTrace();} }} class Dog { Dog(){} } java.io.NotSerializableException: cap4.Dog import java.io.Serializable; import java.io.FileOutputStream; import java.io.ObjectOutputStream; import java.io.FileInputStream; import java.io.ObjectInputStream; class DuviSer implements Serializable { public static void main(String args[]){ Dog d = new Dog(); try{ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("ss.txt")); os.writeObject(d); os.close(); }catch(Exception e){e.printStackTrace();} }} class Dog { Dog(){} } /*o erro permanece to serializando dog e ele nao implementa a interface * quem implementa eh a class DuviSer*/ java.io.NotSerializableException: cap4.Dog
94
.................................................................
//se tentar serializar um objeto de uma class
Certificao JAVA
//que um objeto nao seja serializable lana uma exceo import java.io.*; class Colera{} class Cach implements Serializable{ Colera co = new Colera();//aqui o problema a class nao implementa Serializable public static void main(String ar[]){ Cach c = new Cach(); try{ FileOutputStream fs = new FileOutputStream("ss"); ObjectOutputStream os = new ObjectOutputStream(fs); os.writeObject(c); }catch(Exception e){e.printStackTrace();} }} /* observe que lana uma exceo pq definir que cach tem uma colera e a serializao so aplica a variaveis de instancia e objetos por isso que lanou se declarasse dentro de um metodo nao teria problema ja que seria uma variavel local*/
95
.....................................................................................
import java.io.*; class cross{} class Carro implements Serializable{ /* essa class compila normal pq cross esta na class drive e o processo de serializao ocorre la nao lana nenhuma excecao*/ } class Drive { cross cr = new cross(); public static void main(String args[]){ Carro c = new Carro(); try{ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("carr.txt")); os.writeObject(c); os.flush(); }catch(Exception e){e.printStackTrace();} try{ ObjectInputStream os = new ObjectInputStream(new FileInputStream("carr.txt")); c=(Carro)os.readObject(); os.close(); System.out.println("tudo ok"); }catch(Exception e){e.printStackTrace();} } }
..................................................................................
Certificao JAVA Essa aqui lana uma exceo :

import java.io.*; class cross{} class Carro implements Serializable{ /*minha class carro vai ser serializada porem tem uma instancia de uma class que nao implements serializable*/ cross cr = new cross(); public static void main(String args[]){ Carro c = new Carro(); try{ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("carr.txt")); os.writeObject(c); os.flush(); }catch(Exception e){e.printStackTrace();} try{ ObjectInputStream os = new ObjectInputStream(new FileInputStream("carr.txt")); c=(Carro)os.readObject(); os.close(); System.out.println("tudo ok"); }catch(Exception e){e.printStackTrace();} .. Aqui compila e executa SEM EXCECOES. import java.io.*; class cross{} class Carro extends cross implements Serializable{ /*observe que coloquei agora dentro de um metodo e funciona * tranquilo, ja que qdo o metodo terminar as variaveis sao * destruidas entao o cr nesse caso eh uma variavel local * e nao de instancia. tem que estar atento a isso */ public static void main(String args[]){ cross cr = new cross(); Carro c = new Carro(); try{ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("carr.txt")); os.writeObject(c); os.flush(); }catch(Exception e){e.printStackTrace();} try{ ObjectInputStream os = new ObjectInputStream(new FileInputStream("carr.txt")); c=(Carro)os.readObject(); os.close(); System.out.println("tudo ok"); }catch(Exception e){e.printStackTrace();} } }
96
Certificao JAVA Datas, Nmeros e Moeda. Para entender esse assunto vou precisar de dois pacotes java.text e o java.util. e dentro dele usar as seguintes classes date, calendar,dateFormat,NumberFormat e Locale. Essas so essenciais.
97
Date aqui a maioria dos mtodos foram depreciados, mais pode ser usada junto com a classe calendar e DateFormat. Calendar essa classe serve para manipular data de uma maneira mais fcil que a Date. Text.DateFormat essa serve para formatar datas 01/05/2010 e tambm para formatar datas de diversos locais do mundo. Brasil, Sua etc. Text.NumberFormat essa aqui formata numero e moedas de diversos locais. Locale ela usada em conjunto com as duas classes acima, ela tem a capacidade de converter 1/05/2010 em segunda-feira 01 de maio de 2010. O cdigo abaixo um exemplo do uso da classe Date: import java.util.Date; class TestDate{ public static void main(String args[]){ Date d1 = new Date(); System.out.println(d1.toString()); }} Esse ai exibe dia, ms data, hora e o ano.
Wed Apr 25 10:58:09 GMT-03:00 2007
Para manipular datas vamos usar a class Calendar veja um exemplo aproveitando o anterior. Ao usar essa classe no se cria objeto usando new e sim getInstance(), esse o mtodo referencia a uma subclasse concreta de Calendar. Pois Calendar uma class abstrata. import java.util.Calendar; import java.util.Date; class TestCalendar{ public static void main(String []args){ Date d = new Date(); System.out.println(d.toString()); Calendar c = Calendar.getInstance(); //objeto d foi atribuido a Calendar c.setTime(d); //se for = = a domingo imprima sunday week if(c.SUNDAY= =c.getFirstDayOfWeek()) System.out.println("Sunday week"); //aqui informa o dia em numero 6, 2.... System.out.println("o dia eh " + c.get(c.DAY_OF_WEEK)); //adicionei mais 1 mes c.add(Calendar.MONTH,1);
Certificao JAVA //esse nao aumenta nem diminui se tiver fora do ano c.roll(Calendar.MONTH, 11); //peguei o valor de novo e coloquei em uma nova instancia de Date Date d2 = c.getTime(); System.out.println(d2.toString()); }} exemplo mais simplificado: import java.util.Calendar; import java.util.Date; class Calend{ public static void main(String args[]){ Date d = new Date(); Calendar c = Calendar.getInstance(); c.setTime(d); c.add(Calendar.YEAR,2); d = c.getTime(); System.out.println(d.toString()); }} a class DateFormat tem o objetivo de formatar datas. Essa classe ela abstrata como a class Calendar. import java.text.DateFormat; import java.util.Date; class Date3{ public static void main(String args[]){ Date d1 = new Date(); DateFormat[] df = new DateFormat[5]; df[0]=DateFormat.getInstance(); //imprime assim 10/01/07 20:45:02 com horario df[1]=DateFormat.getDateInstance();// imprime assim 10/01/2007 df[2]=DateFormat.getDateInstance(DateFormat.SHORT); //10/01/07 sem horario df[3]=DateFormat.getDateInstance(DateFormat.LONG);//1 de janeiro de 2007 df[4]=DateFormat.getDateInstance(DateFormat.FULL);//sabado, 1 de janeiro de 2007 for(DateFormat a : df) //imprimo no formato de Date System.out.println(a.format(d1)); }} mais simplificada: import java.util.Date; import java.text.DateFormat; class Dt{ public static void main(String args[]){ Date d = new Date(); DateFormat[] a = new DateFormat[2];//isso eh array olhe os colchetes a[0] = DateFormat.getInstance(); a[1] = DateFormat.getDateInstance(DateFormat.LONG); Material desenvolvido Camilo Lopes - Resumo de Estudo
98
Certificao JAVA for(DateFormat b : a) System.out.println(b.format(d)); }} ..

public class Dcf { public static void main(String[] args) { Date d = new Date(55555.5); System.out.println(d.toString()); }} /* erro de compilao so aceita int ou long*/
99
............................................................
package cap6.Datas; import java.io.File; import java.io.PrintWriter; import java.io.BufferedReader; import java.io.FileReader; import java.util.Date; import java.text.DateFormat; public class ArquiDatForm { public static void main(String[] args) { Date d = new Date(); DateFormat dat = DateFormat.getDateInstance(DateFormat.LONG); DateFormat dt = DateFormat.getInstance(); System.out.println("Arquivo sendo gerado..." + dat.format(d)); File f = new File("formatdate.txt"); try{ PrintWriter pw = new PrintWriter(f); pw.println("dados"); pw.println("joao"); pw.close(); }catch(Exception e){e.printStackTrace();} //lendo o arquivo try{ FileReader r = new FileReader(f); BufferedReader br = new BufferedReader(r); br.close(); System.out.println("arquivo foi lido " + dt.format(d)); }catch(Exception e){} }} /*aqui o uso de E/S e data formatadas bem legal*/ ........................................................ package cap6.Datas; import java.util.Date; import java.util.Calendar; import java.text.DateFormat; public class Dcf { public static void main(String[] args) { Date d = new Date(); Calendar c = Calendar.getInstance(); c.setTime(d); DateFormat d1 = DateFormat.getDateInstance(DateFormat.FULL);
Certificao JAVA
System.out.println("data formatada " + d1.format(d)); c.add(Calendar.YEAR, 2); Date d2 = c.getTime(); System.out.println("Data alterada " + d1.format(d2)); } } /* o uso das tres classes: Date, Calendar e DateFormat*/ // massa essa fusao
100
agora com serializacao : import java.io.Serializable; import java.util.Date; import java.io.FileOutputStream; import java.util.Calendar; import java.io.FileInputStream; import java.text.DateFormat; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.io.Serializable; class DatSer implements Serializable{ public static void main(String args[]){ Date d = new Date(); DatSer das = new DatSer(); Calendar cl = Calendar.getInstance(); DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT); System.out.println("inicio da serializacao " +df.format(d)); try{ ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("as")); os.writeObject(das); os.close(); }catch(Exception e){} cl.setTime(d); cl.add(Calendar.MONTH,1); d=cl.getTime(); System.out.println("Proxima serializacao " + df.format(d)); } } class Locale tem como objetivo de formatar a data de acordo com a localidade informada pela lngua, ou pelo pais. import java.util.Calendar; import java.util.Date; import java.util.Locale; import java.text.DateFormat; class Lo{ public static void main(String args[]){ Calendar c = Calendar.getInstance(); c.set(2010,3,15);//Ano,mes,dia. Date d =c.getTime(); Locale locBr = new Locale("pt", "BR");//Brasil Locale locIn = new Locale("hi", "IN");//India Locale locI = new Locale("it", "IT");//Italia Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
101
DateFormat dfUs = DateFormat.getInstance(); //imprime 15/03/2003 e o horario System.out.println("us " + dfUs.format(d)); DateFormat dfBr = DateFormat.getInstance(); System.out.println("br " + dfBr.format(d)); //imprime por extenso de acordo com o pais DateFormat dfLong = DateFormat.getDateInstance(DateFormat.LONG,locBr); System.out.println("br long: " + dfLong.format(d)); DateFormat dfI = DateFormat.getDateInstance(DateFormat.FULL,locIn); System.out.println("Ind " + dfI.format(d)); DateFormat dfIt = DateFormat.getDateInstance(DateFormat.FULL,locI); System.out.println("italia " + dfIt.format(d)); } } /*observe que acrescentou no final o objeto que deve representar para corresponder com o pais, ao executar esse codigo a india, o jvm nao tem suporte*/ Existe mais dois mtodos a estudar veja: getDisplayLanguage() retorna a lngua de um determinado local getDisplayCountry() e retorna o pais. import java.util.*; class PL{ public static void main(String args[]){ Calendar c = Calendar.getInstance(); c.set(2009,4,22); Date d2 = c.getTime(); Locale locBr = new Locale("pt", "BR"); Locale locDk = new Locale("da", "DK"); //informa o pais System.out.println(" pais " + locBr.getDisplayCountry()); System.out.println(" pais " + locDk.getDisplayCountry()); //informa a lingua System.out.println("lingua " + locBr.getDisplayLanguage()); //aqui so ta referenciado ao objeto local System.out.println("lingua " + locBr.getDisplayLanguage(locBr)); System.out.println("lingua " + locDk.getDisplayLanguage()); }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
102
import import import import public
java.util.Date; java.util.Locale; java.util.Calendar; java.text.DateFormat; class Loca {
public static void main(String[] args) { Date d = new Date(); Calendar c = Calendar.getInstance(); c.set(2007,4,2); Date d2 = c.getTime(); Locale loc = new Locale("it","IT"); Locale loc2 = new Locale("pt"); //imprime o dia DateFormat dat = DateFormat.getDateInstance(DateFormat.FULL,loc); System.out.println(dat.format(d2)); DateFormat dt = DateFormat.getDateInstance(DateFormat.FULL,loc2); System.out.println(dt.format(d2)); } } /*class que imprime data formatada de acordo com o pais: * usei Locale e DateFormat para execucao final*/
import java.util.Date; import java.util.Calendar; import java.util.Locale; import java.text.DateFormat; class LocDSimplex{ public static void main(String args[]){ Date d = new Date(); Locale locfr = new Locale("fr","FR"); DateFormat df = DateFormat.getDateInstance(DateFormat.LONG,locfr); System.out.println(df.format(d)); }}
package cap6.Datas; import java.util.Date; import java.text.DateFormat; import java.util.Locale; import java.io.File; import java.io.FileWriter; import java.io.BufferedWriter; public class PaisDat { public static void main(String[] args) { Date d = new Date(); Locale pais = new Locale("pt","BR"); DateFormat dfesp = DateFormat.getDateInstance(0, pais); File f = new File("D:\\JAVA\\SCJP\\revisaocap\\cap6\\Datas\\arqPais.txt"); try{ FileWriter fw = new FileWriter(f); BufferedWriter bw = new BufferedWriter(fw); bw.write("datas formatadas");
Certificao JAVA
bw.close(); }catch(Exception e){e.printStackTrace();} System.out.println("o arquivo foi gerado "+dfesp.format(d)); } } /*FULL - 0 * LONG - 1 * MEDIUM - 2 * SHORT - 3 * esses sao os indice para formatacao qualquer valor acima dele lanca uma exceo **/
103
Com exceo:
package cap6.Datas; import java.util.Date; import java.text.DateFormat; import java.util.Locale; import java.io.File; import java.io.FileWriter; import java.io.BufferedWriter; public class PaisDat { public static void main(String[] args) { Date d = new Date(); Locale pais = new Locale("pt","BR"); DateFormat dfesp = DateFormat.getDateInstance(4, pais); ..... restante do cdigo Exception in thread "main" java.lang.IllegalArgumentException: Illegal date style 4
NUMBER FORMAT Permite formatar moedas por localidade, uma class abstract nem pense em usar NEW para criar um objeto dessa class.
import java.util.*; import java.text.*; public class MoedaVe { public static void main(String[] args) { Locale ve = new Locale("ve","VE"); NumberFormat num = NumberFormat.getCurrencyInstance(ve); double valor=2500; System.out.println(num.format(valor)); System.out.println(ve.getDisplayCountry()); System.out.println(ve.getDisplayLanguage()); } } /*impriem no formatado da venezuela VEB 2.500,00 Venezuela Venda */ ....................................
Certificao JAVA
import java.util.Locale; import java.text.NumberFormat; public class NumbForm { public static void main(String[] args) { float f1=254.2689f; Locale loc = new Locale("fr"); NumberFormat nf = NumberFormat.getInstance(); System.out.println(nf.format(f1));//1 NumberFormat nf2 = NumberFormat.getCurrencyInstance(loc); //frances moeda format System.out.println(nf2.format(f1));//2 NumberFormat nf3 = NumberFormat.getNumberInstance(loc); System.out.println(nf3.format(f1));//3 NumberFormat nf4 = NumberFormat.getPercentInstance(loc); System.out.println(nf4.format(f1));//4 NumberFormat nf5 = NumberFormat.getPercentInstance(); System.out.println(nf5.format(f1));//5 }} 254,269//1 254,27 //2 254,269//3 25 427%//4 25.427%//5
104
Direto da API
1. Use getInstance ou getNumberInstance para adquirir o formato de nmero normal. Use getIntegerInstance para adquirir um formato de nmero de inteiro. 2. Use getCurrencyInstance para adquirir o formato de nmero de moeda corrente. 3. E usa getPercentInstance para adquirir um formato por exibir porcentagens. Com este formato, uma frao como 0.53 exibida como 53%.
class LocNum{ public static void main(String []a){ NumberFormat nf = NumberFormat.getInstance(Locale.US); System.out.println(nf.format(78.65));//1 //aceita no maximo 1 digito apos a virgula ou . nf.setMaximumFractionDigits(1); System.out.println(nf.format(78.65));//2 //no minimo 1 digito apos o ponto(.) senao nem compila nf.setMinimumFractionDigits(1); System.out.println(nf.format(78.65));//3 //retorna o numero maximo apos a virgula System.out.println(nf.getMaximumFractionDigits()); } } 78.65 78.6 78.6 1
Certificao JAVA REGEX
105
Regex uma linguagem dentro de outra linguagem, o objeto aqui buscar coisas. O regex ele possui um motor regex onde passa os dados textuais que quer processar e a expresso que deseja usar para procurar os dados. A fonte dos dados, ou seja, o dado de busca ele inicia a partir do zero. import java.util.regex.*; class RegexS{ public static void main(String args[]){ //busca Pattern p = Pattern.compile("ab"); //aqui a fonte Matcher m = p.matcher("abaaaba"); //testo boolean b = false; while(b=m.find()){ System.out.print(m.start() + " "); } }} //imprime - 0 Uma busca regex sempre ocorre da esquerda para direita, e aps o uso de um caractere, ele no pode ser usado novamente. Metacaracteres um recurso do regex que permite ser mais dinmico ou seja podemos realizar buscas mais avanadas. \d Um digito \s um caractere de espao em branco \w um caractere de palavra os espao em branco no conta import java.util.regex.*; class RegexS{ public static void main(String args[]){ //busca Pattern p = Pattern.compile("\\d"); //aqui a fonte Matcher m = p.matcher("a12c38ba"); //testo boolean b = false; while(b=m.find()){ //imprime a posicao aonde tem apenas numero System.out.print(m.start() + " "); } }} Deve usar com \\ para que a JVM no identifique como escape. Pois String e Metacaracteres colidem. \\d+ ele pega uma ou mais seqncia de nmeros. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
106
Pattern e Matcher Pattern usada par armazenar a representao da expresso regex a ser buscada ou seja a coisa. Matcher ela que chama o motor regex que tem a fonte. import java.util.regex.*; class Regex{ public static void main(String args[]){ //nao usamos new, pois aqui usa metodo estatico e sobrecarregado compile() //o valor a ser buscado Pattern p = Pattern.compile(args[0]); //aqui representa a fonte de dados Matcher m = p.matcher(args[1]); boolean b = false; System.out.println("Parten is " + m.pattern()); //metodo mais importe ele realiza a busca while(b=m.find()){ //o start obtem a posicao em true e //group obtem a string System.out.println(m.start() + "" + m.group()); }}}
import java.util.regex.*; public class Minureg { public static void main(String[] args) { Pattern p = Pattern.compile("lo"); Matcher m = p.matcher("LOPES"); boolean b = false; while(b=m.find()){ System.out.println(m.start()); } } } /*diferencia LO de lo*/ ................................. import java.util.regex.*; public class Dregx { public static void main(String[] args) { Pattern p = Pattern.compile("\\D"); Matcher m = p.matcher("22e5 1 u"); boolean b =false; while(b=m.find()){ System.out.println(m.start() + " " + m.group()); } } }/*o D maiusculo ele procura apenas por letras isolando qualquer numero,espaos em brancos so validos. Cuidado para nao achar que vai trazer um digito*/ 2 e 4 //espao em branco 6 7 u
Certificao JAVA
Obs.: \\D e \\d so completamente diferente o primeiro traz letras e o segundo traz dgitos numricos. import java.util.*; import java.util.regex.*; public class ScanRegx { public static void main(String[] args) { Scanner dados = new Scanner(System.in); System.out.println("digite a fonte de busca"); String busca = dados.next(); System.out.println("Digite o vai ser buscado "); String vai = dados.next(); Pattern p = Pattern.compile(vai); Matcher m = p.matcher(busca); boolean b=false; while(b=m.find()){ System.out.println(m.start() + " " + m.group()); } }} .. import java.util.regex.*; class regx{ public static void main(String args[]){ Pattern p = Pattern.compile("\\.*aa"); Matcher m = p.matcher("adefaa eea eeaa"); boolean b=false; while(b=m.find()){ System.out.println(m.start() + "" + m.group()); } }} /* tire as barras e perceba a diferena * com as barras--> ele avalia cada parte da expressao * sem as barras ele avalia como um todo */ 4 aa 13 aa Sem as barras \\ 0adefaa eea eeaa
107
Tokezinando com String.split(); A diferena entre a Scanner que essa aqui ele vai buscando dentro de um dado, mesmo se encontrar a busca no interrompida. import java.util.*; class Split{ public static void main(String args[]){ //toke recebe o resultado de args[0] //se passar \d ele ignora todos os digito e retorna //somente os caracteres. \w mostra em branco(ignora todos os caracteres) String[] toke=args[0].split(args[1]); for(String a : toke) System.out.println(a); }} . Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA import java.util.*; class Split2{ public static void main(String args[]){ String nome = "camilo neto 20"; String[]r = nome.split("\\d"); for(String z : r) System.out.println(" "+z); }} Class Scanner usada para tokelizar dados mais tambm pode ser usada para encontrar coisas. Observe o exemplo abaixo que a kathy no teve nem coragem de explicar...Direito eu tentei entender. import java.util.*; class ScanIn{ public static void main(String args[]){ //aqui ele pede a fonte System.out.println("input : "); System.out.flush(); try{ Scanner s = new Scanner(System.in); String token; do{ //pega o valor da expressao e faz a busca token = s.findInLine(args[0]); //imprime se existe System.out.println("found " + token); }while(token != null); }catch(Exception e){System.out.println("scan exc");} }} //para executa java "\d\d" //aqui vc tem que passa a expressao de busca //e em seguida digitar a fonte
108
FORMATAO Aqui algumas formataes vlidas e invalidas, lembrando que um erro de formatao lana uma exceo e no erro de compilao. format() e printf() tem as mesmas funcionalidades. % e o caractere de converso( d,b,c,f) so obrigatrios. class Form{ public static void main(String ags[]){ double n=125.0; int z=852; System.out.printf("%+d \n",z); System.out.format("%,.02f \n",n); System.out.printf("%f \n",n); //System.out.printf("%d \n",2.0); - lanca uma excecao }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
......................................
public class Forma { public static void main(String[] args) { System.out.printf("%(d\n", -25); System.out.printf("%.01f\n",85.32); System.out.format("%,f\n",572.37); }} ........................ public class ff { public static void main(String[] args) { System.out.printf("%2$d %1$d\n",50,100); } } /* $ informa que argumento deve ser impresso * no meu caso deve ser impresso o segundo argumento */ ....................... public class notform { public static void main(String[] args) { String s = "Camilo"; double real = 120.502; System.out.printf("%s ",s,real); } } /* so imprime Camilo pq so tem o formatado para a String*/
109
invlido
public class Noform { public static void main(String[] args) { int d = 1000; double dou = 12.8; System.out.printf("%d",dou); System.out.format("%f",d); } } /* observe que troquei %d botei um double e um int botei um double lana uma exceo*/ Exception in thread "main" java.util.IllegalFormatConversionException: d != java.lang.Double class Format{ public static void main(String arg[]){ String a="lopes"; double d = 12.50; int z = 10; System.out.printf("%,.2f", d); System.out.printf("\n%b ",a);//true //System.out.println("%s",a); - nao compila System.out.printf("%f",z);//lana uma excecao } }
Certificao JAVA
110
12,50 true Exception in thread "main" java.util.IllegalFormatConversionException: f != java.lang.Integer
CAPITULO 7 Subescrevendo equals() para saber se as referencias(apontam) so idnticas usa = = . mas para saber se os prprios objetos so iguais usa equals(). Mtodo equals() publico sempre O mtodo equals para ser subscrito e deve ter o argumento Object, qualquer outra class uma sobrecarga.
public class Subequa { public static void main(String[] args) { Pantera p = new Pantera(10); Pantera r = new Pantera(10); System.out.println(p==r); System.out.println(p.equals(r)); //linha 9 } //subsescrevendo public boolean equals(Object o){ if((o instanceof Pantera)&&(((Pantera)o).z==10)){ return true; } else{return false;}}} class Pantera{ int z; Pantera(int a){ z=a; }} /* o resultado aqui eh false - false observe que aonde estiver o metodo equals faz a diferena, pois esse metodo equals eh para a class Subequa e o chamado na linha 9 de pantera */ .............................................. public class tosting { public static void main(String[] args) { Cliente c = new Cliente("Camilo",8.000); System.out.printf("%s",c); } } .................. class Cliente{ double sal; String nome; Cliente(String a, double f){ nome=a; sal=f; } public String toString(){ return ("nome "+ nome + " salario " + sal); }} /* esse aqui retorna o valor do objeto, isso valido quando * subscreve o metodo toString() */
Certificao JAVA
public class EqualTest{ public static void main(String args[]){ Moof one = new Moof(8); Moof two = new Moof(8); if(one.equals(8)){ System.out.println("one and tow are equal"); } else{ System.out.println("one and two NO are equal");} } } class Moof{ private int moofValue; Moof(int val){ moofValue=val; } public int getValue(){ return moofValue; }
111
public boolean equals(Object o){ if((o instanceof Moof) &&(((Moof)o).getValue() == this.moofValue)){ return true; } else{ return false; } }}
.....................................
public class Stingequa { public static void main(String[] args) { String s = new String("java"); String j = new String("java"); System.out.println(j.equals(s)); System.out.println(j==s); } } /* esse resultado deve ser analisado varias vezes String e wrappers implementam equals so eles mais ng, gravar isso na mente*/ ....................... public class Dog { int idade; Dog(int id){ idade=id; } public static void main(String[] args) { Dog d = new Dog(10); Dog d1 = new Dog(10); System.out.println(d.equals(d1)); } public boolean equals(Object o){ if((o instanceof Dog)&&(((Dog)o).idade==this.idade)){ return true; }else{ return false;
Certificao JAVA
} } }
112
/* presta ateno o this referencia a quem chamou equals no caso d e o que Object recebeu foi d1*/ ........................ public class Equa{ public static void main(String args[]){ String c= new String("Camilo"); String d ="Camilo"; System.out.println(c.equals(d)); System.out.println(c==d);//ele nao referencia a c, tem apenas o mesmo valor que d. - false System.out.println(c=="Camilo");//aqui um objeto q tem o valor Camilo System.out.println(d=="Camilo");//aqui ele referencia a Camilo } } /* d="camilo" est referenciado a Camilo o mesmo que fazer isso com objetos c=d; digo que c referencia a d por isso que a ultima linha true */ /* a pentultima false pq c nao referencia a Camilo tem apenas um valor camilo*/
hashCode()
Usado para melhorar desempenho de grandes conjuntos de dados. Dois nomes diferentes pode ter o mesmo valor.Ex.: Amy e May. Cdigos hashing possui para cada caracter um valor depois somado tendo o resultado inteiro. 1 encontrar o deposito certo onde ta o elemento 2 procurar agora o elemento dentro do deposito equals(). Mesmo que o valor retornado for em hashCode(), o mtodo apropriado. O contrato(equals()) deseja que dois objetos iguais tenha cdigos hashing idnticos. O uso de transient valido.(porem no eh apropriado). class has{ int z; has(int a){ z=a; } public boolean equals(Object o){ if((o instanceof has)&&(((has)o).z= =this.z)){ return true; }else{return false;} } public int hashCode(){ return z*2; } public static void main(String ags[]){ has h = new has(5); has b = new has(8); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA System.out.println(h.equals(b)); System.out.println(h.hashCode()); System.out.println(b.hashCode()); }} /* aqui o valor de z nao foi alterado e sim definido um valor para o codigo hash desse tipo do objeto*/ .................................................................
public class Difhas { String nome; Difhas(String name){ nome=name; } public boolean equals(Object o){ if((o instanceof Difhas)&&(((Difhas)o).nome==this.nome)){ return true; }else{return false;} } public int hashCode(){ return nome.length()*2; } public static void main(String[] args) { Difhas d = new Difhas("cam"); Difhas d1 = new Difhas("cay"); System.out.println(d.equals(d1)); System.out.println(d.hashCode()); System.out.println(d1.hashCode()); }} /*objeto diferente porem hashing iguais*/ ............................ public class HashInt { String aa; HashInt(String a){ aa=a; } public static void main(String[] args) { Integer a=20; Integer b=20; String n = "Camilo"; String n1 = "Camilo"; HashInt h = new HashInt("Camilo"); HashInt h1 = new HashInt("Camilo"); System.out.println(a.equals(b));//1 System.out.println(n.equals(n1)+ " " + n.hashCode() + " " + n1.hashCode());//2
113
//objetos = = com hashing !=

System.out.println(h.equals(h1)+ "" + h.hashCode()+""+ h1.hashCode());//3 } public boolean equals(Object o){ if((o instanceof HashInt)&&(((HashInt)o).aa==this.aa)){ return true; }else{return false;} }}
Certificao JAVA
/* observe aqui que tenho um equal true porem hashing diferente(//3) isso pq nao implementei meu metodo hashCode entao a jvm nao tem como fazer isso ela gera um codigo qualquer*/ true //1 true 2011086237 2011086237 //2 true 3541984 4565111 //3
114
objetos ! = com hashing = = class Codh{ public int hashCode(){ return 2; } Codh(int z){} public static void main(String args[]){ Codh c = new Codh(8); Codh d = new Codh(8); System.out.println(c.equals(d)); System.out.println(c.hashCode()); System.out.println(d.hashCode()); }} /*objetos diferentes com mesmo codigo hashing*/ class StiCod{ public static void main(String args[]){ String n = new String("neto"); String m = new String("neto"); System.out.println(n.hashCode()); System.out.println(m.hashCode()); } }
class EffectCode{ public static void main(String arg[]){ Car c = new Car(101); Car c1 = new Car(101); System.out.println(c.equals(c1)); System.out.println(c.hashCode()); System.out.println(c1.hashCode()); } } class Car{ int placa; Car(int p){ placa=p;} public boolean equals(Object o){ if((o instanceof Car) &&(((Car)o).placa==this.placa)){ return true; }else{return false;} } public int hashCode(){ return placa*2/3; } }
Certificao JAVA
/* lembrar que o equals deve ser da class q desejo comparar*/ /* objetos != com hashing ==*/ /* objeto(valores) iguais e hashing ==*/
115
Fiz essa tabela para facilitar a vida: Objetos == == != hashCode !=(qdo no implementado) = =(ambos implementado) = =(may, amy).
Posso ter objetos = = com hashing != Posso ter objetos = = com hashing = = + eficiente Posso ter objetos ! = com hashing = = - eficiente GENERICOS E COJUNTOS Conjuto representa qualquer estrutura de dados, onde objetos so armazenados. Em um conjuto possvel: inserir, remover ,busca, recuperar objetos. Ordenado X Classificado: Ordenado - existe uma ordem para o conjunto seguir. Por exemplo um conjunto de inteiro segue 1...2...3. Classificado ordem do conjunto por alguma regra de classificao. Por exemplo class Car, regra pode ser pela cor, fornecedor. Collection uma interface e Set, List e Queue deriva dessa interface mas no implementa. Mtodos comuns add(), remove(). Collections uma class que armazena vrios metodos estticos utilitrio como o sort() que serve para ordenao. HashTable (interface Map) essa class no ordenada, mais segue uma lgica interna para determinar a ordem. Com base nos cdigos hashing. Os mtodos dessa class so sincronizados.(e pertence a interface MAP). No aceita nem chaves nem valores null. HashMap - aceita chaves e valores null, aqui os mtodos dessa class no eh sincronizado e tendem a rodar mais rpido que hashTable. A duplicata de chaves, acaba gerando uma subcricao.
class MapHa{ public static void main(String args[]){ HashMap m = new HashMap(); m.put(null,null); m.put(7,2); m.put(7,25); System.out.println(m); } } /* Map nao aceita duplicatas de chaves, ele sobreceve*/
Certificao JAVA
116
HashSet no existe uma ordenao na interao. No aceita objetos iguais no conjunto desde que os cdigo hashing seja implementado. import java.util.HashSet; import java.util.Iterator; class SetHash{ public static void main(String args[]){ HashSet<Integer> h = new HashSet<Integer>(); h.add(20); h.add(10); h.add(20); Iterator<Integer>it=h.iterator(); while(it.hasNext()){ Integer in=it.next(); System.out.println(in);} } }//aqui ele no aceita 20 duas vezes pq objetos Wrapper e String j implementa hashCode(). Arraylist - como um array mantem a ordem pelo ndice.
import java.util.ArrayList; public class ListInt { public static void main(String[] args) { ArrayList<Integer> list = new <Integer>ArrayList(); list.add(10); System.out.println(list); } } /* isso nao compila pela ordem do <Integer>*/ import java.util.ArrayList; import java.util.Collections; public class Locadora { public static void main(String[] args) { ArrayList<Integer> filmes = new ArrayList<Integer>(); filmes.add(10); filmes.add(5); filmes.add(40); filmes.add(35); Collections.sort(filmes); System.out.println(filmes); }}
LinkedHashSet - mantem a ordem pela insero, ! = entre ArrayList que posso escolher a posio especifica do ndice.(no ArrayList) e no aceita duplicatas caso o cdigo hashing esteja implantando de forma correta. LinkedList aceita duplicata e a ordem de iterao por insero. A INTERFACE LIST - ndice tem relevncia. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
117
Arraylist, vector, linkedlist,

INTERFACE SET HashSet,Linkedhashset, TreeSet.(nao aceita null - TreeSet). INTERFACE MAP identificadores(Keys) exclusivo sao relevantes. LinkedHashMap e hashTable(mtodo sincronizado), hashMap(aceita valores e chaves null).
import java.util.TreeMap; class MapHa{ public static void main(String args[]){ TreeMap tm = new TreeMap(); tm.put(4,3); tm.put("a",5); System.out.println(tm); } }//lana uma exceo devido meu TreeMap ter chaves de tipos diferentes
HashMap no utiliza nenhuma ordem nem classificao para iterao, prefira essa quando a ordem dos objetos no for essencial.
import java.util.HashMap; public class RoupMap { String roupa; RoupMap(String a){ roupa=a; } public boolean equals (Object o){ if((o instanceof RoupMap)&&(((RoupMap)o).roupa==this.roupa)){ return true; }else{return false;} } public int hashCode(){ return roupa.length()*2; } public static void main(String[] args) { HashMap<String,String> lista = new HashMap<String,String>(); lista.put("k1", "infantil"); lista.put("k2", "adulto"); lista.put("k3", "moda"); String k2="saia"; String k4="moda"; String z="k3"; System.out.println(lista.get(k2)); System.out.println(lista.get(k4)); System.out.println(lista.get("k1")); System.out.println(lista.get(z)); } } null null infantil moda
Certificao JAVA
/*fato interessante tenho a chave k2 mais nao com o valor saia por * isso quer retorna null e jamais o valor de k2 pq equals false*/
118
............... import java.util.HashMap; class Maphash{ public static void main(String agr[]){ HashMap<Integer,String>add = new HashMap<Integer,String>(); add.put(10,"tv"); add.put(14,"som"); add.put(10,"micro"); //me retorne um cara com a chave 14 System.out.println(add.get(14)); System.out.println(add.size()); }} LinkedHashMap utiliza uma ordem de iterao pela ordem de insero, um pouco mais lento na insero e remoo dos elementos.(mtodo sincronizados) TreeMap e TreeSet - introduzo minha propria regra de comparacao para ordenao dos elementos. Exemplos : import java.util.Map; import java.util.HashMap; class Varejo{ String produto; Varejo(String a){ produto =a;} public boolean equals(Object o){ if((o instanceof Varejo) &&((Varejo)o).produto==produto){ return true;} else{return false;} } public int hashCode(){ return produto.length();} public static void main(String agrs[]){ Varejo v = new Varejo("Cam"); //recebe apenas objetos dessas classes Map<Integer,String> var = new HashMap<Integer,String>(); var.put(10,"cama Casal"); var.put(20,"Cama Solteiro"); var.put(30, "HP Notebook"); System.out.println(var.size()); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //exibe o objeto com a chave 20 System.out.println(var.get(20)); //codigo do meu objeto System.out.println(v.hashCode()); //verifica se contem a chave System.out.println(var.containsKey(10)); //retorna todas as chaves System.out.println(var.keySet()); var.remove(20); System.out.println(var.size()); }} ..
import java.util.Map; import java.util.LinkedHashMap; import java.util.Scanner; class Loja{ static String info; public static void main(String [] agrs){ Map<Integer,String> cad = new LinkedHashMap<Integer,String>();
119
Scanner dados = new Scanner(System.in); int qtde=0; int cadinfo=0; int cont=0; System.out.println("quantos produtos deseja cadastrar "); qtde = dados.nextInt(); while(cont<qtde){ System.out.print("\nCadastre os produtos "); info = dados.next(); cad.put(cadinfo, info); cadinfo++; cont++; } System.out.println("total de produtos cadastrados " + cad.size()); System.out.println("imprimindo produtos cadastrado...."); for(int a=0;a<cadinfo;a++){ System.out.println(cad.get(a)); } System.out.println("Codigos chaves dos produtos por ordem de insercao "); System.out.println(cad.keySet()); System.out.println("Remova um produto digite o codigo "); int co = dados.nextInt(); cad.remove(co); System.out.println("total de produtos cadastrados " + cad.size()); }}
..................................................
Certificao JAVA import java.util.Map; import java.util.HashMap; class Galo{ public Galo(String n){name=n;} public String name; public boolean equals(Object o){ if((o instanceof Galo)&&((Galo)o).name==name){ return true;} else{return false;} } public int hashCode(){return name.length();} } class Pinto{} enum Pet{DOG,CAT,HORSE} class MapT{ public static void main(String agrs[]){ Map<Object,Object>m=new HashMap<Object,Object>(); m.put("k1", new Galo("aiko")); m.put("k2", Pet.CAT); m.put(Pet.DOG, "Dog "); Galo g = new Galo("Lopes"); m.put(g,"key"); g.name="Fuga";
120
//passando a chave e imprimindo System.out.println(m.get("k1")); //retorna nome da Class mais suas propridades System.out.println(m.get(Pet.DOG));//RETORNA Dog System.out.println(m.get("k2"));//retorna CAT System.out.println(m.get(g));//return null ja que fuga != key }
//nao basta o hashCode ter o mesmo valor o metodo equals deve ser true Priority Queue - o propsito criar uma fila com prioridade de entrada e de sada, diferente do FIFO. Usando a interface Comparator.(implementar o mtodo int compare(Object,Object)). Mtodos: offer() adiciona um elemento a fila. Retornar null se tiver vazio: poll() retorna o elemento com maior prioridade e remove peek() mostra o elemento com maior prioridade e no remove. Se tiver fazio retorna null. Esses lana excees no verificadas: remove() remove um elemento, se estiver vazio lana uma exceo. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA element() retorna o elemento na ponta da queue se estive vazia lana uma exceo
121
import java.util.PriorityQueue; import java.util.Comparator; class Queu{ public static void main(String agrs[]){ PriorityQueue<Double> pq = new PriorityQueue<Double>(); pq.offer(3.5); pq.offer(8.0); pq.offer(1.4); System.out.print(pq.poll() + "removido " + "\n"); System.out.println(pq); System.out.println(pq.peek()); Qcomp qc = new Qcomp(); PriorityQueue<Double> pr = new PriorityQueue<Double>(2,qc); pr.offer(8.8); pr.offer(9.0); System.out.println(pr); } }
class Qcomp implements Comparator<Double>{ public int compare(Double a, Double b){ return b.compareTo(a); } } /*observe que eu carrego meu comparator com outros valores e ordeno ele da forma que desejo*/ import java.util.PriorityQueue; class QT{ public static void main(String agrs[]){ PriorityQueue<String> pq = new PriorityQueue<String>(); pq.offer("Camilo"); pq.offer(" efgenia"); System.out.println(pq); } } /*como nao definir nenhuma ordem aqui vai a ordem natural para o tipo do objeto caso fosse uma instancia que no tem uma ordema ,seria por por fila.*/ ............................................ import java.util.Queue; import java.util.PriorityQueue; import java.util.Comparator; class PQ{ //aqui to especificando como vai ser minha ordenacao de traz para frente Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA static class PqCom implements Comparator<Integer>{ public int compare(Integer on, Integer tw){ return tw-on; } } public static void main(String agrs[]){ int[] ia = {12,48,2,3,4,6,9}; PriorityQueue<Integer> pq = new PriorityQueue<Integer>(); for(int x : ia) pq.offer(x); for(int x : ia) System.out.print(pq.poll() + " "); System.out.println(""); //meu comparator PqCom pc = new PqCom(); PriorityQueue<Integer> pq2 = new PriorityQueue<Integer>(2,pc); for(int x : ia) pq2.offer(x); System.out.println("size " + pq2.size()); System.out.println("peek " + pq2.peek()); System.out.println("size " + pq2.size()); System.out.println("poll " + pq2.poll()); System.out.println("size " + pq2.size()); for(int x:ia) System.out.print(pq2.poll() + " "); }} ..
122
import java.util.Queue; import java.util.PriorityQueue; class Que{ public static void main(String arg[]){ PriorityQueue<String> que = new PriorityQueue<String>(); que.offer("Camilo"); que.offer("Beni"); que.offer("CAmilo"); System.out.println(que.peek()); System.out.println(que.element());//mostra o elemento - primeiro System.out.println(que.remove());//remove o primeiro elemento System.out.println(que.peek());//o proximo elemento da filas System.out.println(que.remove("Lopes"));//retorna false nao existe esse cara na fila }} /* imagine isso aqui como uma fila de um banco, ou de um hospital nao a toa que a maioria da populao acorda cedo para pegar os primeiros locais da fila para ser atendindo*/ //ordem dessa fila Beni - CAmilo - Camilo*/
Certificao JAVA Conjuntos - so capazes de armazenar objetos, + no tipos primitivos A classe collections - fornece mtodo de ordenao sort(). Abaixo exemplos do uso do conjuto ArrayList. import java.util.*; class TestSort2{ public static void main(String args[]){ ArrayList<String> stuf = new ArrayList<String>(); stuf.add("efigenia"); stuf.add("camilo"); stuf.add("Benigna"); System.out.println("lista " + stuf); //metodo que ordena sort - class Collections Collections.sort(stuf); System.out.println("lista ordenada por nome " + stuf); System.out.println("tamanho da lista " + stuf.size()); System.out.println(" o numero buscado - " + stuf.contains(48)); }} import java.util.ArrayList; import java.util.Collections; public class ListaInt{ public static void main(String []args){ ArrayList<Integer> objtlista = new ArrayList<Integer>(); int n =3; //autoboxing converte automaticamente objtlista.add(n); objtlista.add(50); objtlista.add(2); objtlista.add(5); System.out.println("lista " + objtlista); //ordeno a lista Collections.sort(objtlista); System.out.println("ordenada lista " + objtlista); System.out.println("Tamanho de minha lista " + objtlista.size()); }} /*insiro numero na minha lista e depois ordeno e removo um numero*/ import java.util.*; Material desenvolvido Camilo Lopes - Resumo de Estudo
123
Certificao JAVA public class TestArrayList{ public static void main(String [] args){ List<String> teste = new ArrayList<String>(); String s = "hi"; teste.add("String"); teste.add(s); /*List myints = new ArrayList(); myints.add(5);*/ //imprime aqui o tamanho de minha lista System.out.println(teste.size()); System.out.println(teste.contains(50)); //verifico se hi existe na lista System.out.println(teste.contains("hi")); teste.remove("hi"); System.out.print("tamanho de itens na lista"); System.out.println(teste.size()); } } INTERFACE lang.COMPARABLE
124
compareTo() - qdo subscrito o argumento deve est classificado. usado pelo mtodo sort() de Collections. Implementar essa interface, precisamos apenas implementar o mtodo compareTo(). compareTo() sempre retorna um int positivo ou negativo quando o objeto for import java.util.ArrayList; import java.util.Collections; class Casa implements Comparable<Casa> { Integer cod; String convidado; Casa(String nome, Integer c){ convidado=nome; cod=c; } public String toString(){ return cod + " "+convidado; } public static void main(String args[]){ Casa c1 = new Casa("Marcela", 20); Casa c2 = new Casa("Carla", 14); Casa c3 = new Casa("Carlos",77); ArrayList<Casa> lista = new ArrayList<Casa>(); lista.add(c1); lista.add(c2); Material desenvolvido Camilo Lopes - Resumo de Estudo = =.
Certificao JAVA lista.add(c3); Collections.sort(lista); System.out.println(lista); } //implementando meu metodo da interface //para definir a classificacao public int compareTo(Casa ca){ return this.cod - ca.cod; } } /*observer que minha ordem de classificacao por cod*/ import java.util.ArrayList; import java.util.Collections; class Dog implements Comparable<Dog>{ String nome; Dog(String n){ nome=n; } public String getNome(){ return nome; } public String toString(){ return nome;} public static void main(String arg[]){ Dog d = new Dog("bela"); Dog d1 = new Dog("aoop"); Dog d3 = new Dog("aiko"); Dog d4 = new Dog("baz"); ArrayList<Dog> animal = new ArrayList<Dog>(); animal.add(d); animal.add(d1); animal.add(d3); animal.add(d4); Collections.sort(animal); System.out.println(animal.toString()); } public int compareTo(Dog dd){ return nome.compareTo(dd.getNome()); }
125
} bom lembrar que sort() faz apenas uma ordenao sem classificacao se implementar o mtodo compareTO(), posso fazer uma ordenao com classificao. Um exemplo classificar os filmes de minha locadora pelo objeto categoria. compareTo() s pode ser implementado uma vez em uma class. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
import java.util.ArrayList; import java.util.Collections; public class LocCar implements Comparable<LocCar>{ String carro; int placa; LocCar(String car, int placa){ this.placa=placa; carro=car; } public static void main(String[] args) { LocCar car1 = new LocCar("monza",1420); LocCar car2 = new LocCar("Celta",1720); LocCar car3 = new LocCar("Focus",1571); ArrayList<LocCar> lista = new ArrayList<LocCar>(); lista.add(car1); lista.add(car2); lista.add(car3); Collections.sort(lista); System.out.println(lista); } public int compareTo(LocCar lc){ return placa-lc.placa; } public String toString(){ return placa + " " + carro; }}/*classificado e ordenado pela placa do carro*/
126
INTERFACE util.COMPARATOR Fornece a capacidade de classificar, devida coleo de uma srie de formas diferentes. Possui apenas um mtodo, int compare(). Retorna sempre um int, como o outro mtodo da interface comparable.
Comparable!= comparator
Comparable s posso criar uma seqncia de classificao. Comparator posso criar varias seqncias de classificao. Classificando com classes Arrays Classificar array de objetos da mesma forma que classificar conjuntos de objetos. Arrays.sort(). Os objetos devem ser mutuamente comparveis, ou seja, os objetos devem ser do mesmo tipo, no posso ter com tipos diferentes. Ex.: Integer com String. binarySearch() mtodo de busca Realizando bucas Collection e Array so classes que permite uma busca por um elemento especifico dentro de um conjunto ou array. As buscas retorna o ndice int do elemento que foi procurado. Quando realizar uma busca, o conjunto deve ser classificado antes da procura. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
127
O inverso do citado acima, o resultado nao sera previsveis. A busca deve ser feita como classificado e se usar ordem natural ela deve ser feita dessa forma. Se usar um comparator, na classificao, a busca deve ser feita usando o mesmo comparator, no segundo arg do mtodo, e se o array for de tipo primitivo o comparator no aceita, aceitvel apenas objetos. LEMBRE-SE DISSO. Exemplo de uma busca no Array. import java.util.*; class Test{ public static void main(String args[]){ String[] sa = {"ceu ", "lucas ", "camilo "}; //ordenacao normal //Arrays.sort(sa); for(String a : sa) //imprimo o array System.out.print(a); //se for positivo ele encontrou System.out.println("\none = " + Arrays.binarySearch(sa,"camilo ")); Compa co = new Compa(); //nova classificacao por String //a antiga eh descartada Arrays.sort(sa,co); System.out.println("\none = " + Arrays.binarySearch(sa,"camilo ",co)); } static class Compa implements Comparator<String>{ public int compare(String a, String b){ return a.compareTo(b); } }} Exemplo bem legal deitel sexta edio. import java.util.Arrays; public class UsingArrays{ private int intarray[]={1,2,3,4}; private double doubleArray[]={8.4,3.2,2.0,1.5}; private int filledIntArray[], intArraycopy[]; public UsingArrays(){ filledIntArray = new int[10]; intArraycopy = new int[intarray.length];
//preencho meu array com o valor 7 Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA Arrays.fill(filledIntArray,7); //ordeno meu array Arrays.sort(doubleArray); System.arraycopy(intarray,0,intArraycopy,0,intarray.length); } public void printArrays(){ System.out.print("array double "); for(double valordouble : doubleArray) System.out.printf("%.1f ", valordouble); System.out.println(); System.out.print("array int "); for(int valorint : intarray) System.out.printf("%d ", valorint); System.out.println(); } //metodo localiza valor no array public int seachint(int valor){ //valor passado com o array return Arrays.binarySearch(intarray,valor); } //compara o conteudo do array public void compara(){ boolean b = Arrays.equals(intarray,filledIntArray); System.out.printf("intarray %s intArraycopy", (b ? "==" : "!=")); } public static void main(String args[]){ UsingArrays use = new UsingArrays(); use.printArrays(); use.compara(); int localiza = use.seachint(5); if(localiza>=0) System.out.printf("\nfound 1 element % d intarray ", localiza); } } Agora um exemplo meu aprimroado eheh salve o deitel para entender essa parte a kathy deixou a desejar... ....................................................... import java.util.Arrays; import java.util.Scanner; public class CrieA{ Material desenvolvido Camilo Lopes - Resumo de Estudo
128
Certificao JAVA private int array[] = new int[5]; private int num,c=0; private int array2[] = new int [array.length]; public CrieA(){ Scanner ler = new Scanner(System.in); while(c<array.length){ System.out.println("digite valores para o array"); array[c]=ler.nextInt(); c++; } //copio para o array2 com o metodo arraycopy; System.arraycopy(array,0,array2,0,array.length); //ordenar meu array Arrays.sort(array); } //metodo que imprime meu array public void print(){ System.out.print("valores do array "); for(int valor : array) System.out.print(valor + ","); } //localiza um valor no array metodo /* ** ler isso assim retorna o valor do indice, caso encontrado o valor passado para esse array*/ public int localiza(int valor){ return Arrays.binarySearch(array,valor); } //metodo que compara conteudo public void compara(){ boolean b =Arrays.equals(array,array2); System.out.printf("\narray %s array2\n", (b ? "==" : "!=")); } public static void main(String args[]){ CrieA ob = new CrieA(); ob.print(); ob.compara(); int loc = ob.localiza(10); if(loc>=0) System.out.printf("o elemento 10 ta no array posicao %d ", loc); else System.out.println("o 10 nao ta no array"); }} Convertendo array em lista e o inverso Material desenvolvido Camilo Lopes - Resumo de Estudo
129
Certificao JAVA
130
Array.asList() um mtodo que copia um array para uma list. A mudana realizada em uma lista/array atualizado em ambos automaticamente. toArray() faz o inverso, copia da lista para o array.(retornar um object caso seu argumento seja vazio). Iterator um objeto, onde permite fazer um loop do conjunto. Ele possui dois mtodos: hasNext() retorna verdadeiro true, se tiver mais de um elemento no conjunto. next() esse aqui retorna o objeto e move o foco, para o prximo elemento seguinte. O interator deve ser do tipo da sua lista: Interator<Dog>, Interator<Integer>. import java.util.*; class Dog{ public String nome; Dog(String n){nome=n;} } class ItTest{ public static void main(String cama[]){ List<Dog> d = new ArrayList<Dog>(); Dog dog = new Dog("aiko"); d.add(dog); //d.add(new Dog("camilo")); //crio meu interador Iterator<Dog> i3 = d.iterator(); //enquanto nao for final de meu conjunto //aqui eh true qdo tenho + de 1 elemento dentro no meu conjunto //tenho aqui nesse caso 2 while(i3.hasNext()){ //d2 recebe o proximo objeto da lista Dog d2 = i3.next(); System.out.println(d2.nome); } System.out.println("size " + d.size()); System.out.println("get1 " + d.get(1).nome); //imprimo a posicao e quem ta no indice System.out.println("aiko " + d.indexOf(dog)); //remove o cara da primeira posicao d.remove(1); //crio um array e coloco minha list dentro dele Object[] oa = d.toArray(); //pego meu array e coloco no object for(Object o : oa){ Dog d2 = (Dog)o; System.out.println("oa " + d2.nome); } } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA } Uso mais complexo do Iterator(). Ufa isso lenha viu!! import java.util.List; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectioTest{ private static final String[] colors={"AZUL", "AMARELO", "BRANCO"}; private static final String[] removeColors={"PRETO","AMARELO","ROSA"}; public CollectioTest(){ //crio duas listas List<String> list = new ArrayList<String>(); List<String> removelist = new ArrayList<String>(); for(String color : colors) list.add(color); for(String recolor : removeColors) removelist.add(recolor); System.out.println("Arrays list : "); for(int c=0;c<list.size();c++) System.out.printf("%s ", list.get(c)); //chamo o metodo remove //passo os elementos das lista removeColors(list,removelist); System.out.println("\n\nAralist afte removeColors: "); //imprimo a lista atualziada com objeto removido os iguais for(String color : list) System.out.printf("%s " ,color); } //ele remove os objetos iguais que tiver no arrayColors private void removeColors(Collection<String> collection1,Collection<String> collection2){ Iterator<String> it = collection1.iterator();
131
while(it.hasNext()) //if meu array 2 removeColors for = ao proximo elemento de collection1 //que list entao remove de list if(collection2.contains(it.next())) it.remove(); } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA public static void main(String args[]){ new CollectioTest(); } }
132
na prxima pagina fiz uma class mais simplificada aff, deu trabalho espero ter entendi isso hehe foda viu!!
import java.util.List; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; class Intera{ private String[] arraynome={"Camilo", "Efigenia","Marcos"}; private String[] array2 ={"Efigenia", "Marcelo", "Camilo"}; public Intera(){ List<String> list = new ArrayList<String>(); List<String> list2 = new ArrayList<String>(); for(String a : arraynome) list.add(a); for(String b : array2) list2.add(b); System.out.println("minha lista : "); for(String c :list) System.out.print(c + " "); System.out.println(); remove(list,list2); //removei os iguais do meu array heheh for(String atu : list) System.out.print(atu); } private void remove(Collection<String> col1, Collection<String> col2){ //crio um iterator de arraynome - list Iterator<String> it = col1.iterator(); //enquanto tiver itens no meu conjunto while(it.hasNext()) if(col2.contains(it.next())) it.remove(); } public static void main(String args[]){ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA new Intera(); } }
133
.................
import java.util.*; class Inter{ public static void main(String [] agrs){ ArrayList<Integer> list = new ArrayList<Integer>(); list.add(20); list.add(30); list.add(10); Iterator<Integer>it=list.iterator(); while(it.hasNext()){ Integer in=it.next(); System.out.println(in); } System.out.print(list); }} Sets usado quando nao permitido duplicator no conjunto. Na tentativa o retorno false. Set s = new HashSet(); hashSet() nao garante nenhum tipo de ordenacao. O desempenho aqui bastante alto, pois usa o hashCode(), para identificaco. O uso dessa interface quando a ordenao no tem prioriade e sim quando no tenho duplicatas. import java.util.*; class SetTest{ public static void main(String[] agrs){ boolean[] ba = new boolean[4]; //crio meu objeto set Set s = new HashSet(); ba[0] = s.add("a"); ba[1] = s.add(new Integer(42)); ba[2] = s.add("a"); ba[3] = s.add(new Object()); for(int x = 0; x<ba.length; x++) System.out.print(ba[x] + " "); System.out.println("\n"); //imprima os objetos for(Object o : s) Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA System.out.println(o + " "); }} /*Set usado qdo nao se pode ter duplicada em seu conjuto*/ /*se eu colocar o TreeSet() dar erros tenho objetos diferente, entao no possivel comparar objetos !=*/
134
import java.util.HashSet; import java.util.Iterator; public class ListSet { public static void main(String[] args) { HashSet h = new HashSet(); h.add(20); h.add("camilo"); h.add(40); h.add(20); System.out.println(h); }} ..
import java.util.List; import java.util.Arrays; import java.util.HashSet; import java.util.Set; import java.util.Collection; public class DeitSet{ private static final String colors[] = { "vermelho", "azul", "verde", "amarelo", "preto", "vermelho", "azul", "rosa"}; public DeitSet(){ //copio meu array para uma lista - asList() List<String> list = Arrays.asList(colors); System.out.printf("ArrasList: %s\n", list); //passo minha lista de arrays para o metodo printDuplo(list); } //metodo que verifica duplicidade no array private void printDuplo(Collection<String> col){ //crio um objeto com o argumento passado //hashSet nao aceita duplicatas Set<String> set = new HashSet<String>(col); System.out.println("\nduplicates "); //imprimo sem duplicada Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA for(String s: set) System.out.printf("%s ", s); System.out.println(); } public static void main(String args[]){ new DeitSet(); } }
135
import java.util.Set; import java.util.HashSet; class SetTest{ public static void main(String [] agrs){ Set s = new HashSet(); s.add(42); s.add("a"); s.add(42); s.add(77); System.out.println(s); System.out.print("Tam " + s.size()); } }//nao tem uma ordem de iteracao especifica ........................................................... import java.util.LinkedHashSet; import java.util.Set; class Set2{ public static void main(String [] agrs){ Set<Double> st = new LinkedHashSet<Double>(); st.add(8.0); st.add(9.2); //st.add("oao"); obserser que criei regras so aceita Double System.out.println(st); } } //se compilar new LinkedHashSet(); - emite uma mensagem informado //que o codigo est inseguro.. mais roda normal o programa. ................................................. import java.util.Set; import java.util.LinkedHashSet; class Linkhas{ public static void main(String [] ag){ Set st = new LinkedHashSet(); st.add(87); st.add(87); st.add(100); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA st.add("Lopes"); System.out.println("Tamanho " + st.size()); System.out.print(st); } } //intera na ordem que foi inserido
136
import java.util.LinkedHashSet; import java.util.Set; class Sett{ public static void main(String args[]){ Set s = new LinkedHashSet<Integer>(); s.add(7.0); System.out.println(s); }} /*isso funciona minha lista Set aceita qualquer coisa, mesmo que eu defina q vou ter objetos do tipo Integer, mas como definir qualquer coisa para a lista prevalece o do tipo e nao do objeto*/ //porem com avisos
PriorityQueue Ordena os elementos usando prioridade definida pelo usurio. Pode ser por: ordem natural, implementao do comparator. Aqui quebrada a idia de FIFO em uma fila. Mtodos dessa interface: peek(), poll(), e offer(). Offer() adiciona elementos. Peek() mostra o primeiro elemento. Poll() remove o primeiro elemento. import java.util.*; class Pq{ static class PQsort implements Comparator<Integer>{ public int compare(Integer on, Integer tow){ return tow - on; //ordeno pela ordem inversa } } public static void main(String args[]){ int[] ia = {1,5,3,6,7}; PriorityQueue<Integer> pq1 = new PriorityQueue<Integer>(); for(int x : ia) Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
137
//carrega os elementos do array e ordena por ordem natural //observe que agora tenho um conjunto com os elementos do array pq1.offer(x); for(int x : ia) System.out.print(pq1.poll() + " "); System.out.println(); //vou realizar uma classificacao usador Comparator PQsort pqs = new PQsort(); PriorityQueue<Integer> pq2 = new PriorityQueue<Integer>(10,pqs); //aqui carrego meu array para meu comparator for(int x : ia) pq2.offer(x); System.out.println("size " + pq2.size()); System.out.println("peek " + pq2.peek()); System.out.println("size " + pq2.size()); //imprimo o ultimo cara que foi removido System.out.println("poll " + pq2.poll()); System.out.println("size " + pq2.size()); for(int x : ia) System.out.print(pq2.poll() + " "); } } import java.util.PriorityQueue; class Priorit{ public static void main(String args[]){ PriorityQueue<Double> pq = new PriorityQueue<Double>(); pq.offer(3.1); pq.offer(11.8); pq.offer(10.0); System.out.print("Polling from "); //enquanto tiver elemento vou imprimindo o topo while(pq.size() > 0){ //imprime o topo da pilha System.out.printf("%.1f ", pq.peek()); pq.poll();//remove o topo da fila } }}
import java.util.PriorityQueue; class Prior{ public static void main(String args[]){ PriorityQueue<Integer> pq = new PriorityQueue(); pq.offer(7);
Certificao JAVA
pq.offer(2); pq.offer(10); System.out.println(pq.peek()); System.out.println(pq); System.out.println(pq.poll()); System.out.println(pq); System.out.println(pq.peek()); } } /* ele ordena por ordem natural buscando o elemento menor do conjunto ondem define que oq tem mais prioridade*/ 2//cara com maior prioridade primeiro da fila [2, 7, 10]//meus elementos q ta na fila 2//mostro o cara de maior prioridade e removo [7, 10]//minha nova fila 7//mostro o cara com maior prioridade da nova fila
138
Revisao de exemplos:
import java.util.HashSet; class Haset{ public static void main(String a[]){ HashSet<Integer> h = new HashSet<Integer>(); h.add(8); h.add(8); System.out.println(h); }}//so imprime 8 uma vez. import java.util.*; class ListIntera{ public static void main(String args[]){ ArrayList list = new ArrayList<Carro>(); list.add(new Carro("corsa")); list.add(new Carro("celta")); list.add(new Carro("bug")); Iterator<Carro>itera=list.iterator(); while(itera.hasNext()){ Carro car = itera.next(); System.out.println(car.nome); } }} class Carro{ String nome; Carro(String n){ nome=n; } } /* obserse que ele intera cada elemento de Carro, se manda so imprimir a lista ele vai imprimir o valor do objeto */ import java.util.Arrays; import java.util.ArrayList; class Ondear{ public static void main(String args[]){ String [] ar={"Camilo", "Beni", "CAMILO"};
Certificao JAVA
Arrays.sort(ar); for(String s : ar) System.out.println(s); System.out.println(Arrays.binarySearch(ar,"camilo")); } }//busca no array e ordenao retorna -3 .................................... class PassList{ public static void main(String arg[]){ ArrayList<Integer>list = new ArrayList<Integer>(); list.add(8); list.add(7); int z = list.size(); Integer[] array =new Integer[z]; //passando de lista para um array array=list.toArray(array); Arrays.sort(array); for(int y : array) System.out.println(y); }} . import java.util.*; class IndexList{ public static void main(String args[]){ ArrayList list = new ArrayList<Integer>(); list.add(8); list.add(8.0); //me traz a posicao do elemento 8 se existir System.out.println(list.indexOf(8)); //me traz o elemento na posicao 0 System.out.println(list.get(0));
139
}//ele aceitou 8.0 pq o tipo de meu ArrayList no existe. } Tabela de mtodos das interfaces List Set Map Add Add containsValue, containsKey, containsValue, containsKey, containsValue, containsKey, contains contains contains Get Get indexOf Iterator Iterator Keyset Put Remove(index),remove(object, Remove(index),remove(object, Remove(index),remove(object, remove(key). remove(key). remove(key). size() size() size() toArray() toArray()
Genricos
Os genricos ele servem para especificar o tipo de conjunto. Ou seja manter a proteo dos objetos para aquele determinado conjunto. Procure no colocar maa na caixa de uva. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
140
Pr-Java 5 No pr-java 5 no era possvel informar que tipo de conjunto. Veja List l = new ArrayList(); l.add(74); l.add(new Dog(dd)); //recebe qualquer coisa No java 5 voc especifica que tipo de objeto seu conjunto pode receber. Eu falei OBJETO cuidado para no confudir com tipos PRIMITIVOS. List<Integer> ist = new ArrayList<Integer>(); ist.add(99); ist.add(44); ist.add(camilo);//erro de compilacao nao pode receber String so Integer. Se usar java 5 com pr-Java sua proteo vai para o saco, ele aceita qualquer coisa pensando que ta recebendo o tipo especifico. Os erros com GENRICOS de compilao e no tempo de execuo ao no ser um Cast que no seja possvel. Mas se voc atribuir tipos diferentes o cdigo no compila. Para a JVM em tempo de execuo voc est usando o pr-java pois seno lanaria uma exceo. O compilador ele que fica encarregado de verificar se esta tudo ok. Compilar cdigos com avisos no quer dizer erro de compilao. o compilador apenas avisa que ali a algo inseguro. As protees nos conjuntos NO EXISTEM EM TEMPO DE EXECUO ALGUNS EXEMPLO: //uso um tipo especifico mais passo para um nao especifico protecao ja era import java.util.*; class TestBad{ public static void main(String [] agrs){ List<Integer> list = new ArrayList<Integer>(); list.add(4); list.add(9); list.add(10); Inserter in = new Inserter(); in.insert(list); System.out.println(list); } } class Inserter{ void insert(List list){ list.add(new Integer(42)); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA list.add(new String("camilo")); list.add(new Double(3.9)); } } /*eita esse ta confuso? eh mais ele adicionou uma String ao ArrayList de Integer pq? * observe que a classe que possui o metodo ela recebe qualquer objeto e adiciona a lista os desenvolvedores tem que manter isso, para que evitasse uma mudana desastrosa, para o novo codigo*/ /* mas eh importante ter cuidado com isso no exame ele vai confudir ao infinito e ficar brincando com java 5 e pre java 5 .genericos eh um bom assunto para brincar*/
141
//isso compila com avisos ja que temos um conjunto nao seguro. // se o metodo da classe Inserter for modificado para void insert(List<Integer> list) o codigo nao compila //pois so posso ter conjunto de Integer e estou adicionando ao meu conjunto outros objetos /*a ideia de conjunto o interessante eh pensar como um Barril experimente colocar dentro de um barril de polvora(Integer) algo que gere Calor(Double) eu acho que explode e voce?(no compila).*/ .................................................................. import java.util.List; import java.util.ArrayList; import java.util.Iterator; class TestLegacy{ public static void main(String [] agrs){ List<Integer>mylist = new ArrayList<Integer>(); mylist.add(7); mylist.add(2); Adder ad = new Adder(); int total = ad.addAll(mylist); System.out.println(total); } } //codigo generico pre-java 5 class Adder{ //recebe qualquer objeto de um conjuto List int addAll(List list){ Iterator it = list.iterator(); int total=0; while(it.hasNext()){ //se nao for Integer ClassCastException //nao eh permitido converter Double em Integer... int i = ((Integer)it.next()).intValue(); total+=i; } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA return total;
142
}} /*usando tipos genericos com nao gerenicos pontos analisar: * observe que a class Test ela usa genericos do java 5 com o tipo * a class Adder usa o genericos pre-java 5 o qual nao possui nenhum tipo para o conjunto de retorno * mais perceba que temos um cash que so aceita Integer caso fosse outro String,Double etc daria ClassCastException */ import java.util.ArrayList; class PosGen{ public static void main(String [] agrs){ ArrayList al = new ArrayList(); al.add(8); al.add(10); al.add("camilo"); al.add(3.4); Preg p = new Preg(); System.out.println(p.addAll(al)); } } class Preg{ public ArrayList addAll(ArrayList lis){ return lis; } } /* observe que a class Preg recebe qualquer conjunto da class ArrayList e o metodo addAll retorna os elementos que receber de um conjunto. e a class onde tem um main tem um conjunto pre-java 5 que recebe qualquer tipo de objeto, menos tipo primitivo mais objeto vai qualquer um nao existe regras de tipo especifico*/ import java.util.*; class ConverPre{ public static void main(String agrs[]){ List lit = new ArrayList(); lit.add(58); System.out.print(lit + " "); }} ............... /*no pre java isso nao funcionava ja que o boxing nao eh feito de forma automatica*/ import java.util.List; import java.util.ArrayList; class Pai{ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA public static void main(String args[]){ ArrayList<String> comp = new ArrayList<String>(); comp.add("pc"); comp.add("tv"); Filho f = new Filho(); f.myComp(comp); System.out.println(comp); }}
143
//nao compila tentei adiciona um integer a minha lista de String class Filho{ public void myComp(ArrayList<String> list){ list.add(new Integer(80)); }} .. import java.util.*; class Ele{ public void inGen(List<Integer> lit){ lit.add(14); } public static void main(String args[]){ List lista = new ArrayList(); lista.add(20); lista.add("lopes"); Ele e = new Ele(); e.inGen(lista); System.out.println(lista); }} /*compila normal ja que minha lista aceita qualquer coisa e o argumento(List) do metodo passo uma lista que nao eh de um tipo especifico*/
lembra que o que passado o tipo do conjunto(antes = ) e no o objeto.
Polimorfismo e Genricos
Ao usar o velho polimorfismo com conjuntos devemos ter certo cuidado, o que j estamos acostumados a usar com array em conjuntos no funciona da mesma forma ou seja: posso ter um Animal[] array, que pode aceitar qualquer tipo ou subtipo de Animal, mas em conjuntos a coisa diferente isso no funciona. Veja: import java.util.ArrayList; import java.util.List; class Animal{} class Dog extends Animal{} class Poli{ public static void main(String agrs[]){ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA List<Animal> l = new ArrayList<Dog>(); l.add(new Animal()); l.add(new Dog());
144
}} Esse cdigo no compila em conjuntos. Mas pq? Lembre-se uma coisa, que falei mais cedo que em tempo de execuo a JVM no sabe que tipo eh seu conjunto pra ela recebe qualquer coisa mais, para chegar na JVM o compilador tem que autorizar sua compilao e isso ele no permite esse cdigo o mesmo que passar tipos <Integer> e <Double> sabemos que isso no permitido em lugar nenhum, posso ter objetos Integer dentro de um Double. o mesmo que comprar uma caixa de ma e levar berinjela dentro dela, ser que ficaria furioso quando abrisse a caixa? Ento o compilador(feirante) ele evitar esses transtorno.(ao cliente). Isso compila: import java.util.ArrayList; import java.util.List; class Animal{} class Dog extends Animal{} class Poli{ public static void main(String agrs[]){ List<Animal> l = new ArrayList<Animal>(); l.add(new Animal()); }} //isso compila ja que os tipos sao iguais o compilador aceita apenas //ANIMAL nada alm so animal. Aproveitando e analisando os cdigos abaixo perceba as diferenas e pq compila: import java.util.*; class Canguru{} class Zebra extends Canguru{} class Cobra extends Zebra{} class Zoo{ public void Zebr(List<Zebra>z){ System.out.println(z); } public static void main(String [] agrs){ Zoo z = new Zoo(); ArrayList<Zebra> list = new ArrayList<Zebra>(); list.add(new Zebra()); list.add(new Cobra()); //list.add(new Canguru()); isso aqui nao compila z.Zebr(list); }} /*roda tranquilo, observe que meus tipos do conjuntos sao iguais entao eu posso passar qualquer objetos para minha lista, ja que em tempo de execucao a jvm nao tem saber, os tipos de conjuntos, e o compilador ele apenas analisa se temos conjuntos equivalente*/ /* a linha de add Canguru nao compila pq Canguru nao extends uma Zebra entao Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA nao posso adicionar minha lista - CUIDADO aqui eh nao tentar fazer o teste -UM no tipo.. mais para adicionar eh permitido.*/ import java.util.ArrayList; import java.util.List; class Animal{} class Dog extends Animal{} class Poli{ public void cha(ArrayList<Animal> a){ System.out.println(a); } public static void main(String agrs[]){ Poli p = new Poli(); ArrayList<Animal> la = new ArrayList<Animal>(); l.add(new Animal()); l.add(new Dog()); p.cha(la); }}
145
A principal questo que permitido colocar um tipo dog dentro de um tipo animal eh que no array existe uma exceo em tempo de execuo ArrayStoreException que impede de colocar um tipo errado dentro do array por exemplo um carro dentro de animal. E em genricos no permitido, como j falei que seus tipos so apagados aps a compilao, em tempo de executacao ELES NO EXISTEM, ento no tem como lanar nenhum TIPO de exceo para algo que no tem TIPO. Em outras palavras em tempo de execuo a JVM sabe o TIPO de um array mais no sabe o TIPO do conjunto. Se voc lembrar, porque o java 5 teve que manter a sintaxe do pr-java seno os cdigos genricos deveria ser alterado se fosse executado no java 5, e isso no pode acontecer, o que j existe em verso pr deve funcionar na nova verso. public void Zebr(List<Zebra>z){} o importante na sintaxe acima que passe para esse argumento um tipo Zebra so isso que importa se vou adicionar um z.add(new Dog()); no importa para a JVM nem compilador j que ele verifica o tipo do conjunto. Lembrando que tem q ser um subtipo de Zebra seno no compila. import java.util.*; class Leao{} class Topera extends Leao{} class Selva{ public void cham(ArrayList<Leao> le){} public static void main(String [] agrs){ Selva s = new Selva(); List list = new ArrayList<Topera>(); list.add(new Topera()); s.cham(list); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA }} /*observe que ele nao compila meu metodo cham so aceita leao nenhum outro animal apenas leao*/
146
import java.util.*; class Cat{} class Dog{} class Coring{ public static void main(String args[]){
//Validas
ArrayList<?> list = new ArrayList();
ArrayList<? extends Object> ll = new ArrayList<Object>(); ArrayList<?super Integer> it = new ArrayList<Number>(); ArrayList<?> qq = new ArrayList<Double>();
//invalidas
ArrayList lis =new ArrayList<? extends Object>(); //nao posso usar no objeto, o mesmo deve ter um tipo declarado ArrayList<? extends Object> ob = new ArrayList<Object>(); ob.add(new Object()); // nao posso adicionar nada ao meu conjunto ArrayList<?super Dog> d = new ArrayList<Cat>(); //cat nao eh super de dog } }
..
import java.util.List; import java.util.ArrayList; class MetodoList{ public static void main(String args[]){ List lista = new ArrayList<Integer>(); lista.add(8); metod(lista); } static void metod(ArrayList a){ System.out.println(a); } } /* observe que meu metodo so aceita tipo ArrayList ou abaixo dele e to passando um tipo List isso nao compila devido a isso*/
CORINGA<?>
Certificao JAVA
147
O uso do coringa permite, receber qualquer tipo, usando com extends permite receber qualquer class que eh subtipo daquela class ou uma interface que implementa aquela classe. Mas voc no pode adicionar nada ao conjunto. Veja o que no compila: import java.util.*; class Carta{} class Coringa extends Carta{} class Jogo{ public void cha(List<? extends Carta> car){ car.add(new Carta()); } public static void main(String [] agrs){ Jogo j = new Jogo(); List<Carta> list = new ArrayList<Carta>(); list.add(new Carta()); j.cha(list); } } /*no compila porque usei < ? >(interrogao) quando uso, digo ao compilador que pode receber um conjunto de qualquer subtipo, porm JAMAIS adicion-lo ao conjunto, nem que seja do mesmo tipo.*/ O cdigo abaixo compila normal: import java.util.*; class Carta{} class Coringa extends Carta{} class Jogo{ public void cha(List<? extends Carta> car){ } public static void main(String [] agrs){ Jogo j = new Jogo(); List<Carta> list = new ArrayList<Carta>(); list.add(new Carta()); j.cha(list); }} /* observe que nao foi adicionado nada a minha lista*/ olhe a essncia da coisa tenho uma lista<azul> o qual adicionei ao mtodo Cor que pode receber qualquer coisa q estenda a ela mais nao pode adicionar. import java.util.*; class Cor{} class Azul extends Cor{} class NoCoring{ public void cham(List<? extends Cor> cor){ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //cor.add(new Azul()); } public static void main(String agrs[]){ NoCoring nc = new NoCoring(); List<Azul> li = new ArrayList<Azul>(); nc.cham(li); }}
148
Dicas: No h sintaxe <? Implements Serializable> isso no existe mais isso sim <? extends Serializable>
<? super tipo>

Como temos o extends temos tambm uma palavra chave super para a notao <?> o qual permite que voc adicionar ao conjunto apenas o que est acima daquele tipo. import java.util.*; class Carnaval{} class Banda extends Carnaval{} class Bloco extends Banda{} class Chi{ public void carna(List<? super Banda> band){ band.add(new Banda()); band.add(new Bloco()); } public static void main(String [] agr){ Chi ch = new Chi(); List<Carnaval> lis = new ArrayList<Carnaval>(); ch.carna(lis); }} /* observe que meu metodo aceita qualquer tipo acima de Banda, porem nao posso adiciona Carnaval, pq ele nao extends a Banda*/ /* o ponto a observar aqui eh que meu metodo aceitou via arg o tipo diferente do seu arg*/ <?> - permite receber qualquer tipo dog, cat, qualquer um. import java.util.*; class QuaCor{ public void ch(List<?> li){} public static void main(String agr[]){ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA QuaCor qc = new QuaCor(); List<Integer> li = new ArrayList<Integer>(); List<QuaCor> list = new ArrayList<QuaCor>(); qc.ch(li); qc.ch(list); }} /* observe que meu metodo recebe qualquer tipo de lista sem restricoes porem nao posso adicionar nada ao conjunto*/
149
import java.util.*; public class TestWild{ public static void main(String [] agrs){ List<Integer> li = new ArrayList<Integer>(); Bar b = new Bar(); b.doinsert(li); }} class Bar{ void doinsert(List<?> list){ list.add(new Dog()); }} /* esse codigo nao compila pq to tentado add algo que tem a notacao <?> sem super*/ Onde no posso usar coringas: Na criao dos objetos List<?> f = new ArrayList<? extends animal>(); Usar coringas apenas: Argumentos variveis e tipos de retornos. List<?extends Animal> li = new ArrayList<Dog>(); ArrayList<?> list = new ArrayList();
ArrayList<?extends Girafa> g = new ArrayList<Gir>(); //nao posso add nada aqui g.add(new Gir()); no compila
<Object>(aceita apenas Object) eh diferente de <?>(aceita qualquer trosso). quando voc usa <?> pode receber qualquer tipo mais quando usa Object pode receber apenas Object se usar <? extends Object> pode ser qualquer tipo: Dog, Cat, Integer. Porem sem adicionar ao conjunto. import java.util.*; class Objec{ public void aa(List<? extends Object> ob){} public static void main(String agrs[]){ Objec p = new Objec(); List<Integer> a = new ArrayList<Integer>(); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA List<Double> d = new ArrayList<Double>(); p.aa(a); p.aa(d); }}
150
...........................
import java.util.*; class Qualquer{ static void met(List l){ l.add(10); l.add(new Double(20.0)); System.out.println(l); } public static void main(String [] ar){ ArrayList<Integer> l = new ArrayList<Integer>(); l.add(8); met(l); }} /* ele aceita devido o argumento do metodo aceitar qualquer coisa aqui a protecao vai para o saco*/ //exemplo do inverso class Nocompi{ static void nocomp(ArrayList<Integer>A){ //A.add(new Double(7.0)); - aqui nao compila devido colocar coisa errada no conjunto } public static void main(String args[]){ ArrayList<Integer> rr = new ArrayList<Integer>(); rr.add(49); nocomp(rr); } }
............................
import java.util.*; class Qbjt{ //eu aceito qualquer coisa o mesmo que ArrayList lista public static void ch(ArrayList<?> al){ System.out.println(al); } public static void main(String args[]){ ArrayList<Integer> aa = new ArrayList<Integer>(); aa.add(10); ArrayList<Double> ad = new ArrayList<Double>(); ad.add(2.0); ch(aa); ch(ad); }}
Certificao JAVA
151
.................................................
import java.util.*; class DecVal{ public static void main(String arg[]){ List<?> lista = new ArrayList<Integer>(); //lista.add(9); - isso nao compila devido nao poder adicionar //nada aqui, ja q posso adicionar coisa errada System.out.println(lista); }}
class Girafa{} class Gir extends Girafa{ public static void main(String args[]){ //observe que mudei o tipo generico ja que posso receber //qualquer coisa q extends a Girafa porem nao posso //adicionar ao conjunto ArrayList<?extends Girafa> g = new ArrayList<Gir>(); //nao posso add nada aqui }} . class SuperG{ public static void main(String ar[]){ //digo que meu tipo pode ser Gir ou Girafa ou Object ArrayList<?super Gir> gg = new ArrayList<Girafa>(); ArrayList<? super Gir>gg2 = new ArrayList<Object>(); gg.add(new Gir()); //entender isso aqui eh essencial // o que passei ali apenas o tipo do generico para q o //tipo de objeto pode receber.. //gg.add(new Girafa()); compila isso }}
Criando suas prprias classes genricas

ufa! Esse capitulo de genricos eh grande demais e o pior q tem questes a rodo, mais vamos la eh permitido criar sua prprias classes genricas. Veja : //criando minhas propria class generica import java.util.*; class MyGene<T>{ T one; MyGene(T a){ one=a;} public T my(){ return one;} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
152
public static void main(String ars[]){ MyGene<Integer> mg = new MyGene<Integer>(10); }} /*nao tem metodo add lembre-se que ele pertence a class ArrayList*/ no lugar do <T> poderia ser qualquer identificador valido, mais T signigica tipo.
Outro exemplo mais cabeludo. import java.util.*; class RentalGeneric<T>{ private List<T> rentapool; private int maxNum; //recebe um int e mais o tipo da minha class public RentalGeneric(int maxNum, List<T> rentapool){ this.maxNum=maxNum; this.rentapool=rentapool; } public T getRental(){ return rentapool.get(0); } public void returnRental(T returnthing){ rentapool.add(returnthing); } } class Car{} class TestRental{ public static void main(String[]agr){ Car c1 =new Car(); Car c2 = new Car(); //crio uma lista de Car - algo normal aqui List<Car> carlist = new ArrayList<Car>(); carlist.add(c1); //minha class generic vai ser de Car RentalGeneric<Car>carRent = new RentalGeneric<Car>(2,carlist); }} /*cuidado isso eh confuso ate agora estou ainda confuso c/ isso tem que praticar muito mesmo aff*/
criando mtodos genricos

Eh possvel criar meus prprios mtodos genricos. T tipo E elemento. import java.util.*; class MetGen{ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA public<T> void make(T t){ List<T> li = new ArrayList<T>(); li.add(t); System.out.println(li); } public static void main(String agrs[]){ List<Integer> la = new ArrayList(); la.add(10); MetGen g = new MetGen(); g.make(la); }}/*observe que meu metodo vai receber um tipo que for especificado quando invocado ele nao possui nenhuma tipo de conjunto*/
153
<T> antes do void define que vc use como tipo no argumento. Eh obrigatrio colocar se voc no definir <T> na class. Veja o mesmo exemplo de forma diferente: import java.util.*; class MetGen<T>{ public void make(T t){ List<T> li = new ArrayList<T>(); li.add(t); System.out.println(li); } public static void main(String agrs[]){ List<Integer> la = new ArrayList(); la.add(10); MetGen g = new MetGen(); g.make(la); }} VALIDO: Class X{public <X> X(X x){} o compilador consegue fazer um parsing disso e trata cada X de forma independente e concerteza no exame vai ter algo disso e no posso perder uma questo dessa por minha falta de ateno hehe. NO CORRETO: no funciona para criao de classes genricas. <? extends Number> o uso do coringa a interrogao NO funciona como identificador valido para declaraes de classes genricas. public class N<?>{ ? A; } // invalido
import java.util.*; class LimiGe<T extends Number>{ public <T> void cham(T list){ System.out.println(list); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA } public static void main(String agr[]){ ArrayList<Integer> li = new ArrayList<Integer>(); li.add(7); LimiGe ge = new LimiGe(); ge.cham(li); }} /* limito, dizendo que so pode receber o pertencer a class Number ou extends a Number*/
class Genr{ public <T> void adiciona(T z){ T a=z; System.out.println(a); } public static void main(String ar[]){ Genr g = new Genr(); g.adiciona(10); g.adiciona(new Genr()); } } //se to usando T no argumento devo especificar antes do tipo de retorno do mtodo j que minha class no tem T.e se tiver um modificador deve vim depois. //outro exemplo class Mac{} class Rede extends Mac{} class Ip{} class Serve<T extends Mac>{ public static void main(String args[]){ Serve<Rede> s = new Serve<Rede>(); Serve<Mac> m = new Serve<Mac>(); //Serve<Ip> m = new Serve<Ip>(); isso nao compila //ip nao extends a Mac hehe } } . public class Entid<T>{ T num; Entid(T n){ num=n; } T getNum(){ return num;} public static void main(String [] ar){ Entid<Integer> e = new Entid<Integer>(50); Entid<Double> d = new Entid<Double>(80.0); System.out.println(e.getNum());//tipo Integer System.out.println(d.getNum());//tipo Double } }
154
CAPITULO 8 CLASSES INTERNAS Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
155
So classes dentro da outra. Uma classe aninhada(static) no uma classe interna. um dos benefcios da classe interna o relacionamento especial, que a instancia da classe interna compartilha com a classe externa. A classe interna ela tem acesso a membros da classe externa mesmo aqueles marcados como private. A classe interna uma parte da classe externa. A definao da classe interna dentro das chaves da externa. class ext{ class int{} } Quando compilado voc no tem acesso ao cdigo da classe interna. Para acessar uma classe interna preciso ter uma instancia da classe externa. O uso excessivo de classe internas pode gerar um labirinto em um milharal, gerando a sndrome conhecida impossvel de ser reutilizado. Para criar uma instancia da classe interna preciso associar ela com minha class externa. No pode criar uma instancia individual de uma classe interna. Interna ob = new Interna(); // invalido Na verdade, a classe externa que cria instancia da classe interna. class MyThi{ private int x = 7; private int y=10; //crio uma instancia da class interna dentro do metodo /*public void makeInter(){ MyInt in = new MyInt(); in.setExt(); }*/ //minha class interna class MyInt{ public void setExt(){ System.out.println("Externa valor " + x); System.out.println("interna class ref is " + this); System.out.println("Externa class ref is " +MyThi.this.y); } } public static void main(String args[]){ //MyExter me = new MyExter(); //crio uma instancia da class interna devo colocar o nome //da class externa em seguidna a minha interna MyThi.MyInt inn = new MyThi().new MyInt(); inn.setExt(); }} /*o valor na tela eh 7*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA /*aqui tenho duas opcoes posso criar instancia dentro do metodo makeInter() ou dentro do meu main()*/
156
Para criar uma instancia como acima, precisa est dentro do mtodo, ou no prprio main() conforme no cdigo acima, passando primeiro a class externa seguida da interna. No posso criar instancias a partir de mtodos estticos da classe externa porque os mtodos estticos no possui referencia a this. This passa a referencia de quem o chamou, no pode ser usado com cdigos estticos. Referenciar a uma classe externa usando this, dentro da interna basta usar o nome myclass.this. Posso definir minha class interna dentro de um mtodo. Declarar uma classe no o mesmo que instancia ela. Quando criar uma class interna dentro de um mtodo, para acessar os membros dessa classe necessrio instanciar ela dentro de mtodo. Class Ext{ void a(){ class int{} int ob = new int(); } } uma classe interna local do metodo, s pode ser instanciada dentro do mtodo onde foi definida. No possvel uma classe interna local de uma mtodo acessar suas variveis a partir de uma classe externa. Se uma varivel for marcada como final poder ser usada por uma class interna local do mtodo. A classe interna local de mtodo os modificadores, public, private, protected, static, transient, no pode ser usado, somente abstrat ou final para class interna local do mtodo. Uma classe interna local declarada dentro de um mtodo esttico ter acesso apenas a mtodos estticos da class externa e nenhuma referencia a this pode ser feita. A class EXTERNA no tem acesso ao membros da class INTERNA, mais o inverso permitido j que que a class interna -UM membro da externa. /* as classes abaixo, a classe externa nao reconhece os membros da class interna veja*/ class Honda{ private int ano=2006; class Moto{ private int modelo=2007; void cor(){System.out.println("azul");} } public static void main(String agr[]){ Honda h = new Honda(); System.out.println(h.modelo); h.cor(); }} /* aqui o codigo nao compila*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA class Carro{ private double motor = 2.0; class Vecta{ private int ano=2005; public void mt(){ System.out.println(motor); } } public static void main(String agrs[]){ Carro.Vecta cv = new Carro().new Vecta(); cv.mt();}}/* observe que tudo funciona normal....*/
157
Certificao JAVA class MetVAr{ private String x = "exter"; void doSt(){ final String z = "local metodo";// linha 4 class IntMet{ void see(){ System.out.println(x); System.out.println(z); } } IntMet im = new IntMet(); im.see(); }//fim do metodo public static void main(String agr[]){ MetVAr mv = new MetVAr(); mv.doSt(); } } /* classes interna de um metodo nao tem acesso a variaveis locais do metodo ja que apos o metodo ele eh excluido, para usar deve ter final*/ /* se remover final da linha 4 o codigo nao compila*/ class Pai{ static String p = "pai"; static class filho{ public static void pa(){ System.out.println(p);} } public static void main(String agrs[]){ //Pai.filho pf = new Pai().new filho();//no compila. filho.pa(); } } /*observe que class static internas segue a mesma regra de class normal, membro static so podem ser acessado por membros static e nao tem nenhuma instancia(objeto da class) o acesso eh direto*/ class StaExt{ static int z = 10; int z2; static class StaInt{ static int a = z; } public static void main(String agrs[]){ System.out.println(StaInt.a); }} /* observe que o acesso eh direto a variaveis static*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
158
Certificao JAVA /* lembre que nao posso definir uma variavel de instancia com o mesmo nome e tipo da static ex.: int z. Isso nao compila o fato de ser static, muda em termo da declaracao ja o que eh analisado o tipo e o identificado*/ Classes internas annimas
159
So classes internas declaradas porem sem nomes. Elas pode estar em: Wrappers, coleta de lixo, subscrio. class PopCorn{ public void pop(){ System.out.println("popcorn"); } } class Food{ PopCorn p = new PopCorn(){ /* aqui que cria uma class sem nome - anonima*/ //mtodo da class annima public void sizzle(){ System.out.println("sizzle"); } //outro metodo da class PopCorn foi subscrito pela class anonima public void pop(){ System.out.println("nova popcorn"); } };//fim da class anonima //metodo da class public void popit(){ p.pop(); //p.sizzle(); } public static void main(String args[]){ Food a = new Food(); a.popit(); } } /*o compilador reclama em nao reconhecer o metodo sizzle, observe que ele nao existe na superclass, entao uma class anonima deve subescrever ou implementar os metodos da super*/ Se for analisar, a variavel de instancia p mudou o formato de : pop p = new pop(); para pop p = new pop(){}; o que acontece : tenho uma variavel de referencia p, do tipo pop e em seguida uma classe que nao tem nome mais uma subclasse de pop, ou seja, ela annima. O fechamento da chave e o ponto e virgula finaliza a instruo da classe annima e assim tenho uma nova classe idigente, podemos chamar assim ne?. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
160
bom lembrar que tem p como referencia a uma super classe que usa objetos da subclasses um exemplo: Animal h = horse(); A vantagem do citado acima que possos chamar mtodos da classe interna annima que foi definifido com o tipo da varivel de referencia. No posso chamar um novo mtodo que no tinha na classe super. class PoliAno{ public void pop(){ System.out.println("popcorn"); } } class PopTest{ //class anonima PoliAno pa = new PoliAno(){ //metodo da class annima no existe na super public void sizz(){ System.out.println("class anonima"); } //metodo da clas PoliAno porem subscrito public void pop(){ System.out.println("subcrito anonimo");} }; void goIt(){ pa.pop();//chamo o metodo da class PoliAno pa.sizz();//observe que nao tem esse metodo na class PoliAno e sim na anonima } public static void main(String agr[]){ PopTest pt = new PopTest(); pt.goIt(); } } /* o compilador reclama na linha 19 pq a super class nao possui esse metodo e nao podemos referenciar aquilo que a super nao conhece, ja que esse metodo pertence apenas a uma class anonima que ninguem sabe qual eh o nome dela*/ /* esse codigo nao compila, se colocar a linha 19 em // ele roda normal*/
Certificao JAVA class Exter{ private int x =9; class Inter{ System.out.println(x); } void stack(){ //class interna do metodo so abstract e final class Meta{ System.out.println("class interna metodo" + x); } Meta m = new Meta(); } public static void main(String args[]){ Exter et = new Exter(); Exter.Inter ei = et.new Inter(); //Exter.Inter ex = new Exter().new Inter(); } } /*isso nao compila System.out.println() deve estar dentro de um metodo por ser uma instrucao*/
161
Interface especiliazado
Para iniciar lembre-se uma interface no pode ser instanciada. Face f = new Face(); // invalido para interface pois elas so implementadas.e no possui construtores. Quando se faz isso, voc usa uma classe annima que vai implementar sua interface. Annimos interface so pode implementar uma interface no existe nenhum mecanismo que a classe interna annima implemente mais interface. Uma classe interna precisa ter uma definio se ir ser uma subclasse nomeada e ir implementar interface ou se implementar uma nica interface. Classes internas annimas com argumento. As classes locais do mtodo com args(argumentos) tem }); E a classe interna simples tem }; interface Cook{ public void coo(); } class FaceAno{ //class anonima que implementa a interface static Cook c = new Cook(){ public void coo(){ System.out.println("interface anonima implementada"); } }; public static void main(String agrs[]){ c.coo(); }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA /*observe que coloquei minha variavel de instancia da class anonima como static para que possa ser acessada diretamente de um metodo static*/ /*remocao do static teria que encapsular com uma instancia da class Face*/ interface Roda{ public void aro(); } class Cam{ Roda r = new Roda(){ public void aro(){System.out.println("aro 16 - anonimo ");} };//fim do meu implementador anonimo void inter(){ r.aro();} public static void main(String agr[]){ Cam c = new Cam(); c.inter(); } } /*exemplo bacana, muita regrinha q nao deve ser esquecida senao eh um abrao */ interface Gol{ void g(); } class Fut{ static Gol g1 = new Gol(){public void g(){System.out.println("gol");}}; public static void main(String agr[]){ g1.g(); } } ............................................ interface Zona{ void zoo();} class Fest{ void dz(Zona z){ z.zoo();} public static void main(String agrs[]){ Fest f = new Fest(); f.dz(new Zona(){public void zoo(){ System.out.println("Zona implementada ");} }); }} /*observe que eu passo minha interface para o argumento aonde eu implemento e em seguinda mostro ela implementada */ Material desenvolvido Camilo Lopes - Resumo de Estudo
162
Certificao JAVA interface cook{ public void seta(); } class ret{ public static void main(String args[]){ cook k = new cook(){ public void seta(){System.out.println("interface implementada anonimamente"); } }; k.seta(); } }
163
Classe estticas aninhadas

No existe uma classe static, os modificadores static, informa que a classe aninhada um membro esttico da classe externa. Isso significa que ela pode acessar qualquer outro membro statico da classe externa. Ela no uma classe interna. Static informa que a classe aninhada um membro esttico da classe externa. No possui acesso as variaveis e mtodos no estticos da classe externa. comum encontrar classes aninhadas estticas tentando se comportar como classes internas, ou seja, tentando acessar membros no estticos da classe externa. Na prxima pagina coloquei varios exemplos do que foi comentado acima. class BigStatic{ //classe statica aninhada static class Nest{ void go(){ System.out.println("hi"); } } //class externa class Broom{ //class statica aninhada static class b2{ void goB2(){ System.out.println("hi 2"); } }//fim da class aninhada public static void main(String args[]){ //crio uma instancia da class Nest //observe que eh diferente para static BigStatic.Nest ob = new BigStatic.Nest(); ob.go(); b2 b = new b2(); b.goB2(); } } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA exemplo 2 //minha interface se ligue aqui interface Cookale{ public void cook(); } class FaceFod{ //crio uma interface anonima que implementa a class Cookale c = new Cookale(){ public void cook(){ System.out.println("metodo da interface implementado com suecesso"); } }; //chamo o metodo da interface anonima public void p(){ c.cook(); } public static void main (String args[]){ FaceFod ob = new FaceFod(); ob.p(); } } exemplo 3 class Ex{ private int a = 5; private double z = 5.0; class In{ public void met(){ System.out.println("Double " + z); System.out.println("Int externa " + Ex.this.a); } } public static void main(String args[]){ Ex.In ob = new Ex().new In(); ob.met(); } } exemplo 4 class MInter2{ private String x = "efigenia"; //metodo pertecente a class externa void doStuf(){ String y = "camilo"; //class interna local do metodo class Inn2{ Material desenvolvido Camilo Lopes - Resumo de Estudo
164
Certificao JAVA public void see(){ System.out.println("Externna " + x); System.out.println("variavel local " + y); } }//fim da class interna local do metodo Inn2 in = new Inn2(); in.see(); }//fim do metodo externo public static void main(String args[]){ MInter2 im = new MInter2(); im.doStuf(); } }/* as variaveis locais de um metodo nao pode ser acessada por uma class interna local do metodo dar erro como essa acima*/ /*se marca como final pode*/ /* classe interna dentro de um metodo*/ class MyExt2{ private String x = "camilo"; void doStuf(){ //aqui minha class interna class MyInt2{ public void see(){ System.out.println("Externa " + x); }//fecha metodo interna }//fecha class interna //crio uma instancia da class interna MyInt2 int2 = new MyInt2(); int2.see(); }//fecha metodo externo public static void main(String args[]){ MyExt2 ext = new MyExt2(); ext.doStuf(); } }//fecha class externa /*observe que na linha 12 nao precisei especifica a class externa pq to instanciando dentro de um metodo da class externa */
165
Certificao JAVA CAPITULO 9 THREAD
166
O grande polemico Thread, bom espero ter compreendido legal esse assunto pois no inicio tudo maravilha, porreta quando comea as sincronizaes.. mo na massa agora.. apenas um objeto em java, como qualquer outro que tem mtodos e variveis. Se no criar nenhum threads ele esta sendo executado em segundo plano. Jvms diferentes pode executar threads de maneira distintas. A ao comea no mtodo run(); Para thread posso dar o seguinte exemplo: desejo fazer um download de arquivos em segundo plano, enquanto estiver fazendo outro coisa no programa. Por exemplo: imprimindo, ento eu quero que o trabalho seja executado no seu prprio thread sem interferir em outras execues. O trabalho a comear com run(). Para criar uma instancia de um Thread tem duas maneiras: estender da class Thread ou implementar a interface Runnable. Usar a primeira opo quando tem uma verso especializada da classe Thread. A segunda deixa a classe livre a estender outra classe.(j que se trata de uma interface). Usando a classe Thread devo subscrever o mtodo run(). Quando estendo a Thread no posso estender a mais nada.(so para lembrar em Java no posso extends a duas classes). possvel sobrecarregar o mtodo run(), porem ignorada pela class Thread, ou seja, ele no chamado pela classe Thread, eu devo chama-lo e ainda assim ocorre na pilha atual e no separada como se fosse um novo thread. Todo thread de execuo precisa de uma instancia da classe Thread independente se for uma subclasse ou implementar runnable(). class MyThread extends Thread{ //implementei meu metodo thread public void run(){ System.out.println("usando extends da class Thread"); }} class MyTPri{ public static void main(String args[]){ //crie uma instancia da class Thread MyThread t =new MyThread(); //coloquei meu thread em estado de execucao t.start(); }} /*um thread so se torna inativo qdo run para de executar*/ ........................................................... class FooRun implements Runnable{ public void run(){ for(int x=1;x<6;x++){ System.out.println("Runnable running"); } }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA class FooTest{ public static void main(String agrs[]){ FooRun fr = new FooRun();//instancia uma class normal Thread t = new Thread(fr);//informei o destino do thread a executar t.start(); }} ................. class LocaT implements Runnable{ public void run(){ System.out.println("my thread"); }} class LocaTes{ public static void main(String agrs[]){ Thread t = new Thread(); t.start(); }} /*observe que meu Thread nao foi executando ja que nao passei o destino, ento eh executado o thread atual da class Thread*/ /* o fato principal de lembrar que o metodo run() de Thread eh subscrito quando informo o destino a ser executado*/ //um exemplo contrario desse class DestT implements Runnable{ public void run(){ System.out.println("executou destino "); } } class DestTest{ public static void main(String [] agr){ DestT d = new DestT(); Thread tt = new Thread(d); tt.start(); } } class Th extends Thread{ public void run(){ System.out.println("rodou"); } public static void main(String []aa){ Th t = new Th(); t.start(); } } Material desenvolvido Camilo Lopes - Resumo de Estudo
167
Certificao JAVA
168
/*th extends Thread entao th est subscrevendo o metodo run() de Thread(que foi herdado da interface Runnable)por isso que a instancia da class executa normal ja que extends*/ //CUIDADO! com o uso de RUNNABLE em codigos complexos confudi Ao implementar Runnable, quando inserir um Thread e uma tarefa, tenho que dividir em duas classes. A classe com o cdigo espefico do Thread e a classe de implementao onde ser executada o cdigo da terefa. Thread trabalhar(eu) ; Runnable trabalho(minha funo); 1 - crio uma instancia do trabalho runnable. 2 - crio a instancia do trabalhador Thread e a sua tarefa a executar no args. Se no passar nada no args ele chamara o seu prprio run(). No posso passar varias tarefas para um objeto thread apenas uma. Porem posso passar a mesma tarefa para vrios objetos threads multitarefas. MultiThreads. class Vname implements Runnable{ void run(){ System.out.println(Thread.currentThread().getName()); }} class VnameTest{ public static void main(String args[]){ Vname vm = new Vname(); Thread t = new Thread(vm); t.setName("Lopes"); t.start(); }} /*esse codigo nao compila observe que mudei o nivel de acesso do metodo run() isso nao eh permitido a nao ser que seja uma sobrecarga mais ai nao teriamos Thread*/ . class Multi implements Runnable{ public void run(){ for(int x=1;x<7;x++){ System.out.println("run by " + Thread.currentThread().getName()+ ", x is " + x); }}} class MultiT{ public static void main(String args[]){ Multi m = new Multi(); //olha o ponto crucial minha instancia de Thread Thread ob1 = new Thread(m); //olha multi-tarefas varios objetos fazendo uma tarefa ob1.setName("camilo"); Thread ob2 = new Thread(m); ob2.setName("efigenia"); ob1.start(); ob2.start(); }}/*observe a inseguraa se alterar o loop para um valor alto como 100*/ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
169
Um threads so iniciado quando chama o mtodo start(), enquanto isso ele est desativado. Lembre-se um thread funciona quando cria uma nova(new) pilha de chamadas. t-minusculo refere-se a threads em execuo e no a class Thread. Estado novo quando tenho apenas a instancia do thread e ele no esta ativo, o mtodo start no rodou ainda. Quando em thread executado o mtodo run() de destino vai ser processado. start() - chama uma classe thread e no RUNNABLE. Obter o nome da thread getName(). Thread.currentThread retorna a referencia que estiver sendo executado. Se no der um nome explicitamente a sua thread, mesmo assim ter um nome . O comportamento de uma thread no garantido. No existe ordem de execuo na forma como instanciou. No h garantias de que uma vez que thread comeou a execuo ela termine. A ordem com os threads executa quem controla o agendador. Lembre-se que a ordem de instaciacao no garantida na execuo, e a durao tambm. Quando o mtodo run(), for concludo o thread deixa de ser threads.(Eu vejo threads mortos). O thread inativo != de eliminado, so no um thread de execuo. Thread inativo se tornou j era, no pode ser reiniciado, no posso chamar start() novamente. Se chamar uma exceo ocorrer. O agendador uma parte da jvm que decide qual thread deve ser executado no momento, mudar o estado do thread etc... esse cara que dita as coisas. Alguns exemplo que fiz com threads. class FooRunable implements Runnable{ public void run(){ for(int x=1; x < 6;x++){ System.out.println("runable run"); } }} class TestThread { public static void main(String args[]){ FooRunable r = new FooRunable(); Thread t = new Thread(r); t.start(); }} exemplo 2 class NameRun implements Runnable{ public void run(){ System.out.println("name run"); System.out.println("Run by " + Thread.currentThread().getName()); } } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA class NameT{ public static void main(String args[]){ NameRun r = new NameRun(); Thread t = new Thread(r); t.setName("meu thread"); t.start(); }} ............................... class NameMain{ public static void main(String [] arg){ System.out.println(Thread.currentThread().getName()); } } /*observe que obtive o nome do metodo thread atual*/ // o metodo Thread.currentThread() ele obtem a referencia do thread em //execucao
170
Estados e transies de threads

Um thread pode ficar em cinco estados: NOVO quando tenho apenas a instancia de thread, mas o mtodo start() nem sonha em ser executado. Aqui ele um objeto ativo mas no um thread em execuo. EXECUTVEL aqui quando chamo o start(), ele passa do estado inativo para ativo, porem o agendador ainda no disse como o thread vai ser processado, mas ele fala j to pronto meu filho. EXECUO esse o principal, aqui o agendador(o chefe) seleciona o processo que vai ser executado, ou seja, a minha tarefa no trabalho. o thread pode sair deste estado se o agendador decidir. ESPERA/BLOQUEIO/SUSPENSO thread no informa ao outro, quem deve ficar bloqueado/espera/suspenso enquanto executado. Os mtodos estticos da class threads no afeta a instancia e sim afeta a thread que est sendo executado. INATIVO quando run() conclui j era, o thread no pode mais executar porem ainda um objeto thread, no posso chamar start(), seno lana uma exeo em tempo de execuo. Lembre-se run() executado aps o start().(se o agendador quiser)
Metodo Estatico (static) - Thread

SUSPENSO (Thread.sleep()) thread suspenso, vai para algum local e no retorna ao estado executavel ate que seja despertado. Vou usar a suspenso no thread, quando achar que o thread est percorrendo seu cdigo muito rapidamente. Forar meu thread dar oportunidade a outro thread. Sleep() mtodo esttico responsvel pela suspenso. (pode lanar uma exceo usar try{} e catch{}. - InterrupedException A suspenso entra no mtodo run() ou qualquer local.
Certificao JAVA
171
class Name implements Runnable { public void run(){ for(int x= 1; x <4; x++){ System.out.println("Run by " + Thread.currentThread().getName()); } //metodo de suspensao sleep() try{ Thread.sleep(1000); }catch(InterruptedException ex){} }} class TestName{ public static void main(String args[]){ Name n = new Name(); Thread t = new Thread(n); t.setName("camilo"); Thread t1 = new Thread(n); t1.setName("efigenia"); t.start(); t1.start(); }} /* observe que tb nao garantido que ele vai ficar suspenso pelo tempo definido se colocar 50, o thread que est suspenso executa.*/ LEMBRE-SE no ter como certificar de quanto tempo a thread ser executado antes de entrar na suspenso. sleep() - tentar que todos threads tenha a chance de serem executados e que o thread no entre em execuo com outro thread tiver sendo executado. Quando ele encontrar a suspensao ele fica sem executar durante o tempo em milisegundos informado em args. class Susp implements Runnable{ public void run(){ for(int x=0;x<50;x++){ System.out.println(Thread.currentThread().getName()); try{ Thread.sleep(1000);//fique sem executar po 1segundo }catch(InterruptedException ex){} }} public static void main(String args[]){ Susp sp = new Susp(); Thread t = new Thread(sp); t.setName("Camilo"); Thread t1 = new Thread(sp); t1.setName("neto"); t.start(); t1.start(); }} /*observe que ele exibe camilo depois neto a cada 1000 milesegundos nada eh Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA garantido que a exibicao saia bonitinho, pois no pool do agendador pode ter dois threads ativos para ser executados ai ele que escolhe quem vai executar poderia sair ai neto camilo - camilo neto fica a criterio do famoso agendador*/
172
observe o mesmo cdigo porem o sleep() mtodo de suspenso em um local diferente. bom lembrar que sleep um mtodo esttico e posso colocar aonde desejar. E quando a execucao chegar nele o Thread atual suspenso e dar prioridade a outro Thread que est no pool do agendador. Esse exemplo abaixo fundamental, no whizlabs as questes de Thread ta cabeluda ele poe os mtodos em vrios locais diferentes e o cara deve se ligar e as vezes ele afirma o resultado e as vezes no. Isso mata o futuro programador Java 5( o que eu espero). class Susp implements Runnable{ public void run(){ for(int x=0;x<4;x++){ System.out.println(Thread.currentThread().getName()); } } public static void main(String args[]){ Susp sp = new Susp(); Thread t = new Thread(sp); t.setName("Camilo"); Thread t1 = new Thread(sp); t1.setName("neto"); t.start(); try{ Thread.sleep(1000); }catch(InterruptedException ex){} System.out.println(Thread.currentThread().getName()); t1.start(); }} ........................................................................
class MainTh extends Thread{ public void run(){ System.out.println(Thread.currentThread().getName()); } static public void main(String args[]){ try{ Thread.sleep(1000); }catch(InterruptedException e){} //executa o run da class thread nao exibe nada Thread t = new Thread(); t.start(); //executa o run da class MainTh MainTh mt = new MainTh(); mt.start(); } }
Certificao JAVA
173
Prioridade dos threads e o mtodo yield No se tem garantias de prioridades no comportamento correto. Os threads possui o conceito de prioridades normalmente entre 1 a 10. porem nem todos os jvm usa a mesma diviso de tempo. Uma coisa quando o thread entra no estado executvel(j foi dado o start()). tem prioridade igual ou maior, para aquele que est no estado de execuo. setPriority(),configuro a prioridade de um thread, de uma instancia Thread.(valor positivo 1 a 10). Tambm no so garantidas. class PrioT extends Thread{ public void run(){ System.out.println(Thread.currentThread().getName()); } public static void main(String args[]){ PrioT p = new PrioT(); PrioT p1 = new PrioT(); p.setPriority(2); p1.setPriority(MAX_PRIORITY); p.setName("neto"); p1.setName("lopes"); p.start(); p1.start(); }} /*observe que a thread com prioridade maxima eh executada e um ponto a observar que nao foi executado na ordem que foi escrito os start()*/ Mtodo yield() DAR OPORTUNIDADE DE PROCESSAMENTO A THREAD DE PRIORIDADE IGUAIS ele faz o seguinte pega o thread que est sendo executado(estado execucacao) e passa para o estado executvel, deixando assim outros threads com a mesma prioridade tenha sua oportunidade de processar. No h garantias para quem cedeu voltar a ser executado o Maximo tirar de execuo para executvel ou no fazer nenhum. Nada garantido. public class TesteThread extends Thread{ public TesteThread(String name){ super(name); } public void run(){ for (int cont = 0; cont < 10; cont++){ System.out.println(this.getName() + ": " + cont); Thread.yield(); //Sai do estado RUNNING e vai para o estado READY!! } } public static void main(String[] args){ //muita desta instanciacao no exame cuidado Thread t1 = new TesteThread("Thread A"); Thread t2 = new TesteThread("Thread B"); t1.start(); t2.start(); }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //observe q ele executa a t1 - A e depois t2 - B pois a prioridade sao as mesmas
174
.. class Priorit extends Thread{ public void run(){ System.out.println(Thread.currentThread().getName()); } public static void main(String a[]){ Priorit pr = new Priorit(); Priorit pr1 = new Priorit(); pr.setName("th"); pr1.setName("th2"); pr.setPriority(10); pr1.setPriority(1); pr.start(); pr1.start(); }} ................................................................ class Yield implements Runnable{ public static void main(String args[]){ Yield y = new Yield(); Thread t = new Thread(y); //se liga aqui t.setPriority(NORM_PRIORITY); } public void run(){ System.out.println(Thread.currentThread().getName()); } }/* esse codigo nao compila devido a class implements Runnable, entao ela n vai reconhecer a variavel constante da class Thread NORM_PRIORITY*/ // se mudar para Thread.NORM_PRIORITY o codigo compila normal
Excees
class Yield implements Runnable{ public static void main(String args[]){ Yield y = new Yield(); Thread t = new Thread(y); Thread t2 = new Thread(y); //se liga aqui t.setPriority(11); } /* ele compila porem uma exceo lanada devido o valor nao esta no intervalo de 1-10*/
Mtodo join() - no ESTTICO adiciona uma thread ao final de outro. Exemplo: B so executa depois de A concluir, ento melhor que B venha depois no acha? Entao B nao se tornara executvel nesse momento. Thread t = new Thread(); t.start(); t.join(); //adiciono o thread atual ao final do representado por join, quando ele terminar o principal volta a executar. MAS LEMBRE-SE nada garantido, tudo depende do agendador, veja isso como um verdadeiro estgio ao terminar ele voc no sabe se retorna a empresa, se vai sair, ou se vai para uma lista e dar o lugar a outro para esperar ele terminar o dele e ver se vai ti chamar. Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
175
class Joi implements Runnable{ public void run(){ System.out.println(Thread.currentThread().getName()); } public static void main(String args[]){ Joi j = new Joi(); Thread t = new Thread(j); Thread t1 = new Thread(j); t.setName("Camilo"); t1.setName("java"); t1.start(); try{ t1.join(); }catch(InterruptedException e){} t.start(); }} //observe que somente minha t1 executa enquanto as outras espera class Joinn extends Thread{ public void run(){ System.out.println(Thread.currentThread().getName()); } public static void main(String args[]){ Thread t = new Thread(new Joinn()); t.setName("T1"); Thread t2 = new Thread(new Joinn()); t2.setName("T2"); t2.setPriority(MAX_PRIORITY); t.start(); try{ t.join();//so eu executo, esperem eu terminar cambada }catch(InterruptedException e){} t2.start(); } }/* observe que mesmo t2 com prioridade maxima, ele so executado apos t concluir*/
public class JJ implements Runnable { public void run(){ for(int x=0;x<2;x++){ System.out.println("imprimindo "+ x + Thread.currentThread().getName()); } } public static void main(String[] args) { JJ j = new JJ(); Thread t = new Thread(j); t.setName("Diretor"); Thread t1 = new Thread(j); t1.setName("Socio");
Certificao JAVA
t1.setPriority(10); t.setPriority(1); t.start(); try{ t.join(); }catch(InterruptedException e){} t1.start(); } } /* observe que mesmo Socio tendo uma prioridade alta * nao eh GARANTIDO que ele execute primeiro que o * diretor que tem uma prioridade menor*/
176
Mais exemplos: class Exe1 extends Thread{ public void run(){ for(int x=1; x<=100;x++){ if(x%10= =0){ System.out.println("x " +Thread.currentThread().getName()); //toma suspensao try{ Thread.sleep(1000L); } catch(InterruptedException a){} } }}} class Exe1Test{ public static void main(String args[]){ /*Exe1 e = new Exe1(); Thread t = new Thread(e); Thread t1 = new Thread(e);*/ // aqui implementando runnable Exe1 t = new Exe1(); Exe1 t1 = new Exe1(); t.setName("t"); t1.setName("t1 "); t.start(); t1.start(); }} /* o programa faz o seguinte a cada 10 numeros encontrado o resto for = = 0 a zero ele imprime o nome do thread e toma uma suspensao para o proximo thread*/ /* 10,20,30.. sao valores = = 0*/ exemplo 2 public class Pri extends Thread{ public void run(){ for(int x=1;x<30;x++) System.out.println("Vejo threads mortos" + Thread.currentThread().getName()); }} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA class PriTes{ public static void main(String args[]){ Pri p = new Pri(); Pri p1 = new Pri(); Pri p2 = new Pri(); p1.setPriority(10); p1.setName("prioridade 5"); p.start(); p1.start(); p2.start(); }} /* observe quem tem a prioridade entre a escala 1 - 10 eh executado primeiro mais isso nao eh garantido colocar um valor fora de 1 -10 eh lancada uma exceo mas o cdigo compila vale lembrar*/ class PrioT extends Thread{ public void run(){ System.out.println(Thread.currentThread().getName()); } public static void main(String args[]){ PrioT p = new PrioT(); PrioT p1 = new PrioT(); p.setPriority(2); p1.setPriority(MAX_PRIORITY); p.setName("neto"); p1.setName("lopes"); p.start(); p1.start(); }} /*observe que a thread com prioridade maxima eh executada e um ponto a observar que nao foi executado na ordem que foi escrito os start()*/
177
Sicronizado threads
Ajuda quando temos dois threads diferentes acessando a mesma instancia, ou seja, dois threads com o mesmo destino ( tarefa a executar).Pense como duas pessoas manipulando um caixa financeiro. Se no tiver sincronia entre as pessoas, ao fechar o caixa o valor no pode ser exato. Isso implica que uma thread muda o estado da instancia em um momento que a outras thread tinha um estado anterior, daquela instancia, isso pode gerar a no garantia do estado do objeto quando esta sendo visualizado. Operao atmica quando a operao vai ser concluda antes que a outro thread atue sobre aquelas instancia, mesmo se tiver suspenso- sleep(). Preciso modificar o controle de acesso do mtodo para que apenas uma thread possa executar por vez so basta usar o synchronized. Quando usamos garantimos que quando uma thread tiver usando o mtodo a outra thread no pode acessar o mtodo ate que thread atual concluir.(Desde que as duas threads tenha o mesmo destino). Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
178
Quando bloqueamos um objeto, nenhum thread poder usa-lo ate que o bloqueio seja liberado. Nenhuma thread pode entrar no codigo de sincronizao. Somente os mtodos podem ser sincronizado, as variveis NO. Cada objeto possui apenas 1 bloqueio. Se a classe tiver mtodos no SINCRONIZADOS vrios threads pode acessar o mtodo.(gerando o estado inconsistente do objeto). Um thread pode chamar mais de 1 bloqueio, ou seja, um thread ta acesando um mtodo sincronizado, posso imediatamente chamar outro mtodo sincronizado de um objeto diferente usando o bloqueio atual. Com a sincronizao afeta o desempenho, em mtodos grandes posso agrupar sincronizar a parte menor. Usando: synchronized(this){} dentro do mtodo. class StatiSyn extends Thread { public static void ff(){ //sincronizei o bloco do codigo synchronized(StatiSyn.class){ for(int x=0; x<2;x++){ System.out.println(Thread.currentThread().getName() + " " + x ); try{ Thread.sleep(500); }catch(InterruptedException e){} }}} public void run(){ ff(); } public static void main(String args[]){ StatiSyn s = new StatiSyn(); StatiSyn s2 = new StatiSyn(); s.start(); s2.start(); }}
class Bloco implements Runnable{ public void run(){ forca(); } public void forca(){ //isso nao ta sincronizado ambas thread pode acessa-lo System.out.println("no"); int y=10; //aqui eh bloqueada para outra thread espere isso terminar para vc //poder entrar nesse bloco synchronized(this){ for(int x=0;x<5;x++){ System.out.println(Thread.currentThread().getName() + " " + y); try{ Thread.sleep(5000); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA }catch(InterruptedException e){} y++; }} } public static void main(String args[]){ Bloco b = new Bloco(); Thread t = new Thread(b); Thread t2 = new Thread(b); t2.setPriority(1); t.setName("dog"); t2.setName("cat"); t.start(); t2.start(); }}
179
Mtodos static pode ser sincronizado(mais no pode ser serializado isso confunde). Uma class SEGURA quando ela foi sincronizada pra proteger os seus dados em relao aos threads. Um exemplo bacana visto com as classes StringBuffer e StringBuilder.A StringBuffer os mtodos so sincronizados por isso que ela mais lenta que a StringBuilder onde os mtodos no so sincronizados. Os impasse a threads acontece quando a thread A precisa da liberao da thread B e a thread D precisa da liberao da A e por via a Thread C precisa da liberao da D para executar. Ai temos um IMPASSE. Um impasse acontece quando dois threads fica impedidos de obter um bloqueio ou seja, nenhum deles ser executado ate que um abra-mao do bloqueio portanto ficara uma vida esperando. importante lembrar que se eu tiver um mtodo esttico acessando um campo nao esttico e sincronizar o mtodo, vou adquirir um bloqueio no objeto Class. O importante que um objeto no static e static nunca vai bloquear um ao outro, ele vo rodar ao mesmo tempo e vai realizar bloqueios diferentes. Ento campos static deve ser feito a partir de mtodos static synchronized E campos no static deve ser synchronized. public class Thing{ private static int staticFiled; private static int nostaticFiled; public static synchronized int getStaticFiled(){ return staticFiled; } //metodo static public static synchronized void setStatic(int stati){ Thing.staticFiled = stati; } public synchronized int getNo(){ return nostaticFiled; Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA } //metodo nao estatico public synchronized void setNo(int nt){ this.nostaticFiled = nt; }} ............................
180
class bloq extends Thread{ public void run(){ bloqq(); } public synchronized void bloqq(){ for(int i=0;i<3;i++){ System.out.println(Thread.currentThread().getName() + i); try{ Thread.sleep(1000); }catch(InterruptedException e){} }} public static void main(String args[]){ bloq b = new bloq();b.setName("JJ"); bloq b2 = new bloq();b2.setName("GG"); b.start(); b2.start(); } } /* ponto chave aqui: minhas duas threads possui destino diferentes entao o metodo synchronized eh executado de forma simultanea, usar synchronized valido qdo duas threads - duas pessoas tem acesso ao mesmo objeto*/ /* se por o mtodo bloqq() em static ele vai syncronizar a instancia da .class(da classe) que eh b ai o acesso ao metodo eh para cada thread de uma vez, ou seja no vai existir o acesso simultaneo*/
meus exemplos:
class Account{ private int balance = 50; public int getBalance(){ return balance; } public void saldo(int real){ balance = balance - real; }} class Cliente implements Runnable{ //objeto da classe que retorna o saldo private Account c = new Account(); public static void main(String args[]){ //crio dois threads Cliente cli = new Cliente(); Cliente cli2 = new Cliente(); Thread t1 = new Thread(cli); Thread t2 = new Thread(cli2); Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA t1.setName("camilo"); t2.setName("efigenia"); t1.start(); t2.start(); }//fim do main
181
//metodo run da thread public void run(){ for(int x=0; x<5;x++){ saldoAtual(10); if(c.getBalance() < 0){ System.out.println("conta sem dinheiro"); }}} //metodo que faz o debito do sac private synchronized void saldoAtual(int m){ if(c.getBalance() >= m){ System.out.println(Thread.currentThread().getName()+"verifica saldo R$ "+ c.getBalance()); try{ //suspenda a thread atual por 5 milesegundos Thread.sleep(500); }catch(InterruptedException ex){} //recebe o valor passado pelo objeto ativo c.saldo(m); System.out.println(Thread.currentThread().getName() + " saque completo" ); }else{ System.out.println("not in conta " + Thread.currentThread().getName() + " to saque " + c.getBalance()); }}} .. class Dados{ private static int saldo=200; public static void main(String args[]){ DadosP c1 = new DadosP(); Thread t = new Thread(c1); Thread t2 = new Thread(c1); t.setName("Gerente"); t2.setName("funcionario"); t.start(); t2.start(); }//fim do main //metodos que configura o saldo public static int getSaldo(){ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA return saldo; } public static void setSaldo(int s){ saldo +=s; } public static synchronized void setDeposita(int real){ if(getSaldo()< real){ System.out.println(Thread.currentThread().getName() + " deposito autorizado " + real); try{ Thread.sleep(500); }catch(InterruptedException e){} setSaldo(real);
182
System.out.println(Thread.currentThread().getName() + " valor depositado" ); }else{ System.out.println("voce ta tentando depositar menor que o valor em saldo " + Thread.currentThread().getName()); }}} //class que executa os threads class DadosP implements Runnable{ private Dados c = new Dados(); public void run(){ for(int x =1; x<3;x++){ c.setDeposita(300); } }} /*esse programa faz o seguinte o deposito nao pode ser menor que o valor em saldo: historia do programa: o gerente entao ele deposita no primeiro momento 300 o saldo vai para 500. ai ele suspenso e o funcionario diz vou depositar 300, mais o valor eh menor que o saldo atual.. ele recebe a mensagem e tenta novamente mais ai ele eh suspenso e o gerente conclui*/ /* importante observar que o thread que representa o funcionario ele so entra em ao qdo o thread do gerente libera o acesso para ele usar o metodo.. mesmo com uma suspensao o metodo nao liberado so apos a concluso*/ outros exemplos.... public class Conta implements Runnable{ double saldo=50; public void poup(double r){ saldo = saldo - r; System.out.println(Thread.currentThread().getName() + " saque realizado"); System.out.println("saldo " + saldo); } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA public double getSaldo(){ return saldo; } public void run(){ for(int x=0;x<3;x++){ result(); } } public synchronized void result(){ if(getSaldo() >0){ System.out.print(Thread.currentThread().getName() + " "); System.out.println("saldo na conta " + saldo); poup(10.0); try{
183
Thread.sleep(500); }catch(InterruptedException e){} } else{ System.out.println(Thread.currentThread().getName() + " conta sem saldo"); } } public static void main(String args[]){ Conta c = new Conta(); Thread camilo = new Thread(c); Thread efigenia = new Thread(c); camilo.setName("Camilo"); efigenia.setName("efigenia"); camilo.start(); efigenia.start(); }} /*o codigo a ser sincronizado eh o que manipula a conta ou seja que subtrai*/ /* importante observar aqui que para cada thread o for executa 3 vezes*/ esse aqui foi um exemplo que fiz bastante legal. public class Conta2 implements Runnable{ double saldo=50; public void poup(double r){ saldo = saldo - r; System.out.println(Thread.currentThread().getName() + " saque realizado"); System.out.println("saldo " + saldo); } public double getSaldo(){ return saldo; } Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA public void run(){ for(int x=0;x<3;x++){ result(); } } public synchronized void result(){ System.out.print(Thread.currentThread().getName() + " "); System.out.println("saldo na conta " + saldo); poup(10.0); try{ Thread.sleep(500); }catch(InterruptedException e){} }
184
public static void main(String args[]){ Conta2 c = new Conta2(); Thread camilo = new Thread(c); Thread efigenia = new Thread(c); camilo.setName("Camilo"); efigenia.setName("efigenia"); camilo.start(); efigenia.start(); }} /*observe que nesse codigo mesmo com o metodo sincronizado a efigenia realizou um saque e deixou a conta negativa mais pq? bom synchronized apenas permite que um thread trabalhe em cima de um objeto, e que o outro thread so vai trabalhar em cima dele quando o atual terminar o servico.. so ti empresto minha marreta quando terminar de quebrar as pedras blz?*/ /* nesse caso ai nao colocamos nada para garantir q ela nao pode realizar saque quando a conta tiver 0.0, entao ela ver q ta sem real e negativa a conta... so isso que acontece....*/ Esse exemplo abaixo levei 30 minutos para fazer.. o programa pequeno porem eficiente a questo de sincronizao de objetos mais valeu apena veja: class caixa implements Runnable{ double real=300.0; public synchronized void fluxo(double r){ if(real <= 2000.0){ System.out.println("valor no caixa para " + Thread.currentThread().getName()+ " de " + real); try{ Thread.sleep(500); }catch(InterruptedException e){} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA real +=r; System.out.println(Thread.currentThread().getName() + " depositou ");
185
}else{ System.out.println(Thread.currentThread().getName() + " caixa fechado"); } } public void run(){ for(int x=0;x<4;x++){ fluxo(300); //mtodo sincronizado eh chamado } System.out.println("total do caixa " +real); } public static void main(String args[]){ caixa c1 = new caixa(); Thread maria = new Thread(c1); Thread jose = new Thread(c1); maria.setName("maria"); jose.setName("jose"); maria.start(); jose.start(); }} /* aqui o caixa nao pode ter mais de 2000 reais .teste ele com synchronized e nonsynchronized e veja a diferena*/ /* non - synchronized nem maria nem jose tem o mesmo valor em mente do caixa e synchronized ambos sai do caixa com o mesmo valor em mente ja que um espera o outro depositar*/ /* * exibicao non-synchronized valor no caixa para maria de 300.0 valor no caixa para jose de 300.0 maria depositou + 300 valor no caixa para maria de 600.0 jose depositou + 300 valor no caixa para jose de 900.0 maria depositou + 300 valor no caixa para maria de 1200.0 jose depositou + 300 valor no caixa para jose de 1500.0 jose depositou + 300 valor no caixa para jose de 1800.0 maria depositou + 300 maria caixa fechado // ouxe como se tinha 1200 qdo olhei? total do caixa 2100.0 jose depositou total do caixa 2400.0 *** */ Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA //exibicao synchronized /* ** valor no caixa para maria de 300.0 maria depositou valor no caixa para jose de 600.0 jose depositou + 300 valor no caixa para maria de 900.0 maria depositou + 300 valor no caixa para jose de 1200.0 jose depositou + 300 valor no caixa para maria de 1500.0 maria depositou + 300 valor no caixa para jose de 1800.0 jose depositou + 300 maria caixa fechado total do caixa 2100.0 jose caixa fechado total do caixa 2100.0 ** */
186
interao com threads

Os mtodo wait() e notify() permite que 1 thread fique na espera de outro thread e o avise para ele executar. Os mtodos de interao deve ser chamado dentro de mtodos sincronizados. wait() faz o seguinte aguarde, a notificao para continuar o processo. notify() eu terminei seu processo Thread, ou seja, libera. Se o thread ou a instancia que chamar wait() no tiver sincronizada ocorrera uma exceo do tipo no verificada. O objetivo da sincronizaao para evitar que uma thread evite alterao do estado do objeto, enquanto uma est executando. Mtodo wait() ele aceita um tempo em milesegundos ou seja, ele libera o bloqueio e espera um notify pela outra thread ate aquele tempo. Depois disso ele continua sua execuo e bloquea novamente. o mesmo que dizer a impressa: imprima 100 paginas em 2 segundos seno eu ti bloqueio e voc no imprime mais nada. class ThreadA{ public static void main(String [] args){ ThreadB b = new ThreadB(); b.start(); //sicronizo o objeto e o bloco do codigo synchronized(b){ try{ System.out.println("waiting for b complete..."); //poe o thread atual para dormir ate ele receber //uma notifiacao para continuar o seu processo b.wait(); }catch(InterruptedException e){} Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA System.out.println("Total " + b.total); } }} class ThreadB extends Thread{ int total; public void run(){ synchronized(this){ for(int i=0;i<3;i++){ total+=i; } notify(); }}} Outro exemplo :
187
class Correio extends Thread{ static int cartas; public static void main(String args[]){ Correio c = new Correio(); c.start(); synchronized(c){ try{ System.out.println("Aguarde verificando o numero de cartas... "); c.wait(); }catch(InterruptedException e){e.printStackTrace();} System.out.println("total de cartas " + cartas); } } public void run(){ synchronized(this){ for(int i =0; i < 100; i ++){ cartas+=i; } notify(); } }}
notifyAll() Permite que todos os thread em espera retorne ao estado executvel. que um objeto pode ter vrios thread esperando apenas a liberao para executar e se usar uma notify() vamos apenas afetar uma deles. Um exemplo voc executar um calculo e voc tem l no pool varios threads esperando para receber o calculo e conclui-lo. Pode ter uma thread que vai pegar o valor e somar na sua conta corrente, outra thread que vai precisar do valor para fazer um debito na sua conta. Ento entrara o notifyAll() wait(), notify(), notifyAll() pertence a class Object. run() interface Runnable Thread static sleep(), yield() non-static start(), join()
Certificao JAVA class Reader extends Thread{ Calculator c; public Reader(Calculator calc){ c = calc; } public void run(){ synchronized(c){ try{ System.out.println("waiting for calculation.."); c.wait(); }catch(InterruptedException e){} } //esta aguardando a notificacao pra imprimir o resultado System.out.println("Total is " + c.total); } public static void main(String args[]){ //objeto da thread Calculator calculator = new Calculator(); //chama o run() q tem o mtodo wait(). new Reader(calculator).start(); new Reader(calculator).start(); new Reader(calculator).start(); //cham o run da class que tem o notify calculator.start(); }} class Calculator extends Thread{ int total; public void run(){ synchronized(this){ for(int i=0;i<100;i++){ total+=i; } //libera toda as tres thread em espera de Readrs notifyAll(); }}}
class WAit extends Thread{ public void run(){
188
} public static void main(String args[]){ WAit w = new WAit(); w.start(); try{ w.wait();}catch(Exception e){e.printStackTrace();} }} /* lana uma excecao IllegalMonitorStateException devido meu wait() nao ser executado em um contexto sinchronized*/
Certificao JAVA CAPITULO 10 DESENVOLVIMENTO
189
Compilando com d Usado quando se desejar colocar o arquivo .class em outro destino que nao seja o mesmo que o arquivo .java. usando em grandes projetos aonde o gerente do projeto diz que os arquivos .class do modulo de cadastro de cliente deve ficar no diretorio Zumbi. isso que o d faz. Propriedades do sistema No Java 5 possui uma class que pode fornecer os dados persistente do sistema como verso atual do compilador e suas prprias propriedades. Listando argumentos via linha de comando public static void main(String args[]) args pode receber qualquer nome e posso usar variaveis veja
public static void main(String args[]) public static void main(String lopes[]) public static void main(String...x) public class Cmd{ public static void main(String...y){ int x=0; for(String s : y) System.out.println(x++ + "elemento = " + s); } } /*x representa a posicao e s o elemento naquela posicao*/ //para executa java Cmd x 2 1 public class Cmd{ public static void main(String args[]){ int x=0; for(String s : args) System.out.println(x++ + "elemento = " + s); }}
usando java e javac

usando quando precisamos usar uma classe da sun ou uma nossa o importante aqui que o java e javac usam o mesmo algoritmo bsico de busca em relao a uma class. Um exemplo : se eu uso o javac para compilar Camilo.java que dentro de com. Ento o java precisara encontrar o o mesmo caminho ou seja : import com.Camilo; Assim que encontra a class a busca parada se tiver mais de um arquivo com o mesmo nome o primeiro encontrado usado Classpath caminhos de busca de classes Material desenvolvido Camilo Lopes - Resumo de Estudo
Certificao JAVA
190
Um ponto interessante quando o java ou javac reclama de no encontrar o arquivo .class e voc ta vendo que o arquivo ta la. Um ponto a observar que ao procurar arquivos de class o java no procuram no diretorio atual padro quando usar o cp ou classpath voc deve instruir a procurar no diretrio padro usando o . ponto no final -classpath /com/Lopes. Procure no diretrio Lopes As buscas so realizadas da esquerda para DIREITA. Pacotes Quando se Poe uma class dentro de um pacote o nome da mesma se torna atmica no possvel dividir veja: Caminhos absolutos e relativos O absoluto ele indica que este caminho comea pelo diretrio raiz do sistema sem se importar o diretrio atual. Relativo caminho NO comea com uma barra.

Certificacao Java SCJP 5

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Certificacao Java SCJP 5

Caricato da

Copyright:

Formati disponibili

Certificao JAVA Reviso Certificao Java 5 Kathy Sierra Capitulo 1 Declarao e Controle de Acesso Identificadores Legais

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA Se ligue:

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA Modificadores de acesso

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA Exemplos com DEFAULT

As Variaveis Locais nao podem ter modificadores de Acesso

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA ***Abstract e Static no se do bem!!

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

............................................. J esses compila:

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Converso de variveis de referencia

Material desenvolvido Camilo Lopes - Resumo de Estudo

Abaixo cdigo que no compila e lana excees:

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA Interface

Material desenvolvido Camilo Lopes - Resumo de Estudo

CAPITULO 3 Converso de tipos primitivos

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA OBJETOS STRING Os objetos string so inalterveis.

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA ARRAY

Material desenvolvido Camilo Lopes - Resumo de Estudo

chama um mtodo com referencia nula.

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA Array de referencia a objetos

Usando a class Wrapper

serve para converter o valor de um objeto em um tipo primitivo.

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA AutoBoxing - torna-se + conveniente o uso das classes wrapper.

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA ...............................................................

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

Certificao JAVA System.out.println("eh tres");

Material desenvolvido Camilo Lopes - Resumo de Estudo

RUNTIMEEXCEPTION Super class Excees no verificadas

Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo

.......................... Material desenvolvido Camilo Lopes - Resumo de Estudo

Material desenvolvido Camilo Lopes - Resumo de Estudo