Polimorfismo

POLIMORFISMO
==================
 Polimorfismo significa varias formas para uma mesma coisa, e introduzido em POO, refere-se a reescrever algo de forma diferente, polimorfismo esta fortemente ligado a herança, quando criamos uma classe "MÃE" esta classe pode ter metodos que seram herdados pela suas classes "FILHAS", se temos a necessidade desses metodos comportassem de forma diferente podemos sobrescreve-los nas filhas deste jeito tendo varias formas de uma mesma coisa. existem varios tipos de polimorfismo, porem os dois mais usados sao sobrecarga e sobreposição.

**sobreposição**: como citado a cima, podemos sobrescrever um metodo com o uso do @Override, tendo obrigatoriamente que a classe em questão seja uma filha da classe instanciada, o mesmo nome no metodo que a sua implementação original e sua assinatura tambem deve ser a mesma(tipos e quantidade de parametros).

**Escolha**: a escolha do metodo que será usado é em tempo de execução e é decidida por qual instancia chamou o metodo (ex...se carros herda de automoveis e quem chama é carros, sera usado o metodo qe esta implementado em carros, se for chamado por automóveis sera usado o de automoveis.)

**filhas**: as FILHAS sempre vão utilizar o metodo da classe MÃE, mesmo qe seja um decendente de outras classes acima de sua mãe(ex...a classe mazda que herda de carros e a mesma herda de automoveis,contem o mesmo metodo lavarCarro() implementado, a classe mazda quando chamada irá conter a implementação da classe carros pois foi a mais proxima a sobrescrever.).

**sobrecarga**: este tipo de polimorfismo, da-se em escrever varias vezes o mesmo metodo na mesma classe, porem com assinaturas diferentes (tipos e quantidade de parametros), usa-se principalmente para se ter varias opções para o mesmo metodo, dessa forma tratando as possibilidades diferentes de parametros que pode receber, assim fazendo com que o metodo atue de formas diferentes conforme o atributo passado. Pode ser escrito quantas vezes for necessario.

Herança

HERANÇA
==============
A herança é sem duvida uma das mais importantes partes do POO, torna os projetos dinamicos e com facil manutenção, trata-se de criar superclasses ou classes "MAE" dentro do projeto, essas classes sao herdadas(extends) para suas classes subclasses "FILHA", desta forma tudo aquilo que pertence a MÃE tambem pertencerá a FILHA.

**Sintaxe** : public class NomeDaClasseFilha extends NomeDaClasseMae{}

**filhas**: podem conter ou nao seus proprios atributos e metodos, caso nao contenham são conhecidas como herança para implementação pois somente estanciam a classe mãe.

**limite**: não a um limite para a herança classes filhas também podem ser extendidas (ex...imagine uma classe imovéis que tem como filha a classe casa e surge a necessidade de criar a classe casaDoisPisos, o correto é a casaDoisPisos extender de casa e nao de imoveis, pois ela é uma derivada de casa apenas com uma implementação(segundo piso) a mais.)

Interfaces

INTERFACES
===================
 Interfaces são contratos que devem ser seguidos pelas classes que a implementam, dentro delas terá sempre metodos que contem somente sua assinatura sem nenhum tipo de implementação no seu corpo, quando a classe implementa a interface, ela deve por (obrigação do compilador) ter todos os metodos da interface implementados no seu corpo.

- **Herança**: unica forma de herança multipla em java, uma classe pode implementar uma ou mais interfaces.

- **Sintaxe**: public interface NomeDaClasse.
          void assobiar(){}
          String falar(){}
          pessoa retornaPessoa(){}

-**acesso**: todos os metodos de uma interface sao por padrao public abstract e não podem ser alterados(nao há a necessidade de declarar)

Classes Abstratas

CLASSES ABSTRATAS
==================
  Classes Abstratas nao podem ser instanciadas, são classes que servem apenas como "MÃES", dentro delas podem ter metodos implementados ou nao, atributos tambem sao herdados, funciona como um contrato porém este tendo a possibilidade de conter implementação ao contrario da interface que contém somente a assinatura do metodo.

- **Devem**: conter pelo menos um metodo abstrato.

- **Sintaxe**: public abstract class NomeDaClasse {}.
          void assobiar(){
           sout("assobiando") }
        
          String falar(String fala){
           return fala}
         
          pessoa retornaPessoa(Pessoa pessoa){
           pessoa.setNome = nome
           return pessoa}


- **Caso**: caso uma classe abstrata tenha todos os seus metodos abstratos, ela se torna uma interface.

Modificadores de Acesso

Modificadores de Acessos
====================
Modificadore de acesso referem-se a o quão visivel é uma variavel, metodo ou classe.

- **Private**: este é o modificador de acesso mais restrito, somente é visivel para a propria classe onde é declarado, para outras classes terem acesso, entra encapsulamento.

- **default**: este vem logo abaixo de private dando acesso apenas para a mesma classe e para o pacote onde ela se encontra

- **protected**:  este da acesso para a propria classe, para o pacote e para os fihos dela mesmo nao estando no mesmo pacote.

-**public**: este é o mais aberto de todos, todas as classes dentro do projeto tem acesso a ele, deve se ter cuidado com ele, pois se udado de forma errada destroi todos os conceitos de poo.

Statics em java

STATICS
==================
Torna algo estatico dentro de uma classe as statics são bem importantes em POO.

- usando em variaveis faz com que o valor atribuido a ela seja compartilhado entre todas as suas filhas, quando o valor é alterado em um objeto dessas classes, é alterado em todos os outros .

- usando em metodos de uma classe, faz com que esses metodos sejam acessiveis sem a necessidade de estanciar um objeto, simplesmente chamando ele, podemos usa-lo.

Dicas Git/GitHub

GITHUB
============================

GitHub é uma aplicação de gerenciamento de projetos e versionamento de codigo, funciona também como rede social para dev's, utiliza git este sendo um sistema de versionamento de projetos, com o git pode-se utilizar um repositório online para controlar os codigos fontes e arquivos de um projeto, este também possibilita varios dev's trabalhando no mesmo projeto, a principal função do git é evitar a quebra de codigo pois o mesmo nao aceita conflitos dentro dos arquivos, hoje sendo a melhor forma de controlar o trabalho em equipe.

**Principais Comandos**

- **git push** : "empurrar", este comando faz o envio das alterações ocorridos na branch local para a master(repositorio).

- **git pull**: "puxar", este comando traz as alterações da master para o local.

- **git merge**: "mesclar", este comando é um dos mais importante, serve para resolver todas os conflitos de codigo dentro de um arquivo, ele separa as atualizações da master e da local dentro do arquivo ficando para o usuario decidir qual é a correta.

- **git checkout **: desfaz as alterações feitas em um arquivo para que fiquem como vieram da master, este ainda tem outras funcões como criar branchs "git checkout -b <branch>, excluir branchs "git checkout -d" etc.

- **git reset** :  git reset HEAD é para desfazer mudanças não confirmadas . (ainda nao enviadas a master.)

- **git revert** : Você pode pensar em git revert como uma ferramenta para desfazer mudanças confirmadas . (enviadas  a master ex..:git checkout
 hotfix git revert HEAD~1)

- **git status ** : mostra as alteracões locais feitas referente a master e que nao foram commitadas.

- **git commit -m** : serve para comitar as alterações inclusas no stash.