Categoria: Java

Olá Pessoal! Hoje vou falar sobre uma técnica que alguns conhecem  apenas teoricamente, uns usam constantemente e outros que nunca ouviram falar. A  nova série do blog é Refactoring. Ops!O que é  isso?  

Refactoring é o modo de você mudar a estrutura interna de seu software sem alterar seu comportamento observável. Você usa essa técnica quando você quer melhorar a legibilidade do código do software. Mas vale lembrar que Refactoring não usada para consertar erros e sim para prevenção. Com ou sem Refactoring seu software deve funcionar da mesma forma de antes ter aplicado a técnica.

 Nem todos os programadores conhecem  ou sabem aplicar a técnica refactoring, devo confessar que não conhecia a técnica antes de novembro/2007. Mas após uma discussão com um amigo sobre o assunto me interessei sobre o tema, dei inicio aos estudos que virou tema de minha monografia e que passou ser uma pratica constante no desenvolvimento de software. Tornou-se uma mania ao ver um código bagunçado e refatorá-lo. Vale salientar que não sou um experts na técnica me considero um mero estudante e curioso com a técnica. 

Espero que gostem da série Refactoring e que ela venha contribuir no seu ambiente de desenvolvimento de software. 
Let’s GO…

Summary

This article presents the technical of refactoring. Refactoring is one process of the restructure the system without changes your operation. Second Fowler (2004) refactoring into the software more easy of understand and change. One user or a programmer not is capable of say that something changed in the software. The technical of the refactoring help in the legible of code. For Fowler the refactoring is one element-key in process of the developing of software.

Sites/Livros:

http://www.refactoring.com

Livro Fowler

Introdução

Algumas profissionais de T.I acreditam que desenvolver um software é sentar na frente do computador e sair codificando. Já alguns acreditam que desenvolver software deve seguir o mesmo processo de linha de montagem de carro como  no filme tempos modernos.

Mas  bons desenvolvedores de software sabem que esse não  é o caminho correto. Desenvolver software requer planejamento e esse pode ser alterado de acordo com o ciclo de vida do software então o ambiente de desenvolvimento não é algo estático. Quando nasce um novo requisito uma parte do projeto ou todo o projeto passa a sofrer alterações e para executar esses novos requisitos é necessário planejar. Senão você desenvolvedor pode entrar em buraco sem saída com o software.

Para não entramos nesse “buraco” temos a refatoração que vem auxiliar no aperfeiçoamento do código-fonte minimizando as chances de novas falhas serem introduzidas no projeto. Refactoring contribuir para processo evolutivo do software, pois as técnicas de refatoração quando aplicada  de forma correta ao software aumenta consideravelmente seu tempo de vida útil, sua extensibilidade e modularidade.

Definição

Refatoração é o processo de reestruturar o sistema sem alterar suas funcionalidades. Mas Fowler (2004) vai um pouco mais além. Segundo este autor refatoração torna o Software mais fácil de entender e modificar. Para ele, apenas as mudanças feitas para tornar o Software mais fácil de entender são consideradas refatoração. A refatoração não altera o comportamento observável do Software. Esse ainda executa a mesma função de antes. Qualquer usuário seja ele final ou programador não é capaz de dizer que algo mudou.

Fowler defende que a refatoração é um elemento-chave no processo de inteiro desenvolvimento de software. O autor vai além e afirma que um bom projeto vem antes mesmo de sua codificação. Desenvolver software requer planejamento. É importante dizer que  refatorar é um “alicate de prata” que ajuda a manter o código seguro, porém a técnica de refatoração não cura todos os problemas no desenvolvimento de Software, mas é uma ferramenta valiosa.

Refatoramos para:

– Melhorar o projeto do Software: um projeto sem refatoração termina por se deteriorar à medida que as pessoas alteram o código e sem uma compreensão total do projeto, do código, acaba desestruturando. A refatoração é uma forma para estruturar o código;

– Tornar o Software mais fácil de entender a nível de código eliminado códigos duplicados;

– Encontrar falhas rapidamente, a partir do melhoramento do código;

– Programar mais rapidamente;         

Quando Refatorar

