Palavra reservada THIS

A palavra reservada this é usada quando se quer fazer uma referencia a um objeto ou chamar um construtor da própria classe. Geralmente chama-se um construtor da própria classe quando queremos evitar a repetição de código. Por exemplo, se tiver uma variável global e uma local com o mesmo nome, o this.variável fará referência a variável local dentro do método. Isso nada mais é do que uma das regras ou a principal regra da Programação Orientada a Objetos, o reuso de código.

Exemplo:

public class Contato {

private String nome;

}

public String getNome() {

return nome;

}

public void setNome(String nome) {

this.nome = nome;

}

Pra não esquecer:
Você só pode inserir this()  dentro de um construtor e essa deve ser a primeira instrução do construtor.


Melissa Lobo.

Classes Wrapper

Uma classe wrapper é uma classe empacotadora, há uma classe wrapper para cada tipo primitivo em Java. Por exemplo, a classe wrapper para o tipo int é Integer, para o float é Float, e assim por diante. O nome do tipo primitivo é simplesmente o nome em minúsculas do wrapper, exceto para char, que passa a ser Character, e int, que a passa a ser Integer.

O wrapper fornece métodos de objeto para os oito tipos primitivos. Como por exemplo os métodos equals(Object) e toString, o primeiro é utilizado para comparações enquanto que o segundo permite que o conteúdo de um objeto seja representado em formato de texto.

Usamos  os tipos primitivos porque eles são mais rápidos e consomem menos memória, permitem operações mais complexas e são eficientes quando usados em laços e expressões. Porém os tipos primitivos não podem ser utilizados em Collections, só objetos. Sendo assim, a solução é usar Wrappers.

Melissa Lobo.

Todas as classes em Java estendem a classe Object

Pra não esquecer:

A classe object é a mãe de todas as classes; é a superclasse de tudo.

Diferença entre Métodos Sobrecarregados e Subscritos

Métodos
	Sobrecarregados	Subscritos
Lista de argumentos	Deve ser alterada	Não deve ser alterada
Tipo de retorno	Pode ser alterado	Não deve ser alterado
Exceções	Podem ser alteradas	Podem ser reduzidas ou eliminadas. Não devem ser lançadas novas ou abrangentes
Acesso	Pode ser alterado	Não deve se tornar mais restritivo. Pode se tornar menos restritivo
Chamadas	O tipo da referencia determina que versão sobrecarregada (baseada nos tipos de argumentos declarados) será selecionada. O método real a ser chamado ainda terá uma chamada virtual no tempo de execução, a coincidência de argumentos já terá sido definida, só faltando a classe real onde o método reside.	O tipo do objeto (em outras palavras, o tipo da instancia real na memória) será selecionado. Isso ocorrerá a todo instante

Array (Vetor)

Em Java, os Arrays são objetos que armazenam múltiplas variáveis do mesmo tipo, ou variáveis que são todas subclasses do mesmo tipo. É comum ouvirmos "array de objetos". Porém quando criamos um array de alguma classe, ele possui referências. O objeto, como sempre, está na memória principal e, no seu array, só ficam guardadas as referências (endereços). Os arrays podem armazenar ou primitivos ou referências a objetos, mas o próprio array será sempre um objeto no heap (falarei mais sobre o heap, em breve), mesmo se o array declarado para armazenar elementos primitivos. Em outras palavras, não existe um array primitivo, mas você pode criar um array de primitivos.

Como os Arrays são declarados? 
Informando-se o tipo de elementos que o array irá armazenar (um objeto ou primitivo), seguido por colchetes em um dos lados do identificador. Lembrando que uma array de tipos primitivos guarda valores, uma array de objetos guarda referências.
Exemplo:

int[] testes;

O int[] é um tipo. E como um array é sempre um objeto, a variável testes é uma referência. Vamos precisar criar um objeto para poder usar o array.
Exemplo:

testes = new int[10];

E você pode (deve) fazer isso diretamente assim:

int[] testes = new int[10];

Pra não esquecer:
Ao declarar uma referencia ao array, você deve sempre colocar os colchetes do array imediatamente depois do tipo declarado, em vez de depois do identificador (nome da variavel). Dessa forma, qualquer um que leia o código saberá facilmente que, por exemplo, testes é uma referência a um objeto de array int, e não um tipo primitivo int.

Criamos um array de int de 10 elementos e atribuímos o endereço no qual ele foi criado.
Podemos ainda acessar os elementos do array:
Exemplo:

