eating java

Métodos Sobrescritos (Overridden)

2010-04-25T10:25:00.002-03:00

Qualquer classe que herda um método de uma superclasse tem a oportunidade de sobrescrever o método (exceto métodos marcados como final). O benefício de sobrepor é a capacidade de definir um comportamento que é específico para um tipo de subclasse particular.

Para métodos abstratos que são herdados de uma superclasse não existe escolha; deve-se implementar os métodos na subclasse, com exceção se a subclasse também seja uma classe abstrata.

public class Pessoa {

public void cadastrar() {

System.out.println("Cadastro de Pessoa");

}

public class PFisica extends Pessoa {

//método sobrescrito de Pessoa

public void cadastrar() {

System.out.println("Cadastro de PFisica");

}

Polimorficamente é possível declarar um objeto de um tipo e referencia-lo com um de seus subtipos, por exemplo: ao declarar um objeto Pessoa, que é superclasse de PFisica, é possível instanciar esse objeto como Pessoa ou PFisica. Caso seja instanciado como Pessoa, este objeto terá acesso a todos os métodos de Pessoa. Porém, se esse objeto (do tipo Pessoa) estiver instanciado como PFisica e tentar acessar qualquer método que exista em Pessoa, o compilador irá tentar acha-lo primeiro na classe de referência (PFisica), caso não encontre, acessará o método da classe Pessoa.

public class Pessoa {

public void cadastrar() {

System.out.println("Cadastro de Pessoa");

}

public class PFisica extends Pessoa {

//método sobrescrito de Pessoa

public void cadastrar() {

System.out.println("Cadastro de PFisica");

}

public void atualizar() {

System.out.println("Atual. de PFisca");

}

public class AppPessoa {

public static void main(String[] args) {

Pessoa pessoa = new Pessoa();

Pessoa pessoa2 = new PFisica();

pessoa.cadastrar();

pessoa2.cadastrar();

//Pessoa não possui o método atualizar()

pessoa.atualizar();

/* Apesar de PFisica possuir o método

* atualizar(), a referência é da classe

* Pessoa, que não possui o método */

pessoa2.atualizar();

}

Um método sobrescrito não pode ter um modificador de acesso mais restrito do que o método original; por exemplo: não se pode sobrescrever um método public marcando-o como protected; porém, é possível sobrescrever um método protected como public.

public class Pessoa {

public void excluir() {

System.out.println("Excluir Pessoa");

}

public class PJuridica extends Pessoa {

/* um método sobrescrito não pode ter um

* modificador mais restrito que o método

* original */

protected void excluir() {

System.out.println("Excluir PJuridica");

}

Regras para sobrescrever métodos:

· A lista de argumentos deve combinar exatamente com a do método sobrescrito. Se não combinar, pode resultar em uma sobrecarga de método não intencional;

· O tipo de retorno deve ser o mesmo, ou de um subtipo dele;

· O nível de acesso não pode ser mais restrito que o nível do método original;

· O nível de acesso pode ser menos restrito que o nível do método original;

· Métodos de instância só podem ser sobrescritos se eles forem herdados na subclasse. Isso significa que: uma subclasse dentro de um mesmo pacote que a superclasse, pode sobrescrever qualquer método desta que não esteja marcado como private ou final; uma subclasse em um pacote diferente pode sobrescrever apenas métodos não-final marcados como public ou protected;

· O método sobrescrito pode lançar qualquer exceção não verificada (runtime), independente de se o método sobrescrito declara a exceção;

· O método sobrescrito não deve lançar exceções verificadas que são novas ou a mais que o método original; por exemplo, um método que declara uma FileNotFoundException não pode ser sobrescrito por um método que declara uma SQLException, Exception ou qualquer outra exceção verificada (não runtime), exceto se a exceção for uma subclasse de FileNotFoundException;

· O método sobrescrito pode lançar menos exceções que as do método original;

· Não se pode sobrescrever um método marcado como final;

· Não se pode sobrescrever um método marcado como static;

· Se um método não pode ser herdado, então ele não pode ser sobrescrito.

Invocando a versão da superclasse

Podem existir casos em que o método original deve ser executado antes do método sobrescrito. Um modo fácil de fazer isso é utilizando a palavra super seguido do nome do método da superclasse no início do corpo do método original.

A chamada do método da superclasse pode ser feita em qualquer parte do código dos métodos da subclasse.

public class Carro {

public void ligar() {

System.out.println("Ligar carro");

}

public class Fusca extends Carro {

public void ligar() {

super.ligar();

System.out.println("Ligar fusca");

}

Para o compilador, em tempo de compilação, quando existe um objeto referenciando sua subclasse e chamando um método sobrescrito, apenas no momento da compilação, o compilador irá assumir como método de execução o método da superclasse, mesmo que o método sobrescrito na subclasse não declare exceções enquanto o método original declare. Porém, nesse caso, em tempo de execução na verdade o método chamado será o da subclasse.

public class Carro {

public void desligar() throws Exception {

System.out.println("Desligar carro");

}

public class Fusca extends Carro {

public void desligar() { //sem exceção

System.out.println("Desligar fusca");

}

public class AppCarro {

public static void main(String[] args) {

Carro carro = new Fusca();

Fusca fusca = new Fusca();

fusca.desligar();

/* nesse caso, o método a ser executado em

* tempo de execução seria o desligar de

* Fusca, mas a titulo de compilação é o

* de Carro, por isso gera erro de

* compilação, já que o método desligar de

* Carro declara uma exceção que não está

* sendo tratada aqui; */

carro.desligar();

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Polimorfismo

2010-04-21T15:09:00.002-03:00

Qualquer objeto Java que pode passar por mais de um teste IS-A pode ser considerado um caso de polimorfismo. À exceção de objetos do tipo Object, todos os objetos Java são polimórficos, pois eles passam por um teste IS-A com seu próprio tipo e por um com a classe Object.

A única maneira de acessar um objeto é através de uma variável de referência:

· Uma variável de referência (objeto) só pode ser de um tipo, e uma vez declarada, aquele tipo jamais poderá ser mudado, embora o objeto possa mudar a referência;

· Uma referência é uma variável, então ela pode ser transferida para outros objetos, a não ser que a referência esteja declarada como final;

· Um tipo de variável de referência determina os métodos que podem ser invocados no objeto que a variável está referenciada;

· Uma variável de referência pode se referir a qualquer objeto do mesmo tipo que a referência declarada, ou a qualquer subtipo do tipo declarado;

· Uma variável de referência pode ser declarada como um tipo de classe ou um tipo de interface. Se a variável é declarada como um tipo interface, ela pode fazer referência a qualquer objeto de qualquer classe que implementa a interface.

Polimorfismo significa que uma chamada de método pode ser executada de várias formas (ou polimorficamente). Quem decide "a forma" é o objeto que recebe a chamada. Invocações de métodos polimórficos são aplicadas somente para métodos de instância.

Se um objeto a chama um método grita() de um objeto b, então o objeto b decide a forma de implementação do método. Então a chamada b.grita() vai ser um grito humano se b for um humano e será um grito de macaco, se o objeto b for um macaco. A forma como b vai escolher qual método vai executar vai depender de onde (qual classe) veio essa referência de b, ou seja, se b está instanciado como Humano ou Macaco.

Existem quatro formas de receber essa referência:

· O objeto AppGritar cria o objeto b:

public class Gritador {

public void grita() {

System.out.println("Gritando..");

}

public class Humano extends Gritador {

public void grita() {

System.out.println("Humano gritando");

}

public class Macaco extends Gritador {

public void grita() {

System.out.println("Macaco gritando");

}

public class AppGritar {

public static void main(String[] args) {

Gritador g;

g = new Humano();

// chamada polimórfica

g.grita(); // imprime: Humando gritando

g = new Macaco();

// chamada polimórfica

g.grita(); // imprime: Macaco gritando

}

· O objeto AppGritar recebe o objeto g de um objeto r:

public class Retorna {

public Humano retornaHumano() {

return new Humano();

}

public Macaco retornaMacaco() {

return new Macaco();

}

public class AppGritar {

public static void main(String[] args) {

Retorna r = new Retorna();

Gritador g = r.retornaHumano();

// chamada polimórfica

g.grita(); // imprime: Humando gritando

g = r.retornaMacaco();

// chamada polimórfica

g.grita(); // imprime: Macaco gritando

}

· O objeto AppGritar recebe o objeto g numa chamada de método:

public class AppGritar {

public static void main(String[] args) {

Humano humano = new Humano();

chamaGritar(humano); // Humando gritando

Macaco macaco = new Macaco();

chamaGritar(macaco); // Macaco gritando

}

static void chamaGritar(Gritador gritador) {

/* dependendo da instância que vier como

* parâmetro, chama Humano ou Macaco */

gritador.grita(); // chamada polimórfica

}

· Através de uso de interfaces (sem herança):

public interface Gritador2 {

void grita();

}

public class Humano2 implements Gritador2 {

public void grita() {

System.out.println("AAAAAAHHHHH");

}

public class Macaco2 implements Gritador2 {

public void grita() {

System.out.println("IIIHHHIIIIHHH");

}

public class AppGritar2 {

public static void main(String[] args) {

Gritador2 g;

g = new Humano2();

// chamada polimórfica

g.grita(); // imprime: Humando gritando

g = new Macaco2();

// chamada polimórfica

g.grita(); // imprime: Macaco gritando

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Relações IS-A e HAS-A

2010-04-21T15:08:00.000-03:00

IS-A

Em OO o conceito de IS-A é baseado na herança de classe e implementação de interface. É uma forma de dizer que uma classe A é do tipo de uma classe B.

A relação IS-A é expressa através das palavras-chave extends (herança) e implements (interface). Se a expressão A instanceof B retorna true, então A IS-A B, mesmo se uma classe não herde diretamente da outra, ou seja, mesmo se existam outras classes na herança.

interface Celular {

}

public class Nokia implements Celular {

}

public class N95 extends Nokia {

public static void main(String[] args) {

N95 n95 = new N95();

Nokia nokia = new Nokia();

if (n95 instanceof Nokia)

System.out.println("N95 IS-A " +

"Nokia");

if (n95 instanceof Celular)

System.out.println("N95 IS-A " +

"Celular");

if (nokia instanceof Celular)

System.out.println("Nokia IS-A " +

"Celular");

}

HAS-A

Uma relação HAS-A é baseada no uso, ao invés de herança. Em outras palavras, a classe A HAS-A B se um código na classe A faz referência a uma instância da classe B.

class Cachorro {

}

public class App {

//App HAS-A Cachorro

Cachorro cachorro = new Cachorro();

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Herança

2010-04-21T15:05:00.002-03:00

A herança permite que as classes compartilhem atributos e operações baseados em um relacionamento, ou seja, permite a criação de subclasses que herdam alguns dos atributos e das operações da classe pai (super-classe ou classe base). É usada na intenção de reaproveitar código ou comportamento generalizado ou especializar operações e atributos.

A palavra-chave instanceof retorna true se a variável de referência que está sendo testada é do tipo da que está sendo comparada, ou pertence a sua hierarquia.

public class Heranca {

public static void main(String[] args) {

Heranca heranca = new Heranca();

if (heranca instanceof Object)

System.out.println("Herança herda "+

"de Object");

}

Toda classe Java é uma subclasse da classe Object. Por causa disso, toda classe em Java terá métodos como equals, clone, notify, wait, pois são herdados da classe Object.

Em Java é possível criar relações de herança estendendo classes. As duas maiores razões para utilizar herança são: para promover o reuso de código e para utilizar polimorfismo.

Uma classe não pode herdar de mais de uma classe, ou seja, uma classe só pode ter uma superclasse imediata, mas pode ter múltiplos ancestrais.

Uma abordagem comum do reuso de código é criar versões de classes bastante genéricas com a intenção de criar subclasses mais específicas que herdem delas. A reutilização de código através da herança significa que métodos com funcionalidades genéricas, que podem ser aplicados a uma gama de diferentes tipos de classes, não tem que ser reimplementados. Isso significa que toda a subclasse especializada tem por garantia todas as capacidades da superclasse.

public class Pessoa {

public void falar() {

System.out.println("Pessoa falando");

}

public class Pessoa_Fisica extends Pessoa {

public void informarCPF() {

System.out.println("Informando CPF");

}

public class AppPessoa {

public static void main(String[] args) {

Pessoa_Fisica pf = new Pessoa_Fisica();

//herdou o método falar de Pessoa

pf.falar();

pf.informarCPF();

}

O segundo uso de herança é o polimorfismo, que torna qualquer subclasse compatível com a superclasse. Isso quer dizer que polimorfismo significa que uma chamada de método pode ser executada de várias formas (ou polimorficamente); quem decide "a forma" é o objeto que recebe a chamada.

Por exemplo: se um objeto a chama um método grita() de um objeto b, então o objeto b decide a forma de implementação do método. Dessa forma, a chamada b.grita() vai ser um grito humano se b possui uma referência para o objeto Humano e será um grito de macaco, se o objeto b possuir uma referência para o objeto Macaco.

public class Profissao {

public void trabalhar() {

System.out.println("Trabalhando..");

}

public class Professor extends Profissao {

public void trabalhar() {

System.out.println("Ensinando..");

}

public class Mecanico extends Profissao {

public void trabalhar() {

System.out.println("Consertando..");

}

public class Test_Profissao {

public static void main(String[] args) {

Profissao profissao;

profissao = new Professor();

profissao.trabalhar(); //ensinando

profissao = new Mecanico();

profissao.trabalhar(); //consertando

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Encapsulamento

2010-04-08T19:46:00.000-03:00

A Orientação a Objetos propõe uma organização de software em termos de coleção de objetos discretos incorporando estrutura e comportamento próprios. Esta abordagem de organização é essencialmente diferente do desenvolvimento tradicional de software, onde estruturas de dados e rotinas são desenvolvidas de forma apenas fracamente acopladas.

Encapsulamento consiste em separar os aspectos externos de um objeto, os quais são acessíveis a outros objetos, dos detalhes internos de implementação do objeto, os quais permanecem escondidos dos outros objetos. O uso de encapsulamento evita que um programa torne-se tão interdependente que uma pequena mudança tenha grandes efeitos colaterais.

class Quadrado {

public int lado;

}

public class App {

public static void main(String[] args) {

Quadrado quadrado = new Quadrado();

/* isso aparentemente não causa erro, mas

* não é uma boa implementação de

* encapsulamento, pois, dessa forma, é

* possível inserir valores não desejáveis,

* que a classe talvez não esteja

* preparada para receber */

quadrado.lado = 1;

quadrado.lado = -1;

}

Para ter uma classe que possa ser alterada sem gerar muitos danos em outras classes que a estão utilizando, é necessário incluir encapsulamento, para isso deve-se:

· Manter as variáveis de instância protegidas (com algum modificador de acesso, normalmente private);

· Tornar público os métodos de acesso (getters e setters), forçando o código de chamada para usar esses métodos em vez de acessar diretamente a variável de instância;

· Usar a convenção JavaBean para os getters e setters.

class Retangulo {

//proteger as variáveis de instâncias

private int lado;

//métodos getters e setters públicos

public int getLado() {

return lado;

}

public void setLado(int lado) {

//tratamento do dado que será settado

if (lado < 0)

this.lado = 0;

else

this.lado = lado;

}

public class App2 {

public static void main(String[] args) {

Retangulo retangulo = new Retangulo();

retangulo.setLado(1);

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Declarando Enums

2010-04-04T10:52:00.001-03:00

Java permite restringir uma variável a ter uma de apenas alguns valores pré-definidos, em outras palavras, um valor a partir de uma lista enumerada.

Os componentes básicos de um enum são suas constantes.

enum Refrigerante { COCA, FANTA, SODA }

Enums podem ser declarados como classes separadas, ou como um membro de classe, entretanto, eles não devem ser declarados dentro de um método. Aqueles que não estão dentro de uma classe podem ser declarados apenas com os modificadores public ou deafult. Utiliza-se a palavra-chave enum para declará-los e é opcional o uso de ponto-e-vírgula no final da declaração.

package dec_enum;

enum Refrigerante {//não pode ser private/protected BIG, HUGE, OVERWHELMING

}

class Bebida {

Refrigerante refri;

}

public class Bebida_Test {

/* tb pode estar dentro de uma classe e pode ter

* qualquer modificador de acesso; o ponto-e-

* virgula é opcional na declaração */

protected enum Test { Test1, Test2, Test3 };

public static void main(String[] args) {

Bebida drink = new Bebida ();

drink.refri = Refrigerante.BIG; System.out.println(drink.refri);

System.out.println(Test.Test1);

}

Enums são representados como instâncias static e final, o que significa que são constantes. Cada enum conhece seu index ou posição, o que significa que a ordem em que são declarados importa. Pode-se dizer que um enum é um array de algum tipo.

Declarando construtores, métodos e variáveis em um Enum

Pelo fato de um enum ser um tipo especial de classe, é possível adicionar construtores, variáveis de instância, métodos e um corpo de classe constante específica.

Todo enum possui um método estático chamado values(), que retorna um array com todos os enums na ordem em que foram declarados.

package declare_class_members;

enum Refri {

//8,10,16 são passados para o construtor do enum

COCA(2), FANTA(3), SODA(6);

Refri(int qtd) { //construtor do enum

this.qtd = qtd;

}

private int qtd; //variável de insância do enum

public int getQtd() {//método get dentro do enum

return qtd;

}

class Bebida {

Refri refri;

public static void main(String[] args) {

Bebida drink1 = new Bebida();

drink1.refri = Refri.COCA;

Bebida drink2 = new Bebida();

drink2.refri = Refri.FANTA;

for (Refri cs : Refri.values())

System.out.print(cs+" "+cs.getQtd());

}

Pontos a serem considerados sobre enums: não é possível invocar um construtor enum diretamente, pois o construtor enum é invocado automaticamente, com os argumentos definidos depois do valor constante; pode-se definir mais de um argumento para o construtor, e é possível sobrecarregar os construtores enums, assim como se pode sobrecarregar um construtor de uma classe normal; utiliza-se corpo de classe constante específica quando é necessária uma constante particular para substituir um método definido em um enum.

package dec_enum;

enum Refri2 { //possui 3 constantes

COCA(8), //não possui corpo

FANTA(10){ //corpo para essa constante

/* sobrescrita (apenas para essa constante)

* do método declarado no enum */

public String getCode() {

return "C";

}

SODA(16) { //corpo para essa constante

/* sobrescrita (apenas para essa constante)

* do método declarado no enum */

public String getCode() {

return "A";

}

}; //qdo segue mais código o (;) é obrigatório

Refri2(int qtd) {

this.qtd = qtd;

}

private int qtd;

public String name;

public int getQtd() {

return qtd;

}

/* esse método é sobrescrito pelas constantes

* FANTA e SODA */

public String getCode() {

return "B";

}

class Bebida2 {

Refri2 refri;

public static void main(String[] args) {

Bebida2 drink1 = new Bebida2();

drink1.refri = Refri2.COCA;

drink1.refri.name = "Teste1";

Bebida2 drink2 = new Bebida2();

drink2.refri = Refri2.FANTA;

drink2.refri.name = "Teste2";

for (Refri2 cs : Refri2.values()) {

System.out.println(cs.getQtd());

System.out.println(cs.name);

System.out.println(cs.getCode());

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Métodos e Variáveis Estáticas

2010-03-30T20:43:00.003-03:00

O modificador static é usado para criar variáveis e métodos que irão existir independentemente de qualquer instância criada para a classe.

Em outras palavras, membros static existem antes mesmo da criação da instância de uma classe, e haverá apenas uma cópia do membro independentemente do número de instâncias daquela classe, ou seja, todas as instâncias dessa classe irão compartilhar o mesmo valor para qualquer variável static.

Podem ser marcados como static: métodos, variáveis, uma classe interna dentro de outra classe (mas não dentro de um método) e blocos de inicialização; não pode ser marcados como static: construtores, classes (exceto as internas), interfaces, métodos de classes locais, variáveis de instância e variáveis locais.

Métodos static não têm acesso direto a membros (métodos ou variáveis) não-estáticos.

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Declarações de Variável

2010-03-25T20:23:00.003-03:00

Existem dois tipos de variáveis em Java:

· Variáveis primitivas: uma variável primitiva pode ser de oito tipos: char, boolean, byte, short, int, long, double ou float. Uma vez que uma variável primitiva tenha sido declarada, seu tipo primitivo nunca poderá mudar; embora seu valor possa na maioria das vezes;

· Variáveis de referência: é usada para referenciar ou acessar um objeto. É declarada com um tipo específico que não pode ser mudado, mas pode ser usada para fazer referência a qualquer objeto do tipo declarado, ou de um subtipo do tipo declarado (um tipo compatível).

Declarando primitivos:

Variáveis primitivas podem ser declaradas como variáveis de classe (estáticas), variáveis de instância, parâmetros de métodos ou variáveis locais.

A seqüência dos tipos numéricos do menor para o maior é: byte, short, int e long; double é maior do que float.

Declarando variáveis de referência:

Podem ser declaradas como variáveis estáticas, variáveis de instância, parâmetros de métodos e variáveis locais.

Declarando variáveis de instância:

Variáveis de instância são definidas dentro de uma classe, mas fora de qualquer método, e só podem ser inicializadas quando a classe é instanciada. São campos que pertencem a cada objeto único, ou seja, cada instância da classe tem seus próprios valores para os campos ou variáveis de instância.

Regras para variáveis de instância:

· Podem usar qualquer um dos quatro níveis de acesso;

· Podem ser marcadas como final e transient;

· Não podem ser marcadas como abstract, synchronized, strictfp, native e static (porque nesse caso se tornariam variáveis de classe).

Os modificadores de acesso funcionam em variáveis de instância da mesma forma que em métodos.

Variáveis locais:

Variáveis locais são declaradas dentro de um método, o que significa que são construídas quando o método é executado, e destruídas quando o método termina. Não podem usar a maioria dos modificadores, como: todos os modificadores de acesso, transient, volatile, abstract e static; o único que pode ser utilizando é o final.

Antes de uma variável local ser usada, ela deve ser inicializada, pois variáveis locais não recebem valor default; qualquer código que tentar utilizar uma variável local não inicializada o compilador não irá aceitar.

É possível declarar uma variável local com o mesmo nome de uma variável de instância; isso é chamado de sombreamento. Para resolver problemas de nomes de variáveis locais e de instância com a mesma identificação, basta utilizar a palavra-chave this seguida de ponto (.) antes de variáveis de instância.

public class Sombreamento {

int cont = 1;

public void setCont(int cont) {

//não sabe a qual variável está referindo

cont = cont;

//por isso utiliza-se a notação abaixo

this.cont = cont;

}

Declarações de array:

Arrays são objetos que guardam múltiplas variáveis do mesmo tipo, ou variáveis que são subclasses do mesmo tipo; podem guardam tanto primitivos quanto objetos. São declarados indicando o tipo de elementos que irão usar (primitivo ou objeto), seguido por um par de colchetes que pode vir antes ou depois do nome do array.

Pode-se declarar também arrays multidimensionais, que são arrays de arrays; o conjunto de pares de colchetes pode aparecer antes ou depois do nome da matriz.

Não é permitido incluir o tamanho do array na sua declaração, pois isso deve ser feito na inicialização.

public class Arrays {

/* é recomendado colocar os colchetes antes

* do nome do array */

int[] array;

/* é permitido colocar os colchetes depois

* do nome do array, mas é menos legível */

Thread array2 [];

String [][] matriz;

/* também é permitida essa disposição dos

* colchetes depois, mas é menos legível */

String [] matriz2 [];

}

Variáveis final:

Declarar uma variável primitiva como final torna impossível reinicia-la com outro valor após ter recebido um valor explicitamente (valor não default). Entretanto, uma variável de referência (objeto) marcada como final não poderá jamais se referir a um objeto diferente, somente os dados dentro do objeto podem ser modificados. Isso quer dizer que não existe objetos final e sim referências de objetos final.

import java.util.Date;

public class Var_final {

final int num = 10;

final Date data = new Date();

void teste() {

/* erro, variável final não pode receber

* um novo valor */

num = 45;

/* erro, objeto final não pode receber uma

* nova referência */

data = new Date();

/* mas pode ter os valores de seus campos

* alterados */

data.setYear(2008);

}

Variáveis transient:

Quando uma variável de instância é marcada por transient, significa que a máquina virtual irá ignorar esta variável quando tentar serializar o objeto que a contém.

A serialização permite salvar o estado de um objeto (em outras palavras, o valor das suas variáveis de instância) em um tipo especial de transmissão I/O; é possível salvar um objeto em um arquivo, ou enviá-lo para outra máquina virtual.

Variáveis volatile:

O modificador volatile diz a máquina virtual que uma thread acessando a variável deve sempre conciliar a sua própria cópia privada da variável com a cópia mestre em memória.

Assim como o modificador transient, volatile só ser aplicado a variáveis de instância.

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Declarações de Construtor

2010-03-21T09:54:00.001-03:00

Em Java, objetos são “construídos”. Toda vez que um objeto é criado, um construtor é invocado. Toda classe possui um construtor, mesmo que não esteja declarado explicitamente na classe, isso quer dizer que, caso não esteja, o compilador irá criar um.

Construtores parecem muito com métodos. A diferença é que construtores jamais terão um tipo de retorno.

Declarações de construtores podem, entretanto, ter qualquer tipo de modificador de acesso, e podem ter argumentos (inclusive var-args), assim como métodos.

Além disso, construtores devem ter o mesmo nome da classe na qual estão sendo declarados, não podem ser marcados como static (porque estão completamente associados à instanciação, e o modificador static não está relacionado a isso) e não podem ser marcados como final ou abstract (porque não podem ser sobrescritos).

public class Construtor {

Construtor() { }

protected Construtor(int value) { }

private Construtor(String... value) { }

// construtores não podem ser static

static Construtor(String var) { }

// construtores não podem ser final

final Construtor(char var) { }

/* aparenta ser um construtor, mas trata-se

* de um método com o mesmo nome da classe */

public void Construtor() { }

}

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Métodos com Listas de Argumento Variável (var-args)

2010-03-20T16:12:00.001-03:00

Argumentos são variáveis especificadas entre parênteses na invocação (chamada) de um método; parâmetros são variáveis declaradas na assinatura de métodos, que indica o que o método deve receber quando for invocado.

// exemplo de parâmetros

private void test1(String var, int value) { }

//exemplo de argumentos

test1(var, value);

Java permite a criação de métodos que podem ter um número variável de argumentos ou var-args.

Regras para declaração de var-args:

- Tipo de var-arg: quando um parâmetro var-arg é declarado, é necessário especificar o tipo de argumento que esse parâmetro irá receber; podendo este ser um tipo primitivo ou um tipo de objeto;

- Sintaxe básica: para declarar um método usando um parâmetro var-arg, coloca-se o tipo do var-arg acompanhado de reticências, um espaço e o nome do array que irá guardar os parâmetros recebidos;

/* esse método espera de 0 a muitos ints

* como parâmetro*/

void testVar_arg(int... x) { }

- Outros parâmetros: é permito ter outros parâmetros comuns na assinatura do método que usa var-args;

/* esse método espera primeiro um char e depois

* de 0 a muitos ints como parâmetros */

void testVar_arg(char c, int... x) { }

- Limites de var-args: o var-arg deve ser o último parâmetro na assinatura do método, e só é permitido um var-arg por método.

// só é permitido um var-arg por método

void testVar_arg(int... x, char... y) { }

// o var-arg deve ser o último parâmetro

void testVar_arg(String... s, byte b) { }

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Modificadores Não Referentes à Acesso para Membros de Classes

2010-03-14T08:54:00.001-03:00

Métodos final:

A palavra-chave final impede um método de ser sobrescrito em uma subclasse, sendo frequentemente usado para impor a funcionalidade de um método.

Argumentos final:

Argumentos de métodos são declarações de variáveis que aparecem entre parênteses em uma declaração de método.

São tratados da mesma forma que variáveis locais, ou seja, podem ser usadas com o modificador final, o que significa que seu valor não poderá ser modificado dentro do método.

Nesse caso, “modificado” significa a reatribuição de um novo valor à variável, ou seja, o argumento final deve manter o mesmo valor que o parâmetro tinha quando foi passado para o método até o final.

public class Argumentos {

public void setArg(String obj1,

final String obj2) {

String obj3 = new String();

obj1 = obj3;

/* erro, argumentos final não podem ter

* um novo valor reatribuído */

obj2 = new String();

/* erro, argumentos final não podem ser

* modificados */

obj2 = obj3;

}

Métodos abstratos:

Um método abstrato é um método que foi declarado, mas não foi implementado; ou seja, o método não contém código funcional.

Métodos abstratos não são declarados com chaves, apenas com ponto-e-vírgula depois dos parênteses, já que não possuem corpo de método. São utilizados quando é necessário forçar subclasses a implementar a funcionalidade.

Classes que possuem métodos abstratos devem ser necessariamente declaradas como abstract também, entretanto, classes abstratas podem conter métodos não-abstratos.

Qualquer classe que herdar de uma classe abstrata deve implementar todos os métodos abstratos da superclasse, exceto se a subclasse também for abstrata.

A regra é: a primeira subclasse concreta (não-abstrata) de uma árvore de herança de classes abstratas deve implementar todos os métodos abstratos das suas superclasses. No caso de um método abstrato de uma superclasse ser implementado na subclasse abstrata, não será obrigatória a implementação deste na classe concreta que herdar dessas classes, pois foi possível implementa-lo na classe abstrata.

public abstract class Animal {

private String nome;

// método não abstrato

public String getNome() {

return nome;

}

// método abstrato

public abstract void falar();

}

public abstract class Mamifero extends Animal {

/* um método abstrato pode ser implementado

* em outra classe abstrata */

public void falar() { }

}

public class Cachorro extends Mamifero {

/* não é uma implementação do método abstrato de

* Animal, e sim uma sobrecrita do método falar

* de Mamifero */

public void falar() { }

}

Observação₁: métodos abstratos não podem ser marcados como final, pois estes não podem ser sobrescritos por subclasses, e métodos final têm justamente função oposta de métodos abstratos (não serem sobrescritos).

Observação₂: métodos abstratos não podem ser também privados, pois estes não são vistos por outras classes.

Observação₃: um método abstrato também não poderá ser marcado como static.

Métodos sincronizados:

A palavra-chave synchronized indica que um método só pode ser acessado por uma thread de cada vez. Esse modificador só pode ser aplicado a métodos, e pode ser combinado com qualquer outro modificador de controle de acesso.

Métodos native:

O modificador native indica que um método está implementado em código dependente de plataforma, normalmente C. Esse modificador também só pode ser aplicado a métodos.

Assim como em métodos abstratos, métodos marcados como native não possuem corpo, portanto, deve terminar com ponto-e-vírgula no lugar de chaves, indicando que a implementação é omitida.

Métodos strictfp:

Mesmo a classe não sendo strictfp, pode-se declarar um método como strictfp. Esse modificador força pontos flutuantes (e qualquer operação de ponto flutuante) a aderir ao padrão IEEE 754. Uma variável não pode ser declarada como strictfp, somente classes e métodos.

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Modificadores de Acesso para Membros de Classes

2010-03-01T21:16:00.007-03:00

É possível aplicar modificadores a membros de classe, métodos e variáveis de instância (variáveis globais). Esses modificadores podem ser de acesso e não-acesso, da mesma forma que ocorre com as classes. Aqui iremos tratar dos modificadores de acesso.

Métodos e variáveis de instância são membros de classe e são tratados com modificadores de acesso da mesma maneira. Enquanto as classes só podem usar dois controles de acesso (default e public), membros de classe podem usar todos os quatro: default, public, protected, e private.

Existem duas questões de acesso diferentes: se uma classe pode acessar um membro de outra classe, e se uma subclasse pode herdar o membro de uma superclasse.

O primeiro tipo de acesso ocorre quando em uma classe um método instancia outra classe e tenta acessar métodos ou variáveis desta. O segundo tipo de acesso ocorre quando uma subclasse herda de uma superclasse e passa a ter acesso aos seus membros diretamente, ou seja, sem ter que instanciar a superclasse dentro de um método.

Membros públicos:

Quando um método ou variável de instância é declarado como public, significa que todas as outras classes, independente de pacote, podem acessar esse membro.

Membros privados:

Métodos e variáveis marcadas como private só podem ser acessados pela classe na qual foram declarados; outras classes não acessam membros privados nem por herança, nem por instância.

Membros protegidos e default:

Os controles de acesso protected e default são quase idênticos. Os dois só podem ser acessados por classes do mesmo pacote por meio da instanciação, com a diferença de que membros protected também podem ser acessados por classes de outros pacotes através de herança; ou seja, membros default e protected diferem apenas quando se trata de subclasses.

Mesmo que aconteça de uma classe conseguir instanciar uma outra classe que possua membros protegidos e esteja em um pacote diferente, ela não conseguirá acessar esses membros através da instanciação, apenas por herança (com a chamada explícita do método).

package geracao1;

public class Pai {

public String nome;

protected int cod;

private void ensinar() { }

protected void educar() { }

}

package geracao2;

import geracao1.Pai;

/* encontra-se em um pacote diferente da sua

* superclasse */

public class Filho extends Pai {

public void aprender() {

// membro público de Pai

String var = nome;

/* não possui acesso a esse membro default,

* pois estão em pacotes diferentes */

int codPai = cod;

/* não possui acesso a esse membro porque

* trata-se de um membro private de Pai */

ensinar();

/* consegue acessar esse membro protected

* de Pai por herança, apesar de estarem em

* pacotes diferentes */

educar();

Pai pai = new Pai();

/* não consegue acessar esse membro

* protected de Pai por instanciação porque

* estão em pacotes diferentes */

pai.educar();

}

Observação₁: modificadores de acesso não são aplicados a variáveis locais; de fato, apenas o modificador de não-acesso final pode ser aplicado a variáveis locais.

Fonte: SCJP Sun Certifi ed Programmer for Java 6 Study Guide

Declaração de Interface

2010-02-20T10:31:00.003-03:00

Uma interface define o que uma classe pode fazer sem dizer nada como a classe irá fazer. Qualquer classe que implementar uma interface deverá implementar os métodos definidos por ela.

Interfaces podem ser implementadas por qualquer classe, de qualquer árvore de herança. São classes 100% abstratas, contendo somente métodos abstratos (isso quer dizer que todos os métodos terminam com ponto-e-vírgula no lugar das chaves {} ).

Regras para declaração de interfaces:

· Todos os métodos são implicitamente public e abstract, ou seja, esses modificadores podem ser omitidos da declaração;

interface Automovel {

/* apesar de não ter modificadores, trata-se de

um método public e abstract */

void acelerar();

public abstract void reduzir();

/* todos os métodos sempre são public */

protected int getMarcha();

/* interfaces definem apenas métodos de

instância */

static void setMarcha();

/* final and abstract não podem ser usados

juntos, já que o abstract está implícito */

final void go();

}

· Todas as variáveis definidas em uma interface são necessariamente public, static e final, ou seja, interfaces não podem declarar variáveis de instância, somente constantes; esses modificadores também podem ser omitidos;

interface Pessoa {

/* constantes devem ser inicializada */

public static final int COD_PF = 1;

/* parece ser não-estática e não-pública,

mas é */

int COD_PJ = 2;

/* pode omitir os outros modificadores, já que

estão implícitos */

static int CONT = 0;

}

· Métodos de interface não podem ser static;

· Métodos de interface não podem ser final, strictfp ou native, pois são abstract;

· Uma interface pode herdar de uma ou mais interfaces;

· Uma interface só pode herdar de outras interfaces;

· Uma interface não pode implementar outra interface ou classe;

· Uma interface deve ser declarada com a palavra-chave interface; a palavra-chave abstract na declaração pode ser omitida, pois se torna redundante;

· Tipos de interfaces podem ser usadas polimorficamente.

Modificadores de Classes (Não Referentes à Acesso)

2010-01-30T10:28:00.003-03:00

No post anterior falamos dos modificadores de acesso a classes. Hoje iremos tratar dos modificadores de classes que não são referentes a acesso, os quais são: final, abstract e stricfp. Os três podem ser aplicados em adição aos controles de acesso. Por exemplo, é possível declarar uma classe como public e final.

Também é possível utilizar mais de um modificador não referente a acesso na mesma declaração. Por exemplo, é possível declarar uma classe como final e strictfp. Entretanto, existem algumas exceções, como por exemplo, não é possível declarar uma classe como final e abstract, já que possuem funções opostas, como veremos a seguir.

Modificador não referente a acesso final:

Uma declaração de classe com o modificador final significa que essa classe não pode ser herdada ou estendida por outra classe, e nenhum de seus métodos poderão ser sobrescritos.

Como citei anteriormente, a palavra-chave final pode ser combinada com qualquer modificador de acesso, ou seja, uma classe pode ter acesso default ou público e ser também marcada como final.

package bebida;

public final class Refrigerante { //púlica e final

}

package bebida.brasil;

import bebida.Refrigerante;

/* erro de compilação - a classe Coca não pode herdar

* de Refrigerante pq esta está marcada como final */

public class Coca extends Refrigerante {

}

Modificador de não-acesso abstract:

Uma classe declarada com o modificador abstract nunca poderá ser instanciada, sua função é ser herdada. Uma classe abstrata pode conter métodos abstratos e não abstratos.

Observação₁: se uma classe possuir um método abstrato, esta também deverá ser obrigatoriamente abstrata.

Observação₂: métodos abstratos não devem conter chaves { } no final da declaração, no lugar devem apresentar ponto-e-vírgula, pois não apresentam corpo de método.

Observação3: classes que herdarem de classes abstratas deverão implementar os métodos abstratos definidos na classe abstrata.

public abstract class Carro { /* abstrata - não pode

* ser instanciada */

int ano;

/* classes abstratas podem conter métodos

* não abstratos */

public void ligar() {

}

/* um único método abstrato declarado torna

* obrigatoriamente a classe abstrata - métodos

* abstratos não possuem corpo de método */

public abstract void acelerar();

}

public class Civic extends Carro {

public void acelerar() {

/* classes abstratas não podem ser

* instanciadas */

Carro carro = new Carro();

}

Modificador de não-acesso strictfp:

A palavra-chave strictfp pode ser usada para modificar uma classe ou método, mas nunca uma variável.

Uma classe com o modificador strictfp significa que seus membros devem seguir o padrão IEEE 754 para pontos flutuantes.

Modificadores e Níveis de Acesso a Classes

2010-01-19T07:29:00.009-03:00

Olá pessoal! Nosso primeiro assunto é um dos mais importantes na certificação SCJP.

Quem está iniciando em Java pode ficar um pouco confuso em relação a modificadores e níveis de acesso, mas nada que não possa ser resolvido. Então chega de conversa e vamos ao que interessa!

Os modificadores de acesso definem o escopo de visibilidade da classe, ou seja, servem para restringir ou permitir o acesso a uma classe. São três os modificadores de acesso: public, protected e private; porém, apenas o public é aplicado a classes.

Embora existam três modificadores de acesso, são quatro os níveis ou controles de acesso: público, protegido, privado e default; porém, apenas os acessos público e default são aplicados a classes.

Acesso significa visibilidade. Dessa forma, são três modificadores de acesso e quatro níveis de acesso; isso ocorre porque o nível de acesso default não possui um modificador.

Acesso default ou padrão:

Como já disse anteriormente, uma classe com acesso default não possui modificador na sua declaração. Por exemplo:

Esse é o chamado acesso em nível de pacote, pois classes com esse tipo de acesso só podem ser vistas (acessadas) por classes de dentro do mesmo pacote em que estão declaradas.

Por exemplo, se criarmos duas classes com acesso default e as colocarmos em pacotes diferentes, uma não poderá enxergar a outra; ou seja, uma classe não poderá herdar ou criar instâncias da outra classe, ou até mesmo declarar um retorno ou uma variável com o tipo da outra classe.

Acesso público:

Uma declaração de classe com a palavra-chave public caracteriza o acesso público, permitindo que todas as classes de todos os pacotes a vejam e acessem.

Por exemplo, se duas classes possuem acesso público, uma poderá criar instâncias, herdar, declarar uma variável ou um retorno com o tipo da outra classe, desde que utilize as notações de importação caso estejam em pacotes diferentes.

Exemplo de acessos default e público:

package bebida;

public class Bebida_alcoolica { // acesso público

/* erro de compilação - Bebida_alcoolica não tem

* acesso a classe Caipirinha porque estão em

* pacotes diferentes e Caipirinha possui acesso

* default */

Caipirinha c = new Caipirinha();

}

package bebida.brasil;

import bebida.Bebida_alcoolica;

class Caipirinha { // acesso default

/* possui acesso a classe Bebida_alcoolica,

* mesmo em pacotes diferentes, porque

* Bebida_alcoolica possui acesso público */

Bebida_alcoolica b = new Bebida_alcoolica();

}