Para Fowler (2004) decidir quando começar a refatorar e quando  parar é tão importante quanto à mecânica de refatoração. Explicar como apagar uma variável de instancia ou criar uma hierarquia é questões simples, porém tentar explicar quando deve fazer, não é algo tão consolidado. Em seu livro Fowler apresenta os problemas que podem ser resolvidos por uma refatoração, mas cabe ao analista de sistemas, programador, desenvolvedor a própria percepção sobre quantas variáveis de instâncias são demais, quantas linhas de código em um método são excessivos.  Abaixo vou apresentar algumas das dicas que considerei importantes citadas Kent Beck um dos criadores da Programação Extrema (Extreme Programming – XP), afirma que refatoração deve ser utilizada quando o “código cheira mal” (do inglês “bad smells in code”).

A refatoração deve acontecer quando…

Código duplicado: Quando tem o mesmo código em mais de um lugar, dificultando a manutenção e aumentando o numero de falhas durante a manutenção do Software.

Método longo: Quando um método tem muito código. Quanto maior for o método, mais difícil é entendê-lo.

Classes grandes: Quando uma classe tem muita coisa a fazer, normalmente há existência de muitas variáveis de instâncias.

Comando switch: Os comandos switch essencialmente levam a duplicação. É comum encontrar o mesmo comando switch espalhado por diversos lugares do mesmo programa.

Comentários: Os comentários nos conduzem ao código ruim. Comentários que estão no código sem explicar o porquê, são considerados supérfluos.

Nesse momento você pode estar se perguntado: “Tudo bem vi quando refatorar  e  onde a técnica pode contribuir para meu software, mais o por que de  fazer tudo isso?”

Veja…

Segundo Maia (2004) o custo e a complexidade de se manter um Software são amplamente reconhecidos. Estima-se que cerca de 50% do tempo de um engenheiro de Software é gasto com tarefas de manutenção e compreensão de código e que ao longo das últimas três décadas mais de 60% dos custos de desenvolvimento de Software das organizações foram gastos com manutenção. Refatoração é o processo de mudar um Software de tal forma que melhore a estrutura interna sem, contudo alterar o comportamento externo. Portanto, é uma forma disciplinada de re-organizar o código, minimizando as chances de introduzir erros. Refatorar tem a vantagem de melhorar a estrutura do código, facilitando o reuso e diminuindo o tempo gasto com tarefas de manutenção. O termo refatoração é aplicado a sistemas orientados a objetos; para outros paradigmas de programação esse mesmo processo é descrito como reestruturação.

Percebeu o por quê?

Bom pessoal! Vou ficando por aqui, o assunto Refactoring é um pouco extenso e não pretendo abordar todo em um único post para não ficar cansativo. No próximo mostrarei mais sobre Refactoring  falando sobre as vantagens /desvantagens e as ferramentas  disponíveis.

Um abraço a todos!

Referencias:

Fowler

Maia, P. H. (2004). REFAX:Um arcabouço para desenvolvimento de ferramamentas de refatoração baseado XML. Programa de Pós Graduação em Ciência da Computação . Ceará, Fortaleza: UFC

Salve!Salve! Mais uma semana e estou aqui  com mais uma série Revisão SCJP. Conforme falei na semana passada, hoje o assunto é: polimorfismo e genéricos  onde veremos como eles trabalham juntos e  as diferenças em relação ao uso  de polimorfismo com array sendo assim é importante você programador Java saber essas diferenças. Somente um detalhe não esquecer que  genéricos está apenas a partir do Java 1.5.

Aproveitando, venho informá-los  que essa será a ultima coluna da serie Revisão SCJP, na próxima coluna abordarei outros assuntos, mas não precisa fazer essa cara de triste por que a série revisão SCJP voltará de vez em quando basta acompanhar o blog! O motivo é para não ficarmos abordando um único assunto.

Let’s go  fight!

Pré-Requisito

– Instalação Java 1.5/superior

– Revisão SCJP  Genérico/Generics

Summary

This article presents as use polymorphism and generics. The use polymorphism with generics there is one big different when use polymorphism and array. You cannot create one collection as below:

List<Animal> l = new ArrayList<Dog>();

Same that Dog extends Animal you cannot do this in collections. Because is permit only create collection of same type. However, you can add one object of other type as long as this object extends the class of the type of your collection. See below:

class Animal{}

class Dog extends Animal{}

ArrayList<Animal> la = new ArrayList<Animal>();

la.add(new Animal());

la.add(new Dog());

This code compiles and execute because you have one collection of the same type and add one object that extends the type of collection.  Is very important that you have attention with question about polymorphism and generics in the exam because they can to get you confuse. In the end this article there is one link for download of the one list with several example of generics and polymorphism do download this list, analysis the code and after test each example.

Polimorfismo e Genéricos

Ao usar polimorfismo com genéricos é importante ter bastante atenção e “esquecer” temporariamente a regra que  é aplicada a um Array. Por exemplo:

Posso ter um Animal[] array, que pode aceitar qualquer tipo ou subtipo de Animal, mas em Conjuntos a coisa é diferente isso não funciona. Veja:

import java.util.ArrayList;

import java.util.List;

class Animal{}

class Dog extends Animal{}

class Poli{

public static void main(String agrs[]){

List<Animal> l = new ArrayList<Dog>();

l.add(new Animal());

l.add(new Dog());

}}

 Esse código não compila. Mas por quê?

Por que  você está tentando criar um conjunto que aceita tipos diferentes onde deveria ser de um único tipo. É normal você achar que deveria compilar já que Dog extends Animal, caso isso fosse um array de Animal não haveria problema algum mais  quando se trata de conjuntos o polimorfismo opera diferente. 

Eu costumo dar um exemplo bem pratico veja:

“Se você compra uma caixa de maçã(É-UM Fruta) e levar berinjela(É-UM Fruta) dentro dela, será que você ficaria furioso quando abrisse a caixa? Então o compilador(feirante) ele evitar esse transtorno (ao cliente) permitindo que dentro da caixa de maça fique apenas maçã, mais nenhuma fruta.”

import java.util.ArrayList;

import java.util.List; 

class Animal{}

class Dog extends Animal{} 

class Poli{

public static void main(String agrs[]){

Poli p = new Poli();

ArrayList<Animal> la = new ArrayList<Animal> ();

la.add(new Animal());

la.add(new Dog()); //aceita porque  Dog extends Animal

}} 

Coringa <?>

O uso do coringa permite receber qualquer tipo. Quando usa o coringa e extends estamos dizendo que é permitido receber qualquer  class que é subtipo daquela class ou uma interface que implementa aquela classe. Mas você não pode adicionar nada ao conjunto. Veja o que não compila:

import java.util.*;

class Carta{}

class Coringa extends Carta{}

class Jogo{

public void cha(List<? extends Carta> car){

car.add(new Carta());          } 

public static void main(String [] agrs){

Jogo j = new Jogo();

List<Carta> list = new ArrayList<Carta>();

list.add(new Carta());

j.cha(list);

}} 

Não compila porque usei < ? > sendo assim estou dizendo ao compilador que pode receber um conjunto de qualquer subtipo, porém JAMAIS adicioná-lo ao conjunto, nem que seja do mesmo tipo. 

Basta alterar essa parte do código para compilar veja:

public void cha(List<? extends Carta> car){

/* observe que não foi adicionado nada a minha lista*/ 

<? super tipo> 

Como temos o extends temos também uma palavra chave super para a notação <?> o qual permite que você adicionar ao conjunto apenas o que está acima daquele tipo.

import java.util.*;

class Carnaval{}

class Banda extends Carnaval{}

class Bloco extends Banda{}

class Chi{ 

public void carna(List<? super Banda> band){

band.add(new Banda());

band.add(new Bloco());} 

public static void main(String [] agr){

Chi ch = new Chi();

List<Carnaval> lis = new ArrayList<Carnaval>();

ch.carna(lis);}} 

Observe que meu método aceita qualquer tipo acima de Banda, porém não posso passar  Bloco porque eu informei que seria super e nao extends a Banda. 

Outro o ponto a observar aqui é que meu método aceitou  um argumento do tipo diferente. 

Está confuso? Experimente fazer essa alteração: 

List<Bloco> lis = new ArrayList<Bloco>();

E veja que o código não compila. Já que o método diz que não é permitido receber nada que não for super a Banda.

<?> – Qualquer Tipo: Permite receber qualquer tipo dog, cat, etc. Porém não posso adicionar(add) nada ao conjunto. 

import java.util.*;

class QuaCor{

public void ch(List<?> li){//nada de adicionar algo aqui} 

public static void main(String agr[]){QuaCor qc = new QuaCor();

List<Integer> li = new ArrayList<Integer>();

List<QuaCor> list = new ArrayList<QuaCor>();

qc.ch(li);

qc.ch(list);}}

Onde não posso usar coringas: 

Na  criação dos objetos: List<?> f = new ArrayList<? extends Animal>(); 

Usar coringas ? apenas:  Argumentos ,variáveis e tipos de retornos. 

List<? extends Animal> li = new ArrayList<Dog>(); 

ArrayList<?> list = new ArrayList(); 

ArrayList<? extends Girafa> g = new ArrayList<Gir>();

//não posso add nada aqui g.add(new Gir()); não compila

<Object>(aceita apenas Object) é diferente de <?> (aceita qualquer coisa). 

Quando você usa <?> pode receber qualquer tipo mais quando usa Object pode receber apenas Object se usar <? extends Object> pode ser qualquer tipo: Dog, Cat, Integer. Porém sem adicionar ao conjunto. 

Bom pessoal! Espero que tenha gostado da coluna e aprendido um pouco como funciona o polimorfismo com genéricos, no inicio acontece uma pequena revolução no cérebro já que com array o uso do polimorfismo é bem mais fácil. Mas com genéricos não é difícil a questão é se acostumar e ficar atento as regras e lembrar que o segredo de genéricos está no tipo do conjunto. No link abaixo deixei uma lista de classes  para você ficar ligado nas pegadinhas para o exame e erros que você pode cometer ao desenvolver uma aplicação usando genéricos e polimorfismo.

Um abraço e até a próxima!
Download – lista de classes

 

 

 

 

 

 

 

Salve! Salve! Pessoal! Hoje vou falar Assert – Assertions. Quem está estudando para certificação ou java 1.5 / superior , em algum capitulo vai se deparar com a tecnica de assert. Mas a questão que ja vi  é: Para que serve mesmo? Parece que é igual ao comando if/else. Não consigo entender…
Bom vou buscar nesse post explicar um pouco da tecnica com base no livro Certificação Java – exame 310-055 – da kathy.

let’s go…

 A partir da vesão 1.4, o recurso de assertivas (assert) permitirão que você teste suposições durante o desenvolvimento sem o desgaste de escrever manipuladores para exceções que se supõe nunca ocorrerão, uma vez que o programa tiver saído da fase de desenvolvimento e for totalmente distribuído.

Se você não quer perder tempo ou trazer impacto ao desempenho do programa escrevendo um código de manipulação de exceções ou não deseja teste IF/else já que se chegar a condição else, significa que a lógica anterior falhou então  as assertivas permite que você teste suas suposições durante a fase de desenvolvimento.

 

Assertivas funcionam de maneira bem simples sempre que você quer ter certeza que o valor testado jamais pode vai ser falso caso contrario m erro  AssertionError (que não é possível manipular) é lançado.

assert (boolean) : string;

Entre (  ) sempre terá que ser um valor booleano e true, caso contrario uma exceção é lançada (AssertionError).

Por padrão assert vem desabilitado para desfrutar do recurso é necessário ativá-lo.

1.Compilando

javac  -source 1.5 classe.java

2.Habilita

java –ea classe

ou

java –enableAssertion minhaclss

3.Desabilita

java –de classe

ou

java –disableAssertion classe

Regras de uso Assert:

-Assertion não pode ser usado no lugar do IF

-Assertion não pode testar métodos públicos ou argumento digitado pelo usuário

-Não pode apresentar efeitos colaterais* no programa. Ou seja, o seu programa deve rodar tanto com ele habilitado ou não.

 Usar assertivas capazes de causar efeitos colaterais pode levar a alguns dos bugs mais enlouquecedores e difíceis de encontrar (Kathy Sierra, 2006)

Não é objetivo de assertivas substituir o uso IF/ELSE, tratamentos de exceções. O uso de assertivas é no ambiente de desenvolvimento (debug) e não distribuição.

Na prática:

class Asert{

      private static void setD(int z){

            boolean b=true;

            assert(z>0):” alguém alterou o valor da linha 3 “;

            assert(b=false);

            System.out.println(z);

      }

      public static void main(String args[]){

            setD(1);

      }}

………………

class Assert{

      //usando assertivas    

      public static void main(String args[]){       

            int taxajuros=4;

            assert(taxajuros==2):“algum programador mudou o valor da int taxajuros na linha 6”;

            System.out.println(true);

      }}

Agora basta compilar com assert, e ativar em tempo de execução! E verificar a essência desse recurso.

Eu mesmo tenho habito de usar assertivas, acho uma boa pratica de programação. Espero que tenham gostado e até a próxima!!

Salve!Salve! Mais uma semana, e mais um dia de blog! Hoje venho falar, sobre qual xícara tomar? Qual rumo vale apena arriscar.
Claro que o exposto aqui vai ter ser adaptado para cada região/estado/cidade. Mas o que quero transmitir é que um profissional de T.I deve saber qual xícara tomar de acordo com o momento (ambiente). Espero que o artigo venha contribuir diretamente/indiretamente em sua carreira/estudos.

let’s go…

O primeiro caminho antes do JSE, JME, JEE normalmente é esse. Após ter passado por ele, você está livre a escolhe a área que deseja atuar. Porém para uns não é uma tarefa fácil. E realmente não pode ser, vá que a escolha seja em longo prazo? E você não precisa de algo para longo prazo e sim curto ou médio. Então qual será a xícara?

Um ponto importante é analisar o mercado onde pretende atuar, qual é a real demanda? O que as consultorias RH daquela região buscam? Que tipo de tecnologia é auge (JME, JSE, JEE)?.

“antes de querer ir caçar com uma pistola, é bom saber que tipo de bicho pode encontrar por lá.”

Em síntese: por que caçaria dinossauro com uma pistola? Por que estudaria JME agora se na região que pretendo trabalhar está rolando altas vagas para JEE e quase não tem vaga para JME?

Hoje temos vários sites de empregos uns bastante conceituados, onde é possível encontrar tudo que precisa saber como:

– o que estudar?

– qual xícara tomar?

No Brasil a maior xícara é JEE, a demanda por JSE é muito pequena, já JME vem ganhando cada dia mais espaço.

Para cada 10 vagas 8 são pra JEE. Mas por causa disso que você não vai estudar as outras tecnologias?Claro que NÃO. Estude como hobby, com uma cara horária menor que JEE(por exemplo), mas estude o importante é está adquirindo conhecimentos já que não sabemos o dia de amanhã e nem a oportunidade que pode surgir. Hoje o mercado de JME não está fervendo, a partir de amanhã ele pode começar a ferver do nada, os avanços tecnológicos, não dar para prevê com exatidão quando vão acontecer.

Lembre-se:“conhecimento nunca é demais”

Uma curiosidade é que na Europa há muito projetos para JSE, chega a ser muito superior que os projetos aqui no Brasil por exemplo.

Acho que a ordem para estudos com bases sólidas (não fazer uma janelinha, ou imprimir Hello World!) seria:

1. JSE: não levar a profundo o estudo, aprenda de forma intermediário, que pelo menos consiga fazer uma aplicação com acesso a Banco de dados etc. Enfim algo bem funcional.
2. JEE: aqui será suas refeições, então nem preciso comentar muito né?
3. JME: pode ser um hobby para brincar no final de semana.

Outro ponto a observar é que o número de materiais para JEE desde livros, artigos etc. É mais elevado que as outras duas tecnologias. Sem falar que lançamentos de livros para JEE têm um velocidade maior.

Flw! Pessoal, espero que o post tenha ajudado para a escolha da xícara!

P.s: por está meio adoentado as atualizações do blog vão ocorrer apenas em dois da semana. Desde já agradeço a compreensão de todos.

Salve!Salve! Pessoal! Hoje vou abordar o que acho necessario, para aprender Java de um forma disciplina e tentar diminuir aquele “fala-fala” que java é confuso e dificil, às vezes, nós que colocamos algumas pedras em nosso caminho e depois nao dar trabalho para tira-la. Claro o que exposto aqui é a ponta de iceberg acredito que ajuda aos novos javeiros. Quero aproveitar e convidar vocês para fazer uma visita a minha nova coluna no Imasters sobre Threads.

Links interesantes:

Conheça os pais das linguagens de programacao

TIOBE – MAY/2008 – 1º Java 😀

Aprender Java não é bicho de 7 cabeças como divulgam pelo mundo a fora. Como qualquer outra tecnologia que você for aprender um pouco de disciplina é necessário, porém há aquelas que cobram muito e outras um pouco. Java está entre as que cobram muito. Não é apenas copiar e colar, é preciso entender os conceitos de O.O e saber implementar para poder desfrutar dos recursos oferecidos: JAVA + O.O.

Já vi código em Java todo estruturado (parecia pascal), e outros com tanta gambiarra, alto acoplamento e baixa coesão e isso não há Santo que faça milagre, e ainda dizem: no PHP, .NET isso funcionava melhor. Será que o problema/culpa está na linguagem?

A forma que você aprende influencia diretamente na sua carreira, no seu sistema e o ponto principal na manutenção do software. Então não vá com muita “Sede ao pote”.

As pessoas (os caras) que você considera “Fera” e os que são conceituados nacionalmente/mundialmente todos eles começaram com o “Hello World!” não tem para onde correr, porém o processo de aprendizagem leva tempo e exige dedicação + disciplina. Não dar para dormir e acordar sendo “Fera”.

Recomendo aos iniciantes e os migrantes os seguintes caminhos:

– estudar bastante O.O

– fundamentos Java

– Buscar o por quê?

– praticar bastante (porém implementando os conceitos O.O e fundamentos)

Sempre falo aos amigos/colegas o profissional com uma EXCELENTE base (formação de conhecimento) de modo fluente tanto O.O e fundamentos Java ele aprende o que quiser da tecnologia (e se amanhã migrar para outra que seja O.O não levará muito tempo para aprende-la).

Um exemplo clássico é se hoje você trabalha com desenvolvimento de aplicações JEE e amanhã precisa mudar para desenvolver aplicações JME, à coisa é tão rápida que você vai precisar apenas de alguns dias para aprender o necessário sobre JME. O conceito de interface, herança, polimorfismo etc. não mudam de acordo com aplicação (JSE, JME, JEE). A regra é a mesma independente de qual plataforma desenvolve (mais um ponto para valorizar a certificação SCJP que esse é seu foco entre linhas).

Outro ponto que indico é comprar um BOM livro, sei que na internet tem aquela frase: “Tem tudo”. Porém esse “Tudo” não está de forma organizada e muito menos com objetivo, metodologias de aprendizado etc. E tem mais um pouco, buscar e organizar demanda tempo que significa $$$.

Outro ponto é que os livros não são baratos, porém hoje as empresas on-line dividem em até 10x s/juros + frete grátis e quase todo mundo tem um cartão de credito com pelo menos o limite de um salário mínimo. Então o importante é ter o livro como vai pagar é outro 500(não é para passar o calote). Mais ainda acho o livro à melhor opção para estudar, bons livros tem um todo processo metodológico de aprendizado, objetivo e com intuito de realmente fazer o leitor aprender e sentir prazer na leitura. Um exemplo os livros da Kathy Sierra.

Outra opção para quem não gosta ou não tem disciplina com os livros é fazer um bom curso. O que não pode é você mesmo colocar pedras (já basta às pedras default que vão surgir por lei da vida) em seu caminho.

Para quem for fazer um curso recomendo a caelum, pois tenho colegas que entrou lá sem saber nem imprimir o “Hello World!” e saiu fazendo aplicações que nem dava para acreditar.

Não estou sendo pago, pelo mkt, mas estou recomendando uma boa escola onde tenho referências,assim como faço com os livros que já citei que considero bons livros, e nenhum dos autores depositaram nada na minha conta até o momento rs.

Enfim são apenas pequenas dicas, como sempre nada comprovado cientificamente. Mas espero que tenha contribuído para a vida profissional de alguém!

Flw! Um abraço a todos e um bom final de semana!