Capitulo 1

Identificadores legais
Regras:
Comear com letra, cifro ou caracter de conexo (_). No podem comear com
numero!
Aps primeiro caracter, pode conter qualquer combinao de letras, caracteres de
moedas, caracteres de conexo ou nmeros;
No h limite de numero de caracteres;
No pode usar palavra reservada java;
So case sensitiva, portanto, foo no igual a Foo;
Convenes de cdigo java da SUN
Classes e Interfaces: primeira letra maiscula, o resto em camelCase; Ex: Dog, Cachorro,
NomeClasse;
Mtodos: primeira letra minscula, demais camelCase. Ex: getBalance, doCalculation;
Variveis: primeira letra minscula, demais camelCase. Ex: buttonWidth, myString;
Constantes: tudo em letra maiscula. Ex: MIN_HEIGHT;
Declarao de classes Modificadores de acesso
Classes utilizam apenas os modificadores default e public:
Acesso defaul: Apenas classes do mesmo pacote podero acessar
Exemplo declarao:
class NomeClasse {
}
Acesso public: Todas as classes acessam
Exemplo declarao:
public class NomeClasse {
}

Outros modificadores no referentes a acesso

Capitulo 2
Benefcios do Encapsulamento
Principio do encapsulamento definir variveis de instancia private e mtodos com acesso
public acessando a estas variveis.
Herana, -UM (IS-A), TEM-UM(HAS-A)
-UM: Ocorre quando uma classe herda ou implementa de alguma outra classe. Exemplos:
public classe Vehicle {}
public class Car
extends Vehicle {}
public class Subaru extends Car {}
Portanto:
Car -UM Vehicle;
Subaru -UM Car;
Subaru -UM Vehicle;
TEM-UM: Ocorre se o cdigo da classe A apresentar uma referncia a uma instncia da classe
B. Exemplos:
public class Animal {}
public class Horse extends Animal {
private Halter myHalter;
}
Portanto:
Horse -UM Animal;
Horse TEM-UM Halter;
Polimorfismo
Todo o objeto aceito no teste -UM polimrfico.
Coisas importantes sobre variveis de referncia:
S pode ser de um tipo e, uma vez declarado, esse tipo nunca pode ser mudado;
O tipo de varivel de refncia determina os mtodos que podem ser chamados no
objeto o qual a varivel esta refernciando;
Uma varivel de referncia pode apontar para qualquer objeto do mesmo tipo que a
referncia declarada ou a qualquer subtipo do tipo declarado.
Uma varivel pode ser declarada com um tipo de classe ou tipo de interface. Se for
declarada por um tipo que seja uma interface, poder referenciar qualquer objeto que
implemente esta interface;
IMPORTANTE: Uma classe no pode estender mais do que uma classe.
Sobrescrevendo / Sobrecarregando
Mtodos Sobrescritos
Exemplo de sobrescrita de mtodo:
public class Animal {
public void eat() {
System.out.println(Animal genrico comendo de forma genrica);
}
}

