| Autor |
Mensagem |
|
|
Bom dia,
Este tipo de estrutura chama-se "Bloco de Inicialização Estático"; isto é perfeitamente válido, e ele executa junto com a criação da classe. O que esta questão realmente trata é o "Sombreamento de Variáveis". Ela deseja se certificar que você realmente sabe que a variável "x" criada dentro do bloco de inicialização tem sua vida apenas dentro desse bloco, ou seja, ela não tem nenhum vínculo com a variável "x" criada na classe, e nem altera o valor desta.
Isto é muito bem tratado no livro da Kathy Sierra.
Espero ter ajudado!
Abraço.
|
 |
|
|
Boa tarde pessoal do Fórum; Vim relatar minha jornada para conquistar a SCJP 5 hoje. Vou falar como fiz, para que outras pessoas possam se guiar, caso estejam meio perdidas.
Primeiro um pouco da história:
Minha jornada de estudos começou no dia 22 de setembro de 2008, quando chegou o meu livro de SCJP da Kathy Sierra, SEGUNDA EDIÇÃO, em PORTUGUÊS - na empresa onde trabalho tem o livro em inglês, e posso garantir que é um mito dizer que a tradução é mal feita - assim como a prova, também. Estudei o livro com gosto, com muita determinação; gostei do livro (apesar de algumas pessoas o acharem chato), e ele aborda realmente 100% dos tópicos do exame. Lembre-se, se quiser realmente passar no exame, LEIA O LIVRO DA KATHY SIERRA E BERT BATES COM DETERMINAÇÃO E DEPOIS FAÇA MOCKS (simulados).
Marcando a prova:
Dentro de 15 dias terminei a primeira leitura do livro e já comecei a pensar em comprar um voucher - não demore muito pra fazer a prova quando estiver realmente estudando, por que você pode esquecer detalhes importantes - por um grande acaso, apareceu um, aqui mesmo neste fórum, que tinha data de expiração para 31 de dezembro de 2008. Não exitei, procurei detalhes sobre o vendedor, entrei em contato com ele e comprei - já que estava confiante e iria fazer a prova rapidamente. Marquei a prova no dia 18 de outubro de 2008, para hoje, segunda-feira, 17 de novembro de 2008 (um mês de antecedência). Tracei esta estratégia por que queria aperfeiçoar o que tinha estudado anteriormente, e um mês, pra mim já era o suficiente. Detalhe: Marquei a prova SCJP 5 em português mesmo (comentarei a seguir).
Revisando e se preparando realmente para o exame:
Com a prova marcada e com a primeira leitura do livro já feita (inclusive com a resolução de todos os exercícios de todos os capítulos - que são do mesmo nível da prova), partí para o estudo dos detalhes; a segunda leitura é bem mais clara, por que você consegue enxergar coisas que antes não conseguia. Passado esta parte, procurei memorizar os métodos da parte de decoreba (IO / Serialização / RegEx / Classes de Datas e Numeros - capítulos 5 e 6 do livro). É bom saber muito sobre estes, por que pode ter certeza que despencará isso na prova real.
Nos finalmentes
Revisei tudo o máximo possível e fiz alguns mocks, como o WhizLabs, TestKiller e o MasterExam. (Eles te abrem o olho para coisas que o livro fala, mas não mostra, portanto, é fundamental que faça mocks). Não fiquei quebrando muito a cabeça com eles, pois, eu queria aprender com eles, e não me importava caso errasse, por que depois revisaria a questão.
Dia do exame
Hoje, segunda-feira, 17 de novembro de 2008, foi o grande dia, passado-se 54 dias de preparação, é a hora da verdade... rrsrs... Marquei a prova em Ribeirão Preto - SP (minha região), na Center Cursos - pertinho do Ribeirão Shopping - , às 10:30 da manhã. (Lembre-se do detalhe que outras pessoas bem sucedidas na prova me deram, e vou repassar: marque a prova para um dia que não esteja cansado, no caso segunda-feira, num horário de manhã, pra começar com a cuca fresca). Cheguei lá meia hora antes (10 horas) e me apresentei. Saí um pouco pra tomar um ar e comer alguma coisa, que fiz alí pertinho do Ribeirão Shopping. Às 10:15 estava de volta e pronto para o exame, o qual, o fiscal prontamente pergutou: Quer começar já? e claro, topei prontamente. A barriga deu uma gelada, mas tinha chegado a hora. Fiquei numa salinha, com uma câmera, um computador e um ar condicionado, só. O fiscal te acompanha até a sala, conecta-se com o software do teste (que já tem todas as suas informações, online) te dá algumas orientações e sai da sala. Nisto, o tempo começa a ser cruel (pode ter certeza, passa bem rápido e a gente nem vê, rsrrs).
O Exame
* Tradução para o português:
Marquei o exame em portugês e posso garantir que a idéia de que o exame é mal traduzido é equivocada. O Exame é perfeitamente traduzido e entende-se tudo o que ele quer expressar (talvez você estranhe termos que conheça em inglês que são traduzidos para o português, mas isso não quer dizer que o exame é mal traduzido, ele apenas traduz coisas e gera termos nos quais não estamos acostumados). Resumindo: Se quiser fazer o exame em português, pode fazer, por que a tradução não atrapalha em nada quem está preparado - acho que até ajuda nas questões de drag-n´-drop.
* Questões de drag-n´-drop:
Estas questões são chatas pra caramba, a maioria é fácil, mas tem outras nas quais você sequer consegue entender o que elas querem que você faça. Mas não se preocupe muito, pois elas serão no máximo 10 questões no exame de 72. A correção destas questões realmente é complicada, por que o software do exame perde a resposta - SOMENTE DA QUESTÃO DRAG´N´DROP ATUAL, E NENHUMA OUTRA. Somente este é o problema.
* Questões Iniciais (Questionário de participação da Sun):
Iniciando a prova você deve responder 7 questões para SUN e concordar com um contrato de licença da certificação - Você tem 15 minutos para concluir esta etapa, e, segundo o livro da Kathy e documentação oficial da SUN, suas respostas NÃO INTERFEREM NA PROVA, porém, tem-se uma pressão psicológica e uma propensão a marcar "iniciante" em todas as questões, rsrsrs.
* Fazendo o exame
O objetivo da SUN realmente é enganar você, e ver até onde você pode chegar (e domina o assunto). A prova é totalmente objetiva, quando a questão pedir pra você selecionar APENAS UMA OPÇÃO, ISSO ESTARÁ EXPLÍCITO NA TELA, e quando for pra marcar mais opções, a PROVA TE INFORMARÁ QUANTAS QUESTÕES VOCÊ DEVE MARCAR. Resumindo: Você SEMPRE SABERÁ QUANTAS QUESTÕES TERÁ QUE MARCAR.
As questões são complicadas, e exigem realmente raciocíonio e domínio pleno do assunto, por que eles te lançam um problema (você acha que é um problema), porém, o problema está em outro lugar. Fiz todas as questões de forma calma e tranquila; sempre quando me deparava com algo que não conseguia resolver em 15 segundos (e as questões Drag n´ Drop), eu já as marcava para a revisão futura. Fui assim até terminar todas as 72 questões. O Exame te mostra um resumo com todas as questões incompletas, completas e marcadas para revisão. Você pode voltar e revisar as questões quantas vezes quiser (as drag n´ drop terão a resposta apagada, se você revisá-las). Depois de tudo pronto, existe um botão ("FIM") ou ("END"). Cliquei e.......... bom...... nada de resultado pra mim.... o resultado sai diretamente num realtório impresso na mesa do inspetor (que no caso da Center Cursos é no andar de baixo). Descí correndo e fui logo ver o meu resultado. Depois de um drama, ví que conseguí passar no exame, com um score de 90% (acertei 65 questões de 72). O relatório te mostra uma análise de seção, na qual suas notas são divididas por grupos, como Controle de Fluxo, Fundamentos, etc.
Resumo do Exame
Exame: Sun Certified Programer for the Java 2 Platform, Standard Edition 5
Data: 17 de novembro de 2008
Score: 90 % - PASS.
Bom pessoal, fica aí o meu relato sobre a prova que fiz hoje; conseguí um bom score e me sentiria culpado se não compartilhasse o que fiz com a comunidade. Nunca desista, quem tem medo de vencer já está vencido. Estudo e determinação é o segredo para SCJP.
Grande abraço,
Até,
Rodrigo Lopes,
Sun Certified Programer for the Java 2 Platform, Standard Edition 5
|
|
|
|
E aí Diego, blz ?
A explicação é muito simples:
Lembre-se:
Todas as exceptions derivadas de RuntimeException e ERROR, NÃO PRECISAM SER DECLARADAS, E O COMPILADOR NÃO SE IMPORTARÁ SE ASSIM VOCÊ O FIZER E NÃO SEGUIRÁ AS REGRAS DAS EXCEPTIONS CHECKED.
Pela explicação acima é que o código de cima COMPILA (por que usa ERROR) e o de baixo NÃO COMPILA (IOException e Exception NÃO SÃO DERIVADAS DE RUNTIMEEXCEPTION).
Espero ter ajudado !!
Abraço,
Rodrigo Lopes.
|
|
|
|
# package com.sun.masterexam;
#
# import java.util.Arrays;
# import java.util.Comparator;
#
# class Comp2{
# public static void main(String[] args){
# String[] words = {"Good","Bad","Ugly"};
# Comparator<String> best = new Comparator<String>(){
# public int compare(String s1,String s2){
# return s2.charAt(1) - s1.charAt(1);
# }
# };
# Arrays.sort(words,best);
# System.out.println(words[0]);
# }
E aí, blz ?
Essa pergunta é meio estranha mesmo, mas é que involve uma série de conceitos que precisamos entender.
Vamos tentar ver o que acontece :
Temos esse array:
Neste ponto, ele NÃO ESTÁ CLASSIFICADO, porém, queremos classificá-lo, e para isso, usaremos a interface java.util.Comparator (Estudar java.lang.Comparable e java.util.Comparator).
Neste método que sobrescrevemos é que está o segredo:
Se prestarmos bastante atenção, podemos ver que ele está comparando o SEGUNDO ARGUMENTO com o PRIMEIRO, ou seja, EM ORDEM INVERTIDA, e notamos também que o parâmetro de comparação é a SEGUNDA LETRA (índice de arrays começam pelo 0).
O produto desse processamento só pode ser um array ordenado inversamente.
(Precisamos saber que o ordenamento por odem natural seria Bad-Ugly-Good por que A vem antes de G e O vem depois de G).
Como comparamos ao contrário, basta inverter a ordem do array, que ficará assim:
Good-Ugly-Bad
Logo, quando exibirmos o primeiro elemento do array (0), então surgirá a string "Good".
Essa parte precisa ser estudada com muita atenção e de um tempinho para cair a ficha.
Espero ter ajudado !
Grando abraço,
Até Logo,
Rodrigo Lopes.
|
|
|
|
E aí Jefferson, blzera ?
É o seguinte, a resposta correta realmente é a C .
Generics é algo muito doido, que, às vezes, parece fugir da lógica do Java, em sí; porém, a explicação é a seguinte:
quando você usa o coringa <? extends CLASSE>, VOCÊ NÃO PODE ADICIONAR NADA AO CONJUNTO.
quando você usa o coringa <? super CLASSE> VOCÊ PODE ADICIONAR ALGO AO CONJUNTO.
Quanto ao termo "extends" nesse caso, ele serve para A PRÓPRIA CLASSE ou CLASSES QUE A ESTENDAM, ou seja, NADA PODE ESTENDER STRING, mas, STRING É UMA STRING, por isso, ele é aceitável e o compilador ACEITARÁ O TERMO SEM PROBLEMAS.
Espero ter ajudado !
Grande abraço,
Até,
Rodrigo Lopes.
|
|
|
|
Oi, tudo beleza ?
Vamos ver se conseguimos resolver algumas questões 
---------------------------------------------------------------------------------------------------------
Questão 1:
---------------------------------------------------------------------------------------------------------
A alternativa correta é a letra D ;
Exatamente 4 opções compilam.
Explicação:
Todas as declarações EXCETO "%" irão compilar normalmente. O método ESTÁTICO Integer.getInteger(String) retornar um Integer (que, neste caso será automaticamente feito UnBoxing para um int primitivo).
---------------------------------------------------------------------------------------------------------
Questão 2:
---------------------------------------------------------------------------------------------------------
O primeiro if escreve "passo1", muda o valor de "y" para "true" e incrementa a variável "z", que passa a ter o valor de "43".
O segundo if escreve "passo2" e incrementa "z", que PASSA A SER 44.
A instrução "System.out.println" escreverá "z = 44".
Chave da história:
O SEGUNDO IF USA UM OPERADOR DE CURTO-CIRCUITO "||" (OU), ou seja, SE A PRIMEIRA CONDIÇÃO FOR SATISFEITA (for true, o que realmente é), A SEGUNDA EXPRESSÃO NÃO SERÁ ANALIZADA/EFETUADA, portanto, "z" NÃO SERÁ INCREMENTADO.
---------------------------------------------------------------------------------------------------------
Questão 3:
---------------------------------------------------------------------------------------------------------
Essa é uma questão um pouco subjetiva, pois cada pessoa entende isso de uma maneira. Porém, preste bastante atenção na palavra APROPRIADA e não VÁLIDA; resumindo, TODAS AS EXPRESSÕES SERÃO COMPILADAS, PORÉM, EM ALGUNS CASOS SUA UTILIZAÇÃO NÃO É RECOMENDADA PELA SUN.
Creio que TODAS AS EXPRESSÕES estejam sendo usadas de forma INAPROPRIADA, pois, não DEVEMOS USAR ASSERTIONS EM MÉTODOS PÚBLICOS, por que não sabemos sequer de onde virá a chamada ao nosso método. A expressão assert no método estático doStuff(int args) ESTÁ SENDO USADA PARA DESVIAR O FLUXO DO PROGRAMA, e isso NÃO É RECOMENDADO, pois, para que essas assertivas sejas executadas, você precisa compilar o código e executá-lo com essa opção ativada, o que não pode ser totalmente garantido, e, por questões óbvias, essa prática não é recomendada pela SUN. A terceira expressão está sendo usada em um lugar no qual o sistema JAMAIS DEVERIA CHEGAR, portanto, deve-se alterar a lógica do sistema e não forçar um AssertionError (o que irá acontecer caso o fluxo chegue neste ponto).
Resumindo:
As assertivas devem ser usadas SOMENTE EM MODO DE TESTES e nunca em AMBIENTE DE PRODUÇÃO. As assertivas não devem ser usadas como modificadoras de fluxo, pois sua execução só será efetuada caso o sistema esteja rodando com essa opção ativada, o que, não pode ser garantido; e, finalmente, AS ASSERTIVAS NÃO DEVEM SER USADAS EM MÉTODOS PUBLIC.
A opção correta, na minha opinião é a opção "A" (A None of the assert statements are appropriate.)
---------------------------------------------------------------------------------------------------------
Questão 4:
---------------------------------------------------------------------------------------------------------
Você não postou quais foram as opções.
Neste caso, qualquer coisa que esteja em algum local no qual o compilador tenha certeza que o fluxo do programa JAMAIS CHEGARÁ (depois do lançamento de uma EXCEPTION, por exemplo), ele não deixará que o seu código seja compilado, apontando claramente o local do erro e dizendo algo como : "Essa instrução jamais será executada, portanto, tira isso do código por que eu já tenho muita coisa pra transformar em ByteCode"
---------------------------------------------------------------------------------------------------------
Questão 5:
---------------------------------------------------------------------------------------------------------
A opção correta é:
C w can be of type PrintWriter, but NOT of type BufferedWriter.
Somente a classe PrintWriter tem o método print, logo, todas as outras opções são inválidas.
---------------------------------------------------------------------------------------------------------
Questão 6:
---------------------------------------------------------------------------------------------------------
A opção correta é:
A new Car
Essa questão de serialização é um pouco complicada, você precisa estudar mais pra se adapatar as conceitos. Vou tentar explicar o que acontece:
A classe Ford estende Car e implementa Serializable (A interface Serializable serve apenas pra dizer: Quando você des-serializar essa classe, por favor, NÃO EXECUTE O CONSTRUTOR DELA NOVAMENTE, ok). Então, como marcamos Ford como Serializable, o construtor dela NÃO SERÁ EXECUTADO QUANDO ELA FOR DES-SERIALIZADA, só que, a classe Car (a qual a estendemos) NÃO IMPLEMENTA Serializable, logo, o CONSTRUTOR DA SUPER CLASSE SERÁ EXECUTADO, produzindo a saída acima.
---------------------------------------------------------------------------------------------------------
Essas questões estão diretamente relacionadas a vários objetivos do exame, os quais devemos estudar a fundo, pois um conceito depende do outro pra ser bem compreendido.
---------------------------------------------------------------------------------------------------------
Espero ter ajudado !!!
Grande abraço,
Até,
Rodrigo Lopes.
|
|
|
|
Exatamente.
Quando usamos NÚMEROS LITERAIS (DIGITADOS "NA UNHA"), rrsrs... o compilador consegue ver se o número CABE na variável, ou seja:
byte b = 100; // Ok - 100 é menor que 127, portanto não precisa de Cast,
Só que, se eu fizesse isso:
byte b = 3550; // Não vai compilar, CAST EXPLÍCITO é necessário por que 3550 é maior que 127, portanto o compilador sabe que haverá uma possível perda de precisão e deve te alertar sobre isso.
Quando usamos variáveis, o compilador (em tempo de compilação, claro) NÃO TEM CONDIÇÕES DE SABER O VALOR DA VARIÁVEL, portanto ELE SEMPRE VAI LHE SOLICITAR CAST.
A mesma regra se aplica a todos os outros tipos primitivos.
Grande abraço,
Rodrigo.
|
|
|
|
-------------------------------------------------------------------------------------------------------------------------------------
Analize bem:
-------------------------------------------------------------------------------------------------------------------------------------
public class Ex21 {
private int number;
public Ex21 (int i){
number=i;
}
public int hashCode(){
int i=(int)(Math.random()*100);
return i*number;
}
//others methods
}
Este método implementa HashCode INCORRETAMENTE, por que estamos usando UM NÚMERO ALEATÓRIO, ou seja, os DADOS QUE DEVERIAM SER AGRUPADOS DE ACORDO COM ALGUMA CARACTERÍSTICA SIMILAR ENTRE SÍ, estarão sendo classificados de forma aleatória, ou seja, de uma forma totalmente ineficáz.
Para resolver este problema precisaríamos remover a utilização do código aleatório, e utilizarmos um código fixo para que, suponhamos, pessoas que tenham o nome com 5 letras, fiquem agrupadas no mesmo lugar, enquanto as que possuam 6, em outro... etc...
-------------------------------------------------------------------------------------------------------------------------------------
No caso de StringBuilder (INSERIDA NO JAVA 5), é CORRETO afirmar:
b) It is faster than StringBuffer (mais rápida que StringBuffer - NÃO É THREAD SAFE)
c) It defines the append and insert methods
-- INCORRETAS --
A está incorreta por que StringBuilder não possui proteção entre threads (sincronização/thread safe).
D StringBulder difere-se da classe String, pois não possui pool, e É MUTÁVEL, ao contrário do que diz a opção.
-------------------------------------------------------------------------------------------------------------------------------------
Sua implementação de Scanner aparentemente está correta, e deve exibir todo o texto que esteja depois do delimitador "." até o final do arquivo ser alcançado.
-------------------------------------------------------------------------------------------------------------------------------------
Sua questão sobre switch:
No Exemplo 1:
-----------------
A palavra reservada "return" irá retornar o objeto "String" e vai interromper o fluxo do switch alí mesmo.
No Exemplo 2:
-----------------
A declaração do Enum provavelmente NÃO IRÁ COMPILAR, por que, diz a lenda que quando é colocado um corpo no Enum (A {public...}), deve-se OBRIGATÓRIAMENTE ao final do Enum, USAR O PONTO E VÍRGULA (
Algo correto seria:
enum Grade{A{public String toString(){return "Book";}},B,C,D}; // Observe o Ponto e Vírgula no final
Se isso for consertado, o restante do código aparenta estar correto, seguindo a regra da "Passagem Completa" de switch, onde serão executadas todas as condições do switch, a partir da primeira condição satisfeita até que uma palavra reservada "break" seja encontrada. Caso isso não ocorra, todas as condições do switch serão executadas, até o seu fim.
--------------------------------------------------------------------------------------
No meu ponto de vista, essa questão está meio confusa, pois java.util.Set É UMA INTERFACE e NÃO UMA IMPLEMENTAÇÃO. Logo, algumas opções se referem a ela como se fosse uma classe de impelentação. Como a questão nos pede 3 respostas, vamos tentar:
which of the following statements regarding the java.util.Set interface are true?
seelct any 3 options :
CORRETAS:
a) java.util.Set extends the java.util.Collection interface (Sim, java.util.Set ESTENDE java.util.Collection - Ambas são interfaces)
b) java.util.Set maintains a set of key-value pairs (Sim, os Set´s determinam que existam pares de Chave/Valor - O VALOR NÃO PODE SE REPETIR)
c) java.util.Set does not allow duplicate elements. (Sim, os Set´s NÃO PERMITEM QUE OS VALORES SE REPITAM)
INCORRETAS:
d) java.util.Set maintains its elements in a sorted order. -> java.util.Set é UMA INTERFACE E NÃO UMA CLASSE DE IMPLEMENTAÇÃO, portanto, ELA NÃO MANTÉM NADA. Essa tarefa de manter seus dados ordenados(interface Comparable) ou classificados(interface Comparator) é de responsabilidade das classes de implementação (java.util.HashSet, java.util.LinkedHashSet e java.util.TreeSet).
e) All methods definded in java.util.Set are also define in java.util.Collection -> Se fosse o inverso estaria correto. Podemos AFIRMAR COM CERTEZA que todos os métodos públicos definidos em java.util.Collection estarão implementados em java.util.Set, porém, NÃO PODEMOS AFIRMAR O MESMO AO CONTRÁRIO, pois, java.util.Set tem métodos mais específicos do que java.util.Collection. Para usar isso, precisamos usar a operação de redução, que não se aplica a essa questão.
f) java.util.Set does not allow a null element -> Novamente, java.util.Set É UMA INTERFACE E NÃO UMA CLASSE DE IMPLEMENTAÇÃO. Funções específicas como ordenação/classificação e permissão de valores null ou não SÃO DE RESPONSABILIDADE DAS CLASSES DE IMPLEMENTAÇÃO (java.util.HashSet, java.util.LinkedHashSet e java.util.TreeSet).
--------------------------------------------------------------------------------------
Espero ter ajudado !!
Grande abraço !
Rodrigo Lopes.
|
|
|
|
Esquecí de modificar o nome da classe, do jeito que estava o generics não seria compatível, mas este sim:
Abraço!
Rodrigo.
|
|
|
|
Cara, o problema no Código de Generics é o seguinte:
public static void add(List<? extends Shape2> l,int pos ,Rect r){
l.add(pos,new Shape2());
}
Pela regra de Generics, quando você utilizar o termo "? extends Classe", você está dizendo ao compilador QUE JAMAIS MODIFICARÁ O CONTEÚDO DO CONJUNTO, apenas utilizará, SEM FAZER NENHUMA ALTERAÇÃO; logo, quando você invoca o método "add", você está tentando adicionar algo ao conjunto tipado, o que, adivinha : Vai causar um belo erro de compilação.
Para consertar esse trecho de forma que ele compile (e funcione) corretamente, você deve usar o termo "super", ou seja, a partir dele e todas as suas classes pais, mais nunca suas classes filhas (derivadas).
Experimente consertar para isso:
public static void add(List<? super Shape2> l,int pos ,Rect r){
l.add(pos,new Shape2());
}
No caso das assertivas, o seu código está correto, só que, muito provavelmente você não está executando o seu código com as assertivas ativadas ( que é exatamente da forma como você descreveu "java -ea NomeDaClasse".
Talvez o seu IDE não esteja configurado corretamente para executar codigo com assertivas; experimente fazer via linha de comando mesmo
Espero ter ajudado !
Grande abraço !
Rodrigo.
|
|
|
|
Mais uma dica pra complementar a dica do colega:
<?> // pode ser tudo que herde de Object alem de Object
(Qualquer tentativa de adicionar algo ao conjunto causará erro de compilação)
<T> // Somente T
(Pode adicionar algo ao conjunto)
<? super Animal> // somente Animal ou uma superclasse
(Pode adicionar algo ao conjunto)
<? extends Animal> // qualquer subclasse de Animal inclusive Animal
(Qualquer tentativa de adicionar algo ao conjunto causará erro de compilação)
Resumindo: Você conseguirá compilar nos casos do coringa(?) e de (? extends) SE, E SOMENTE SE, NÃO FOR ADICIONADO AO CONJUNTO. Nos outros casos pode, por que será o próprio tipo ou algo superior a ele.
Genérics tem "milhares" de regrinhas... tem que praticar bastante
Abraço.
|
|
|
|
Fábio, eu tenho enteresse no seu Voucher.
Te mandei um e-mail, por favor, responda-o.
Abraço,
Rodrigo Ferreira.
|
|
|
|
Exatamente... cada construtor precisa chamar o construtor da sua super classe, até chegar na classe Object (aonde a herança acaba). Se isso não acontecer (você pode testar tentando chamar um construtor e outro, recursivamente), haverá um erro em tempo de exeução (StackOverflowError), pois o restante do código do construtor filho não será executado até que todos os seus super-construtores tenham terminado sua execução.
Até.
|
|
|
|
Cara, beleza ?
Você está tentando chamar um método de uma referência de objeto "null". Procure por variáveis que você ainda não criou o objeto. Posta o código ae pra gente te ajudar, por que, sem ver fica difícil de te falar aonde está o problema.
Inté.
|
|
|
|
Boa Tarde, blz ?
Para que você chame uma servlet e ela faça algum processamento e depois retorne os dados processados para a mesma página que a chamou, você deve usar "request.setAttribute(String, Object)" para gravar os dados no Atributo do Request e depois o "(Casting)request.getAttribute(String)" no JSP para obter o resultado. Segue um exemplo:
-----------------------------------
Código teste.jsp:
-----------------------------------
-----------------------------------
Código minhaServlet.java:
-----------------------------------
-------------------------------------------------------
Este exemplo ilustra a essência do negócio.
-------------------------------------------------------
Sugiro que estude JAVA WEB e frameworks como o Struts e JSF, que facilitam e centralizam bastante esse tipo de operação.
Grande abraço !!!
Até,
Rodrigo Ferreira.
|
|
|
|
|
|