Design Patterns usar ou não?

Olá, já faz algum tempo que não posto nada no blog, hoje vou escrever um pouco sobre Design Patterns.

Pra quem não conhece ainda muito bem sobre o assunto, Design Patterns são soluções para determinados problemas usadas repetidas vezes  que foram desenvolvidas por programadores experientes que obviamente se depararam com esses problemas também repetidas vezes, por isso é recomendável o uso dos Patterns.

Já li bastante sobre o assunto e implementei muitos patterns, confesso que não dominei todos os principais ainda completamente mas pretendo.

No início alguns Patterns podem parecer que mais complica do que ajuda, mas após um tempo que usamos os Patterns e entendemos melhor, percebemos que não é bem assim.

Os conceitos chaves dos Patterns são desacoplamento e coesão, ou seja, o código fica escalável e com fácil manutenibilidade. Polimorfismo e abstração são extremamente usados, além dos conceitos de orientação a objetos.

Por isso quando forem estudar Design Patterns preparem-se pra verem muitas interfaces e classes abstratas.

Existem muitos patterns mas os principais são os que foram publicados no livro Design Patterns: Elements of Reusable Object-Oriented Software pela Gang of Four, Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides,

Padrões de criação
Padrões estruturais
Padrões comportamentais

Para o uso de cada Pattern o problema deve ser analisado, nem sempre o uso de um Pattern é o ideal se seu uso for incorreto.

Caso o Pattern seja implementado para um problema que não seja adequado, a implementação do código só terá sua complexidade aumentada e dificilmente trará vantagens de uso.

É extremamente importante o domínio dos patterns pois usam todo o poder do paradigma de orientação a objetos, conhecê-los é fundamental.

 

 

 

 

Design Patterns usar ou não?

Como se dar bem em uma entrevista de emprego

Saudações!

Fazia tempo que eu estava pensando em postar experiências de entrevistas que fiz e de todo material que li também a respeito.

Na verdade não tem muito segredo, a dica valiosa é ser sincero com o entrevistador e ter congruência do que é falado, por exemplo se foi dito que você tem conhecimento sobre algo, vai precisar mostrar isso!

Olhe direto nos olhos do entrevistador ao conversar.

Mantenha uma linguagem corporal adequada, não cruze as mãos, ou os braços (óbvio), tente manter-se relaxado de forma reta na cadeira.

Lembre-se do nome do entrevistador, cumprimente-o com um aperto de mão também ao chegar na entrevista, o aperto de mão deve ser equivalente ao do entrevistador.

Controle-se, o nervosismo é normal nessas horas, mas depois de um pouco de conversa o nervosismo diminui, e conforme mais experiências tiver mais confiança se adquire.

Não fale demais, isso pode prejudicar sua imagem, seja objetivo, responda o que o entrevistador perguntou, o que ele quer ouvir, é aceitável falar um pouco mais, se o que tem a falar é importante e interessante.

Mostre forte interesse em aprender!Isso conta muito, pode até ser mais importante que um bom curso.

Conheça a empresa antes, entre no site leia a respeito, veja o que a empresa faz , se der pra dar uma passada na empresa melhor, mas como não temos muito tempo pra isso fica difícil e não é necessário.

Chegue sempre 15 minutos antes na entrevista de preferência, se não souber direito como chegar ao local, prefira sair um tempo antes de casa.

Cumprimente as pessoas da empresa, boa educação é sempre agradável.

Separe sua roupa um dia antes mas cuidado, a roupa não pode chamar mais atenção que seu talento, procure usar roupa social.

Leve seu currículo atualizado e certificados dos cursos, se tiver algo de bom pra mostrar, projetos e outros, procure levar também, ou mostrar onde o entrevistador pode ter acesso.

Não pare de se desenvolver, e mostre como que você faz isso para o entrevistador.

Evite respostas clichês, e reflita sobre perguntas frequentes de entrevistas, vou citar alguns exemplos:

Porque saiu da sua antiga empresa?
Outra pergunta decisiva, seja sincero e responda o que realmente aconteceu, e contorne essa pergunta.
Cuidado, não fale mal da empresa anterior.

Fale um pouco sobre você.
Explique o que faz no cotidiano, objetivos, o que estuda, o que pretende alcançar, e o que faz pra poder alcançar.

O que você vai ser daqui 5 anos?
Outra resposta pessoal.

Qual seu herói favorito?
Pense em um herói que tenha a ver com você.

O que levou a você querer trabalhar conosco?
Aqui deve ser aplicado o conhecimento sobre a empresa. A questão do dinheiro não deve ser levantada, somente se perguntarem.

Você sabe falar em público?
Responda de acordo com o que você acha.

Qual sua matéria favorita?
Pessoal.

Porque você acha que eu deveria contratar você?
Pessoal, deve ser explicado o que vem sendo feito para chegar em seu objetivo, não fale mal dos concorrentes.

Cite 3 defeitos, ou coisas a melhorar:
Pense profundamente e descubra esses pontos a melhorar, explique sempre de forma positiva e como pode fazer parar melhorá-los.