Class Horse extends Animal {

//Sobrescrevendo o mtodo eat() da classe pai
public void eat() {
System.out.println(Cavalo comendo coisas como um cavalo);
}
}
Agora, um exemplo de uma classe que chama estas classes e testa a execuo dos
mtodos:
public class TestAnimals {
public static void main(String [] args) {
Animal a = new Animal();
Animal b = new Horse();//Referencia animal apontando objeto Horse
a.eat();// Executa a verso Animal do mtodo eat()
b.eat(); //Executa a verso Horse do mtodo eat() O
compilador age da seguinte forma " A varivel x est chamando o mtodo em
Animal, mas o objeto sobrescreveu? Ento execute o mtodo do objeto!".
}
}
As regras de acessibilidade de membros de classe vistas no capitulo 1 devem ser
consideradas na sobrescrita. Lembre-se que um mtodo que no herdado, no pode ser
sobrescrito, portanto:
Subclasse no mesmo pacote que a superclasse pode subscrever mtodos, desde que
estes no sejam private ou final;
Subclasse em pacote diferente apenas no pode subscrever mtodos final, pois,
protected podem ser herdados por classes em diferentes pacotes, como visto no
captulo 1;
Outras regras importantes para subscrever um mtodo:
Lista de argumentos deve coincidir exatamente com a do mtodo sobrescrito;
Tipo de retorno deve ser o mesmo, ou um subtipo, do tipo de retorno declarado no
mtodo original;
O nvel de acesso no pode ser mais restritivo do que o mtodo original;
O nvel de acesso pode ser menos restritivo do que o mtodo original;
O mtodo que sobrescreve pode lanar qualquer exceo no verificada (Excees
no verificadas so excees de tempo de execuo So tratadas por instancias de
subclasses de RuntimeException), independente do mtodo que foi sobrescrito declarar
ou no a exceo; Significa que se o mtodo da superclasse no tiver nenhum throws
(gatilho) de exception declarado e/ou se entre os declarados, no tiver nenhum throws
para uma exceo de tempo de execuo (RuntimeException por exemplo), esta
poder ser declarada (atravs de um throw) no mtodo sobrescrito;
O mtodo que sobrescreve no deve lanar excees verificadas (Excees
verificadas so erros que dependem da lgica do programa, em geral defeitos nos
dispositivos de I/O (arquivos, banco de dados, rede, etc..) So tratadas pela classe
Exception e suas subclasses) novas ou mais abrangentes que as declaradas pelo
mtodo que esta sendo sobrescrito; Significa que se na superclasse um mtodo declara
um throws para SQLException, por exemplo, o mtodo sobrescrito no poder declarar
um throws para Exception, pois este mais abrangente que SQLException. Se declarar
um IOException no mtodo sobrescrito, tbm d erro, tendo em vista que o mtodo da
superclasse declara apenas SQLException e, portanto, seria nova no mtodo
sobrescrito;

O mtodo que sobrescreve poder lanar excees mais restritivas ou menos

abrangentes. Significa dizer que se a superclasse declara um throws para Exception,
no mtodo sobrescrito possvel declarar um throws para SQLException, por exemplo,
pois este mais restritivo ou menos abrangente que Exception;
Voc no pode sobrescrever um mtodo marcado como final;
Voc no pode sobrescrever um mtodo marcado como static;

Chamando a Verso da Superclasse de um Mtodo Sobrescrito

Basta usar a palavras super antes da chamada do mtodo. Por exemplo:
super.metodoDaClassePai();
OBSERVAO: Embora at este ponto nada sobre exceo tenha sido abordado, apontado o
livro um exemplo importante sobre excees e mtodos sobrescritos que pode cair no exame.
Segue:

public class Animal {

void comer() throws Exception {
//Lana uma exceo
}
public static void main(String[] args) {
Animal a = new Dog(); //Referncia polimrfica
a.comer(); //Aqui d erro de compilao. Para resolver, necessrio colocar um
try cath tratando a exception neste ponto. Na verdade, o mtodo a ser executado aqui
ser o da classe Dog (que no retorna exception alguma), entretanto, o compilador no
entende este processo e retorna erro ao compilar esta classe.
}
}
class Dog extends Animal {
void rolar() {
System.out.println("Dog rolando...");
}
void comer() { //Sobrescrita do mtodo comer sem exceo....
System.out.println("Dog comendo...");
}
}
Para este exemplo, haver erro de compilao, pois na superclasse h uma exceo declarada
e mesmo que em tempo de execuo a verso do mtodo a ser executada seja a da classe
filho Dog que no retorna nenhuma exceo, o compilador no entende e retorna erro de
compilao, exigindo que o tratamento da exceo na chamada do mtodo a.comer() na
classe Animal seja feita atravs de um try cath.
Mtodos Sobrecarregados
Utilizao de um mtodos com o mesmo nome em uma classe, com argumentos diferentes
(Ocasionamente, com tipos de retorno diferentes).
Regras:

Devem alterar a lista de argumentos;

Podem alterar o tipo de retorno;
Podem alterar o modificador de acesso;
Podem declarar excees verificadas novas ou mais abrangentes;

Chamando Mtodos Sobrecarregados