testes[5]= 8;

O código acima altera o quinto elemento do array, como pode ver na ilustração abaixo.

| | | | |8| | | | | |

Cada item em um array é chamado de elemento, e cada elemento é acessado pela posição numérica. Como na ilustração abaixo as posições são numeradas a partir do 0 (zero). O 5º elemento, por exemplo, é acessado na posição 4.

|0|1|2|3|4|5|6|7|8|9| -> Posições
 | | | | | | | | | |
 1 2 3 4 5 6 7 8 9 10 -> Elementos

Lembrando que na declaração de um array, cada elemento recebe um valor padrão, sendo 0 (zero) para números de tipo primitivo, falso (false) para elementos booleanos e nulo (null) para referências.

Arrays multidimensionais
Pois é, ainda não acabou! Um array pode ter mais de uma dimensão. Isto é, em vez de termos um array de 10 testes, podemos ter um array de 10 por 10 testes e você pode acessar o teste na posição da coluna x e linha y. Na verdade, um array bidimensional em Java é uma array de arrays. Parece confuso mas é simples, a ilustração deixa bem claro.
Exemplo:

Não vou entrar muito a fundo nessas dimensões, mas vocês podem pesquisar mais a respeito se desejarem. Enfim em Java é fundamental entender o funcionamento de um Array e saber como utilizá-lo. Como podem ver não é tão difícil e é bem útil guardar objetos e valores em um array.

Pra não esquecer:

tipo[] nome_do_array = new tipo[numero_de_elementos];
Ou:
tipo[] nome_do_array = { valor1, valor2, ...,valorx};


Melissa Lobo,

Declaraçoes de variáveis

Existem dois tipos de variáveis em Java as Variáveis de tipo Primitivos e as Variáveis de referencia

Primitivos - Um primitivo pode ser de oito tipos diferentes: char, bollean, byte, short, int, long, double  ou float. Uma vez declarado, o seu tipo primitivo não pode nunca ser modificado, embora na maioria dos casos o seu valor possa se modificar.

Variáveis de referencia- As variáveis de referencia são usadas para se referir (ou acessar) um objeto. Uma variável de referencia e declarada como sendo de um tipo especifico, e esse tipo não pode nunca ser modificado. Uma variável de referencia pode ser usada para referir-se a qualquer objeto do tipo declarado, ou de um subtipo do tipo declarado (um tipo compatível).

Modificadores de acesso

Em um programa podemos desejar que as classes de um pacote não possam ser acessadas pelas classes de outro, ou então que determinada variável fique restrita somente ao escopo da sua classe. Para definir este tipo de acesso é que usamos os modificadores de acesso.
Neste caso, escopo é o limite da existência da classe. É a parte do código que inicia após a abertura das chaves e termina no seu fechamento.

Os modificadores servem para definir que tipos de acesso terão as classes e seus membros.

Níveis de acesso são conhecidos por public, private, protected e default. E os modificadores são apenas três: public, private, protected. O nível de acesso default (padrão) não exige modificador. Quando não se declara nenhum modificador, o nível default é implícito.

- Public: Esse é o modificador menos restritivo. Permite visibilidade global;
- Private: Esse é o modificador mais restritivo. Permite visibilidade apenas na própria classe;
- Default: Nível default é o mesmo que nível de pacote. Permite visibilidade dentro do pacote. Não exige um modificador explícito;
- Protected: Esse é como o default, porém permite visibilidade global através de herança. Parece confuso a primeira vista, mas analisaremos como funciona em detalhes mais adiante.

As classes só aceitam dois modificadores: default e public. A classe pode estar acessível no nível de pacote ou globalmente. Ou seja não existem classes isoladas.

A visibilidade entre classes é que determina se podemos ou não:
- Estender outra classe;
- Criar instâncias de outra classe;
- Acessar membros de outra classe.

O modificador private é o contrário do public. Com ele o acesso é o mais restrito possível. Membros declarados como private só podem ser acessados por membros da sua própria classe. Eles não podem ser acessados nem por classes do mesmo pacote.

Git

O Git é um sistema fácil de usar, incrivelmente rápido, bastante eficiente com grandes projetos e de uma excelente qualidade. Mas o que é exatamente o Git? O Git considera que os dados são como um conjunto de snapshots (captura de algo em um determinado instante, como em uma foto) de um mini-sistema de arquivos. Cada vez que você salva ou consolida (commit) o estado do seu projeto no Git, é como se ele tirasse uma foto de todos os seus arquivos naquele momento e armazenasse uma referência para essa captura. Para ser eficiente, se nenhum arquivo foi alterado, a informação não é armazenada novamente - apenas um link para o arquivo idêntico anterior que já foi armazenado.
O workflow básico do Git pode ser descrito assim:

• Você modifica arquivos no seu diretório de trabalho.
• Você seleciona os arquivos, adicionando snapshots deles para sua área de preparação.
• Você faz um commit, que leva os arquivos como eles estão na sua área de preparação e os armazena permanentemente no seu diretório Git.

E agora algumas dicas e comandos resumidos para começarmos a trabalhar com o Git

Instale o Git:
Git para Linux
Git para Windows
Git para OSX

Crie um novo repositório
Crie uma nova pasta ou somente abra a pasta que o seu arquivo/programa/teste/etc que deseja commitar esteja e execute o comando:
 git init  e ele criará um novo repositório.

Copie um repositório
Se você quer copiar um repositório Git já existente o comando necessário é:
 git clone /caminho/para/o/repositório 
Quando usar um servidor remoto, seu comando será:
 git clone usuário@servidor:/caminho/para/o/repositório 

Verifique o Status de Seus Arquivos
A principal ferramenta utilizada para determinar quais arquivos estão em quais estados é o comando git status. Se você executar este comando diretamente após uma clonagem, você deverá ver algo similar a isso:
 $ git status 
 # On branch master 
 nothing to commit (working directory clean) 
Que significa que não existem arquivos monitorados e modificados. Git também não encontrou qualquer arquivo não monitorado, caso contrário eles seriam listados aqui.

Adicione & confirme
Você pode propor mudanças (adicioná-las ao Index) usando:
 git add <arquivo>  ou  git add .  que adiciona todos os arquivos.
Este é o primeiro passo no fluxo de trabalho básico do git. Para realmente confirmar estas mudanças (isto é, fazer um commit), use:
  git commit -m "comentários das alterações" 
Agora o arquivo é enviado para o HEAD, mas ainda não para o repositório remoto.

Envie suas alterações
Suas alterações agora estão no HEAD da sua cópia de trabalho local. Para enviar estas alterações ao seu repositório remoto, execute:
 git push origin master 
Altere master para qualquer ramo (branch) desejado, enviando suas alterações para ele.
Se você não clonou um repositório existente e quer conectar seu repositório a um servidor remoto, você deve adicioná-lo com:
 git remote add origin <servidor> 
Agora você é capaz de enviar suas alterações para o servidor remoto selecionado.

Atualize & mescle
Para atualizar seu repositório local com a mais nova versão, execute:
 git pull  na sua pasta de trabalho para obter e fazer merge (mesclar) alterações remotas.
Para fazer merge de um outro branch ao seu branch ativo (ex. master), use:
 git merge <branch> 
Em ambos os casos o git tenta fazer o merge das alterações automaticamente. Infelizmente, isto nem sempre é possível e resulta em conflitos. Você é responsável por fazer o merge estes conflitos manualmente editando os arquivos exibidos pelo git. Depois de alterar, você precisa marcá-los como merged com:
 git add <arquivo>  antes de fazer o merge das alterações, você pode também pré-visualizá-as usando:
 git diff <branch origem> <branch destino> 

Sobrescreva alterações locais
No caso de você ter feito algo errado você pode sobrescrever as alterações locais usando o comando
 git checkout -- <arquivo> 
isto substitui as alterações na sua árvore de trabalho com o conteúdo mais recente no HEAD. Alterações já adicionadas ao index, bem como novos arquivos serão mantidos.
Se ao invés disso você deseja remover todas as alterações e commits locais, recupere o histórico mais recente do servidor e aponte para seu branch master local desta forma:
 git fetch origin 
 git reset --hard origin/master 

Remova Arquivos
Para remover um arquivo do Git, você tem que removê-lo dos arquivos que estão sendo monitorados (mais precisamente, removê-lo da sua área de seleção) e então fazer o commit. O comando  git rm faz isso e também remove o arquivo do seu diretório para você não ver ele como arquivo não monitorado (untracked file) na próxima vez.

Pra não esquecer:
Fluxo de trabalho
Seus repositórios locais consistem em três "árvores" mantidas pelo git. A primeira delas é sua Working Directory que contém os arquivos vigentes. A segunda Index que funciona como uma área temporária e finalmente a HEAD que aponta para o último commit (confirmação) que você fez.

Melissa Lobo,