Cite 3 qualidades:
Pense em suas melhores qualidades, seu diferencial.

Pode ser também que te coloquem em situação difícil, e nesse contexto você deverá se sobressair, e geralmente são situações que parecem impossíveis de se resolver.

Em empresas grandes e multinacionais, seu conhecimento vai ser explorado, as perguntas terão nível alto, e as respostas deverão ser criativas e inovadoras. Então já prepare-se!

No final da entrevista geralmente querem saber se você tem algo a perguntar sobre a empresa, nessa hora é importante perguntar algo para mostrar que tem interesse na empresa.

Bom, essas são as principais dicas que devem ser seguidas, qualquer dúvida ou sugestão são bem vindas!

Como se dar bem em uma entrevista de emprego

Preparando ambiente para programar com Android de forma prática e funcional

Vou apresentar um guia fácil e prático para programar com Android!

Primeiro instale o JDK do Java (Caso não tiver):
http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html

Depois efetue o download do Eclipse de sua preferência (Caso não tiver):
http://www.eclipse.org/downloads/

Adicionando o Plugin ADT no Eclipse

Abra o Eclipse no menu/help/install new software e clique em add, na opção name digite o nome desejado, eu coloquei Android e na opção Location o link:
https://dl-ssl.google.com/android/eclipse/

Imagens do procedimento:

Android_Image

Selecione Developer Tools:

Plugin

Faça o procedimento padrão de instalação next next finish.

Instalando o SDK do Android

Baixe o SDK do Android para obter ter acesso as classes e usabilidades:
http://developer.android.com/sdk/index.html

Para instalar o SDK é necessário primeiro descompactar em uma pasta que não haja restrição de permissões, por exemplo em alguma pasta de arquivos de programas pode haver essa restrição, sugiro que descompacte a pasta sdk android no ‘C:’, assim evitará problemas.

Caminho SDK

No Eclipse vá no menu Window/Preferences opção Android e clique em Browse localizando onde foi colocado o SDK, e aí clique em apply e depois OK:

SDK Android

Depois vá no menu Window/SDK Manager

Opção Android

Recomendo selecionar todas as opções e instalar (Este procedimento é relativamente demorado de acordo com a velocidade da internet):

Android Instalação

Pronto!O ambiente está preparado para programação com Android!Caso tenham alguma dúvida ou sugestões, podem comentar!

Preparando ambiente para programar com Android de forma prática e funcional

Dominando Arrays com Java

Array: Conjunto de variáveis aninhadas possibilitando a manipulação mais facilitada.

A declaração simples de um array em Java é:

Forma correta:

int [] array = new int[5];

Forma porca:

int array [] = new int[5];

Na forma correta o programador vai analisar o código e já vai perceber que é um array, na forma porca não vai estar muito claro que a variável é um array, olhando rapidamente a variável parece do tipo int. É importante deixar claro que ambas compilam.

Um detalhe muito importante!

Na declaração de um array, é importante que usemos a sempre os [] logo após o tipo da variável, pois se declararmos depois se houver uma variável declarada junto com o outro array, ela será do tipo declarado, mas não será um array!

int array [], arrayCamuflado;

Nesse exemplo de cima, a variável arrayCamuflado é um tipo int e não um array!Pois os colchetes ficaram logo após o identificador e não antes do tipo.

Nesse exemplo abaixo é justamente o contrário, a variável arrayDeVerdade como o próprio nome diz, também é um array pois os colchetes foram declarados após o tipo:

int[] array , arrayDeVerdade;
int[][] array [], arrayDeVerdade; // Nesse caso a variável
//arrayDeVerdade terá duas dimensões([][]),
//o terceiro colchete é válido apenas pra variável array.

Matriz no Java:

Forma correta:

int [][] matriz = new int [2][2];
int [][][][][] matrizX = new int [7][7][7][7][7]

Forma porca:

Integer array7[][] = new Integer[2][50];
int[] matriz [] = new int [2][]; // Também compila perfeitamente

No Java os Arrays bidimensionais ou de mais dimensões, são na verdade arrays de arrays, ou seja os arrays guardam referências uns dos outros.

A declaração a seguir também é válida:

int[] matriz [] = new int [2][];

Outra regra extremamente importante:
Os arrays só podem ser inicializados em seu índice quando forem instanciados.
Por exemplo:

Válido:

int [] array = new int[5];

Inválido:

int [5] array = new int [5];

Também é possível usar polimorfismo nos arrays:

Considerando que a classe Animal é pai de Dog:

Animal [] animais = new Dog [5];

Lembre-se, todas as variáveis do tipo array são inicializadas com o valor padrão quando declaradas, não importando ser variáveis de instância (atributos) ou variáveis locais de métodos, não importa onde:

Tipo Valor padrão
variável de referência de objeto null
byte, short, int, long 0
float, double 0.0
boolean false
char /u0000′

Arrays anônimos

Pode-se utilizar os Arrays inicializando-os diretamente instanciando-os como Arrays anônimos, instanciar de forma anônima é instanciar de forma que não seja preciso armazenar a instância em outra variável, é útil quando já sabemos que vamos utilizar somente uma vez, pois após o uso o objeto ficará inacessível:

new int [] {5,6,7};

Inicialização do array diretamente em uma variável

int [] array = {4,6,7,7};
int [] array = new int [] {5,6,8,9};

A atribuição de um Array para outro deve ser feita se e somente se as dimensões forem iguais e seus tipos forem iguais ou covariantes (subclasses):

Double [] array = new Double [5];
Object [] objects = new Integer[5]; // Aqui é aplicado o polimorfismo, é perfeitamente válido pois Integer é um Object, todas as classes são.

array = objects; // Inválido, Integer não é um Double.

Atribuição válida:

Boolean [][] array = new Boolean[5][50];
Boolean [][] array2 = new Boolean[5][77];
array = array2;

Referência: SCJP 6 Kathy Sierra

Dominando Arrays com Java

Classe interna anônima definida no argumento

Saudações!

Vou explicar detalhadamente o processo de como criar uma instância diretamente no argumento da chamada de um método.

A interface:


//Apenas a interface
public interface Ex1Foo {
	// Apenas o método da interface
	void metodoDaInterface();

}

A classe que chama a interface no argumento do método doStuff()


public class Ex1Bar {
	// Método que recebe como parâmetro a Interface Ex1Foo
	void doStuff(Ex1Foo f) {
		System.out.println("LOL");
		// Recebendo a interface como parâmetro posso manipulá-la do jeito que
		// foi declarado no método
		// Ex1MyWonderfulClass
		f.metodoDaInterface();
	}
}

A classe em que os processos acontecem:

Aqui é onde tudo acontece!
Primeiro a classe Bar é instanciada trazendo a possibilidade de
utilizar seus métodos e assim com a variável de referência (“Objeto”) b, uso o método doStuff
passando como parâmetro a interface!

AÍ ESTÁ O PROBLEMA, EU NÃO TENHO UMA CLASSE QUE IMPLEMENTA ESSA
INTERFACE!

Por isso eu preciso criar uma classe anônima que implemente essa interface para poder passar o parâmetro!
Para praticalizar o processo eu posso criar uma classe anônima que implemente essa interface dentro do argumento do método.
Por exemplo esse trecho do argumento new Ex1Foo(), seria o mesmo que ClasseQualquer classeImplementadoraQualquer = new Ex1Foo{…….

A classe é já instanciada automaticamente com os métodos da interface obrigatóriamente implementados, ou seja pra resumir:
É instanciada uma classe anônima do tipo Ex1Foo, e aplicando suas
funções já dentro do parâmetro.


public class Ex1MyWonderfulClass {
	void go() {
		Ex1Bar b = new Ex1Bar();

		b.doStuff(new Ex1Foo() {
			@Override
			public void metodoDaInterface() {
				System.out.println("Método da interface");

			}
		});
	}

	public static void main(String[] args) {
		Ex1MyWonderfulClass wonderfulClass = new Ex1MyWonderfulClass();
		// Aqui utilizo o método go e tanto o método doStuff quanto o método
		// metodoDaInterface são executados perfeitamente!

		// Obs: O método da interface é executado porque ele é chamado no método
		// da classe Ex1Bar
		wonderfulClass.go();
	}
}

A saída dos método é:

LOL
Método da interface!

Classe interna anônima definida no argumento

Ordenação de Arrays com Java

A ordenação básica de um Array, sem nenhum método específico..

package arrays;

public class OrdenacaoArrays {

	public void ordenaArrayFormaComum(int [] array) {
		int aux = 0;
		for (int i = 0; i < array.length - 1; i++) {
			for (int j = i + 1; j < array.length; j++) {
				if(array[i] > array[j]) {
					aux = array[i];
					array[i] = array[j];
					array[j] = aux;
				}
			}
		}

		System.out.print("\nArrays ordenados: ");
		for(int i = 0; i < array.length; i ++) {
			System.out.print(array[i] + " ");
		}
	}

}
Ordenação de Arrays com Java

Criando o algoritmo de junção de arrays em Java

public class UnificacaoArrays {

      public int [] unificaArray(int array1[], int array2[]) {
           final int tamanhoArrayUnificado = array1.length + array2.length;
           int arrayUnificado[] = new int [tamanhoArrayUnificado];

           for(int i = 0; i < array1.length;i++) {
           arrayUnificado[i] = array1[i];
      }
      for(int i = array1.length; i < tamanhoArrayUnificado; i++) {
           arrayUnificado[i] = array2[i - array1.length];
      }
           return arrayUnificado;
      }
}

public class Main {
       public static void main(String[] args) {
            int array1[] = {5,10,15,25,30};
            int array2[] = {9,8,7,6,5,4};

            //Executa a classe de unificação de arrays e mostra os dados
            UnificacaoArrays unificacaoArrays = new UnificacaoArrays();
            int arrayUnificado[] = unificacaoArrays.unificaArray(array1, array2);
            System.out.print("For normal: ");
            for(int i = 0; i< arrayUnificado.length; i++) {
                 System.out.print(arrayUnificado[i] + " ");
            }
       }
}
Criando o algoritmo de junção de arrays em Java