Nesta sesso, demonstado um exemplo onde h um mtodo sobrecarregado, onde um
declara dois parmetros int e o outro, dois parmetros double. Na chamada destes mtodos,
passado primeiro duas variveis int (Executando o mtodo sobrecarregado com dois
parametros int) e depois, passado 22.5 e 89.36 usando assim o mtodo double. At aqui,
sem mistrio!
H outro exemplo, mais interessante. Veja:
class Animal {}
class Horse extends Aninal {}
classe UseAnimals {
public void doStuff(Animal a)
{
System.out.println( um animal!);
}
}
public void doStuff(Horse h)
{
System.out.println( um Cavalo!);
}
}
public static void main(String [] args) {
UseAnimals ua = new UseAnimals();
Animal animal = new Animal();
Hoser horser = new Horse();
Animal animalRefHorse = new Horse();
ua.doStuff(animal); //Sada aqui ser um animal!
ua.doStuff(horser); // Sada aqui ser um Cavalo!
ua.doStuff(animalRefHorse); //Sada aqui ser um Animal! O tipo
da referncia e no do objeto em execuo determina que mtodo ser chamado!
ATENO pois isso o inverso da sobrescrita, que SEMPRE executa o mtodo do
objeto em execuo!
}
}
Polimorfismo em Mtodos Sobrecarregado e Sobrescrito
No li nada nesta sesso relevante, que eu no saiba, por isso no perdi tempo
documentando.
Converso (cast) de Variveis de Referncia
Exemplo interessante. Veja:
class Animal {
void makeNoise() {
System.out.println(Barulho genrico);
}
}

class Dog extends Aninal {

void makeNoise() {
System.out.println(Barulho de cachorro);
}
void playDead() {
System.out.println(Rolar!);
}
}
classe UseAnimals {
public static void main(String [] args) {
Animal [] a = {new Animal(), new Dog(), new Animal()};
for(Animal animal : a)
{
animal.makeNoise();
if(animal instanceof Dog) {
animal.playDead(); //Aqui d erro de compilao, pois o mtodo
playDead no existe na classe animal!
//Para que este erro no ocorra, necessrio realizar um downcast
(converter para baixo na rvore de herana) antes. Veja:
Dog d = (Dog) animal;
d.playDead(); //Agora sim possvel chamar o mtodo playDead da classe
Dog
//ATENO linha abaixo! O compilador permitira, embora ocorra um
erro em tempo de execuo
Animal animal2 = new Animal(); //Veja, diferente do exemplo anterior, aqui
a referncia animal2 para um objeto Animal e no para Dog , portanto, no
possvel o downcast! Veja:
Dog d = (Dog) animal2; //Aqui ocorreria o erro de execuo! O compilador
identifica tratar-se de tipos da mesma rvore de herana e permite. tudo que o
compilador pode fazer em casos como este!
}
}
}
Para o upcast (converso para cima na rvore de herana), pode ocorrer de forma implcita ou
explcita:
Dog d = new Dog();
Animal a = d; //Implcito
Animal a2 = (Animal) d; // Explcito
ATENO!
Animal a = new Dog();
Dog d = (Dog) a;
d.doDogStuff();
a mesma coisa que:
((Dog).a).doDogStuff();

Implementando uma interface

Para ser uma classe de implementaao vlida,, uma classe de implementao no abstract
deve fazer o seguinte:
Fornecer implementaes concretar (no abstract) de todos os mtodos da interface
declarada;
Seguir todas as regras de sobrescrita vlidas (Vide capitulo 5);
Declarar excees no verificadas nos mtodos de implementao diferente dos
declarados pelo mtodo da interface, ou subclasses dessas declaradas pelo mtodo da
interface;
Manter assinatura e o mesmo tipo de retorno do mtodo da interface, no sendo
necessrio declarar as exceoes declaradas no mtodo da interface;
Se a classe de implementao for abstract, no precisa implementar nenhum mtodo
da classe implementada;
Uma classe pode implementar mais de uma interface;
Uma interface pode extender outras interfaces (a primeira classe concreta dever
implementa os mtodos da interface implementada e de todas as quais esta interface
tbm esta extendendo);
Uma interface NO pode implementar outra interface!;
Uma interface NO pode estender uma classe!;

Exemplo interessante:
Assumindo-se que temos uma interface Bounceable com dois mtodos: bounce() e
setBounceFactor();
abstract class Ball implements Bounceable {} // A classe de implementao
abstract, portanto, no precise implementar os mtodos da interface! At aqui,
ok...
class BeachBall extends Ball { //embora no esteja explcito, BeachBall
implementa Bounceable, uma vez que extende a classe Ball, portanto, dever
declarar os mtodos bounce() e setBounceFactor();
public void setBounceFactor() {
}
public void bounce() {
}
}
ATENO: No exemplo acima, caso a classe abstrata Ball tivesse implementado um mtodo
(bounce() por exemplo) da interface Bounceable, ento, a classe BeachBall precisaria
implementar apenas o outro (setBounceFactor por exemplo), pois o outro mtodo j foi
implementado pela classe abstrata Ball.
Tipos de Retornos Vlidos
Veja exemplo abaixo:
public classe Foo {
Void go() {}
}
Public classe Bar extends Foo {
String go(int x) {
return null;

}
}
A verso do mtodo go da classe Bar usa um tipo de retorno diferente. Isso perfeitamente
adequado, uma vez que na sobrecarga a lista de argumentos do mtodo que precisa ser
diferente!
IMPORTANTE: Se na classe Bar o mtodo go estivesse da seguinte forma:
String go() {
}
Essa seria uma sobrecarga invlida, uma vez que no possvel modificar apenas o tipo de
retorno na sobrecarga.

Sobrescrita, Tipos de Retorno e Retornos Covariantes

Veja o exemplo:
class Alpha {
Alpha doStuff (char c) {
Return new Alpha();
}
}
classe Beta extends Alpha {
Beta doStuff(char c)
{ //Este um exemplo de retorno covariante. Uma vez
que Beta subclasse de Alpha, pode retornar Beta que ainda assim ser uma sobrescrita
vlida. Lembrando que retornos covariantes so permitidos a partir d Java 5;
return new Beta();
}
}
Com exceo ao retorno covariante, um mtodo sobrescrito dever retornar o mesmo tipo do
mtodo da superclasse.
Retornando um Valor
Seis regras:
Voce poder retornar null em um mtodo que tenha como tipo de retorno a referncia a
um objeto;
O array um tipo de retorno perfeitamente vlido;
Em um mtodo com um tipo de retorno primitivo, voce pode retornar qualquer valor ou
varivel que possa ser implicitamente convertido para o tipo de retorno declarado;
Em um mtodo com um tipo de retorno primitivo, voce pode retornar qualquer valor ou
varivel que possa ser explicitamente convertido (cast) para o tipo de retorno
declarado;
public int foo ()
{
float f = 32.5f;
return (int) f;
}
Voc no deve retornar nada de um mtodo com tipo de retorno void;
Em um mtodo que tenha como tipo de retorno a referncia a um objeto, voc pode
retornar qualquer tipo de objeto que possa ser implicitamente convertido para o tipo de
retorno declarado (ou seja, um subtipo);
Construtores e Instanciao

Aspectos bsicos
Um contrutor tem o mesmo nome da classe, sem tipo de retorno. Exemplo:
class Foo {
int size;
String name;
Foo(String name, int size) {
this.name = name;
this.size = size;
}
}
Neste caso, se tentarmos instanciar um objeto Foo da seguinte forma: Foo f = new
Foo();...dar erro, pois no h um construtor sem argumentos declarado. Se no houver
nenhum construtor declarado, por default haver um, no seguinte formado (a exemplo da
classe Foo acima).. Foo() {}
Cadeia de Construtores
Os construtores so chamados em tempo de execuo, ao digitar new em alguma classe. Ex:
Horse h = new Horse();
IMPORTANTE:
Considerando que Horse estende Animal e que Anima estende Objetc. Ao digitar new Horse,
ocorrer o seguinte:
O construtor de Horse ser chamado e far uma chamada ao construtor de Animal
(Implcitamente);
O construtor de Animal far uma chamada ao construtor de Object (Implicitamente);
Object a ltima classe na hierarquia de classes, portanto, a ponta da pilha. Agora as
variveis de instancia de Object recebero seus valores explcitos (Valores atribudos na
declarao das variveis int x = 210; por exemplo);
A execuo do construtor de object ser concluda, voltando para o construtor de
animal onde as variveis de instncia de Animal recebero seus valores explcitos (se
houver). Isto feito, a executao do construtor de Animal ser concluda, voltando para
o construtor de Horse onde as variveis de instncia recebero seus valores (se
houver) e a execuo do construtor de Horse ser concluda;
Regras dos Construtores
Podem usar qualquer modificador de acesso, inclundo private (permitindo que apenas
o cdigo dentro da propria classe instancie este objeto);
O nome do construtor deve coincidir com o da classe;
Os construtores no devem ter um tipo de retorno. Se tiver um tipo de retorno ser um
mtodo normal e no um construtor;
Se vc no inserir, o compilador ir inserir um padro sem argumentos;
Se vc inserir um construtor com argumentos, o construtor default do compilador no
existir, portanto, dever inserir um sem argumento caso seja do seu interesse;
Todo construtor deve ter como sua primeira instruo a chamada a um construtor
sobrecarregado (this()) ou ao construtor da superclasse (super()), mas lembre-se de
que essa chamada pode ser inserida pelo compilador;
Se voc inserir um construtor e no digitar super() ou this(), o compilador ir inserir
automticamente uma chamada a super() sem argumentos, como a primeira instruo
do construtor.
A chamada a super() pode ser sem argumentos ou incluir os argumentos passados para
o construtor da superclasse;
IMPORTANTE: Veja o exemplo a seguir:
public class SuperClasseTesteConstrutor {

int valor;
SuperClasseTesteConstrutor(int umValor) {//O construtor aqui DEVE receber um parmetro;
this.valor = umValor;
}

public class TesteConstrutor extends SuperClasseTesteConstrutor {

public int numero = 10;
private TesteConstrutor() {
super(1);//Se remover a chamada a super(1), ocorre ERRO, pois a chamada default do
compilador a super() ir falhar, uma vez que a superclasse tem um construtor que declara
um parmetro!
}
public static void main(String [] args) {
TesteConstrutor testeConstrutor = new TesteConstrutor();
System.out.println(testeConstrutor.numero);
}
}

Vc no poder fazer uma chamada a um mtodo de uma instncia ou acessar uma

varivel de instncia at que tenha executado o construtor da superclasse;
Apenas variveis e mtodos static podem ser acessados como parte da chamada a
super() ou this(). Exemplo:

public class TesteConstrutor extends SuperClasseTesteConstrutor {

static public int numero = 10;
private TesteConstrutor() {
super(numero);//A varavel de instncia numero static, portanto, pode ser utilizada
na chamada de super(numero);
}
public static void main(String [] args) {
TesteConstrutor testeConstrutor = new TesteConstrutor();
System.out.println(testeConstrutor.numero);
}
}

As classes abstract tem construtores e eles so chamados sempre que uma subclasse
concreta instanciada;
As interfaces NO tem construtores. Elas NO fazem parte da rvore de herana de um
objeto;
A nica maneira de chamar um construtor dentro de um construtor. NUNCA de dentro
de um mtodo normal;

Identificando se um Construtor Padro Ser Criado

O construtor padro do compilador criado apenas se nenhum construtor for declarado na
classe;
Se houver um mtodo com o mesmo nome da classe, entretanto declarando um tipo de
retorno, este JAMAIS ser um construtor.
Como Voc Pode Ter a Certeza de Quem um Construtor Padro Ser Criado?
Na seguinte classe, em negrito esta o que o compilador criar:
class Foo{} O que voc criou

classe Foo {
Foo() { //O que o compilador insere...
super();
}
}
O Que Acontecer se o Construtor da Superclasse Tiver Argumentos?
Esta sesso fala exatamente do problema que informei a pouco, descrita no exemplo abaixo:
public class SuperClasseTesteConstrutor {
int valor;
SuperClasseTesteConstrutor(int umValor) {//O construtor aqui DEVE receber um parmetro;
this.valor = umValor;
}
}
public class TesteConstrutor extends SuperClasseTesteConstrutor {
public int numero = 10;
private TesteConstrutor() {
super(1);//Se remover a chamada a super(1), ocorre ERRO, pois a chamada default do
compilador a super() ir falhar, uma vez que a superclasse tem um construtor que declara
um parmetro!
}
public static void main(String [] args) {
TesteConstrutor testeConstrutor = new TesteConstrutor();
System.out.println(testeConstrutor.numero);
}
}

Construtores Sobrecarregados
A nica coisa importante a observar nessa sesso:
Quando usamos a chamada this(), ou this(valor)...estamos chamando alguma construtor da
mesma classe. Esta chamada retarda a chamada ao mtodo super() que ser feita por
alguma construtor desta mesma classe. Exemplo:
public class Pg82_ArrayString {
String name;
String makeRandomName() {
int x = (int) (Math.random() * 5);
String name = new String[] {"Ab","cd","ef","gh"} [x]; /**Esta linha equivalente ao
seguinte cdigo:
String [] nameList = {"Ab","cd","ef","gh"};
String name = nameList[x];
**/
return name;
}
Pg82_ArrayString () {
this("aa");
}
Pg82_ArrayString (String aa) {
}

O construtor sem argumentos esta fazendo uma chamada para o construtor com argumentos
utilizando this(aa).
IMPORTANTE! A primeira linha de um construtor deve ser uma chamada a super() ou a this().
Se no houver nenhuma dessas chamadas, o compilaor inserir a chamada sem argumentos
a super(). Portanto, se a primeira linha de um construtor for this(), o compilador saber que
no ser este construtor que chamar super(). Um mtodo no pode ter uma chamada a
this() e a super(). Onde houver um, no haver o outro, regra padro!
Variveis e Mtodos Estticos
Um membro static (variavel ou mtodo) no pode chamar um membro no static (varivel ou
mtodo). Isto o que dito nesta sesso!
public Foo {
int x = 3; float y = 4.3g;
public static void main(String [] args) {
for (int z = x; z < ++x; z-, y = y+z) { //ATENO! As variveis x e z no podem
ser chamadas de um mtodo esttico!
}
}
Acessando Variveis e Mtodos Static
Exemplo:
public class Frog {
int frogSize = 0;
static int frogCount = 0;
public int getFrogSize() {
return this.frogSize;
}
public Frog(int s) {
frogSize = s;
}
public Frog() {
frogCount =+ 1;
}
public static void main(String[] args) {
Frog f = new Frog(25);
System.out.println(f.getFrogSize());
new Frog();
new Frog();
new Frog();
System.out.println("frogCount: "+Frog.frogCount); //Acessando um membro static atravs
do nome da classe.
System.out.println(f.frogCount); //Acessando um membro static atravs de uma instncia
da classe. Aqui, o que importa o tipo da varivel f, onde neste caso, o
//tipo Frot, portanto, possvel acessar os membros estticos de Frog.
}
}

IMPORTANTE! Mtodos static NUNCA sero sobrescritos! O mtodo static da Classe e no da

Instncia, veja:
public class Animal {

static void doStuff() {

System.out.println("a");
}
}
package pacote_A;
public class Dog extends Animal {
static void doStuff() {
System.out.println("b");
}
public static void main(String[] args) {
Animal [] a = {new Animal(), new Dog(), new Animal()};
for(int x = 0; x < a.length; x++) {
a[x].doStuf(); // A sada aqui ser a a a, pois o tipo da varivel "a" Animal e,
portanto, o mtodo static doSuff
// da classe Animal ser SEMPRE executado. No h polimorfismo aqui!
}
}
}

Acoplamento e Coeso
Acoplamento: Grau em que uma classe conhece outra classe. Tem a ver com a forma como as
classes interagem umas com as outras. Se o nico conhecimento que a classe A tem sobre a
classe B o que a classe B exps atravs da sua interface, ento diz-se das classes A e B que
elas possuem baixo acoplamento. Isso bom!
Exemplo de acoplamento forte:
public class DoTaxes {
float rate;
float doColorado() {
SalesTaxRates str = new SalesTaxRates();
rate = str.salesRate; //Deveria ser uma chamada a mtodo:
str.getSalesRate("CO");
return rate;
}
}
public class SalesTaxRates {
public float salesRate; //deveria ser private
public float adjustedSalesRate; //deveria ser private
public float getSalesRate(String region) {
salesRate = new DoTaxes().doColorado();
//Faz calculos com base na regio
return adjustedSalesRate;
}
}

Variveis publicas, sem encapsulamento, permitem que a classe DoTaxes saiba o valor da
varivel salesRate na classe SalesTaxRates. Portanto, DoTaxes sabe demais sobre
SalesTaxRates, portanto, tem um forte acoplamento.
Coeso
Tem a ver com o grau em que uma classe tem um nico e bem-focado propsito. Quanto
mais focada for uma classe, maior a coeso. Isso bom!