Git, GitHub e OO

Git
- Controle de versões
- Backup do código (segurança)

Principais Comandos
$ git init - Cria um repositório local
$ git clone url - Clona um repositório remoto para uma pasta local
$ git remote add <uri> - Adiciona um repositório remoto (não necessário caso tenha sido usado o
clone)
$ git add <files> - Adiciona ao index
$ git commit -m “Message” - Commit dos arquivos do index
$ git pull - Atualiza os arquivos locais baseados no repositório remoto
$ git push origin master - Envia os arquivos para o repositório remoto, na branch master
$ git checkout -b <branch> - Cria uma branch e troca para ela
$ git merge <branch> - Faz o merge de uma branch para a outra

GitHub
- Plataforma de hospedagem
- Compartilhamento de código
- Contribuição para projetos OpenSource
https://github.com/

OOP
Object-Oriented
Programming

Procedural x OO
OOP
● Objetos
● Campos e
métodos
● Reaproveitamento
de código
● Métodos com
poucos
parametros
● Controle de
acesso
Programção
Procedural
● Lista de
procedimentos
● Muitas variáveis
● Muito
Copy+Paste
● Funções com
muitos
parâmetros
● Dificil
manutenção
let titular = "Douglas";
let cpf = 11122233345;
let cc = 987654;
let saldo = 500;
function saca(saldo, valor) {
return saldo - valor;
}
let conta = {
titular: "Douglas",
cpf: 11122233345,
cc: 987654,
saldo: 500,
saca: function(valor) {
return this.saldo - valor;
}
}
● Programação Procedural
● OOP

OOP
PolimorfismoAbstraçãoHerançaEncapsulamento

Algumas práticas:
- Information Hidding
- Tell, don’t ask (Mande, não peça)
- Programação voltada a interface
- Lei de Demeter
- Liskov Substitute Principle

Modificadores de
Acesso
● Segurança de código
● Responsabilidade única com o private
Class
Packag
e
2
protected
1
public
Subclass World
3
no-modifier
4
private

Como saber se está bem
encapsulado?
NotaFiscal nf = new NotaFiscal();
double valor = nf.calculaValorImposto();
O que o método faz?
Como ele faz?
Encapsulamento

Herança
● Um objeto adquire as propriedades e
comportamentos da classe mãe
● Cria uma relação mãe-filho(parent-
child) entre duas classes
● Mecanismo robusto e natural para
organizar e estruturar softwares
Livro
Livro Fisico E-Book
E-Bok2E-Book1Livro2Livro1

Abstração
● Agrupa classes similares como irmãs
● Diminui a complexidade de
implementação
● Não pode ser instanciada
Objeto
ƒx
ƒx
ƒx
ƒx
ƒx
ƒx
ƒx ƒx ƒx
X X
X X
X X
Classe abstrta
ƒx
ƒx
ƒx
ƒx

public abstract class TemplateImpostoCondicional implements
Imposto {
@Override
public double calcula(Orcamento orcamento) {
if(deveUsarMaximaTaxacao(orcamento)) return
maximaTaxacao(orcamento);
else return minimaTaxacao(orcamento);
}
protected abstract double minimaTaxacao(Orcamento
orcamento);
protected abstract double maximaTaxacao(Orcamento
orcamento);
protected abstract boolean
deveUsarMaximaTaxacao(Orcamento orcamento);
}
Classe Abstrata

Objeto
public class IKCV extends TemplateImpostoCondicional {
private boolean temItemMaiorQue100Reais(Orcamento
orcamento) {
for (Item item : orcamento.getItens()) {
if(item.getValor() > 100) return true;
}
return false;
}
@Override
public double minimaTaxacao(Orcamento orcamento) {
return orcamento.getValor() * 0.06;
}
@Override
public double maximaTaxacao(Orcamento orcamento) {
return orcamento.getValor() * 0.1;
}
@Override
public boolean deveUsarMaximaTaxacao(Orcamento
orcamento) {
return orcamento.getValor()> 500 &&
temItemMaiorQue100Reais(orcamento);
}
}

Encapsulamento x Abstração
1. Separar o código em unidades (objetos)
a. Conta, Agencia, Titular
b. Gerente, Funcionário, Cliente
2. Esconde atributos e métodos por razões
de segurança
1. Criar um “molde” que pode ser aplicado
com facilidade para classes semelhantes:
a. Livro(abstrata) -> Ebook, LivroFisico
2. Permite focar em quais informações um
objeto deve conter

Polimorfismo
● Reutilização
● Clareza
● Manutenção de código
public abstract class OperacaoMatematica {
public abstract double calcula(double x, double y);
}
public class Soma extends OperacaoMatematica {
@Override
public double calcula(double x, double y) {
return x+y;
}
}
public class Teste {
public static void main(String[] args) {
OperacaoMatematica soma = new Soma();
Soma soma2 = new Soma();
soma.calcula(5,7);
soma2.calcula(8,9);
OperacaoMatematica sub = new Subtracao();
sub.calcula(7,5);
}
}

Interface (protocolo)
Animal
Ave
Mamifero
CachorroCavaloPapagario
Baleia
AnimalEstimacaoAnimalDomesticado
Gato
Classe
Abstrata
Classe
Interface

public abstract class Animal {
private String nome;
public abstract String emitirSom();
public String getNome() { return nome; }
public void setNome(String nome) { this.nome =
nome; }
}
public abstract class Mamifero extends Animal {
private String especie;
public abstract void amamentar();
}
public abstract class Ave extends Animal {
public abstract void voar();
}

public interface AnimalDomesticado {
void levarVeterinario();
void alimentar();
}
public interface AnimalEstimacao {
void brincar();
void passear();
}
Todos os campos de interfaces são públicos, estáticos
e finais:
public static final int id = 2;
int id = 2;

public class Cachorro extends Mamifero implements
AnimalDomesticado, AnimalEstimacao {
@Override
public void levarVeterinario() { }
@Override
public void alimentar() { }
@Override
public void brincar() { }
@Override
public void passear() { }
@Override
public void amamentar() { }
@Override
public String emitirSom() { return "Au au"; }
}
public class Gato extends Mamifero implements
AnimalDomesticado, AnimalEstimacao{
@Override
@Override
@Override
public void brincar() { }
@Override
public void passear() { }
@Override
@Override
public String emitirSom() { return "Miau"; }
}

public class Cavalo extends Mamifero implements
AnimalDomesticado {
@Override
@Override
@Override
@Override
public String emitirSom() { return null; }
}
public class Papagaio extends Ave {
@Override
public void voar() {
}
@Override
public String emitirSom() {
return "Piupiu";
}
}
public class Baleia extends Mamifero {
@Override
public void amamentar() {
// Nada
}
@Override
public String emitirSom() {
return null;
}
}

Statics
● Métodos estáticos não precisam de
instâncias para serem chamados
● Constantes através de interfaces
public class Fibonnacci {
public static int calcula(int n) {
if (n < 2) return 1;
return calcula(n-1) + calcula(n-2);
}
}
public class Teste {
public static void main(String[] args) {
System.out.println(Constantes.PROJECT_NAME + ":");
for(int i = Constantes.I; i<Constantes.LIMITE; i++) {
System.out.println(Fibonnacci.calcula(i));
}
}
}
public interface Constantes {
int ANSWER = 42;
String PROJECT_NAME = "Fibonnacci Numbers";
int LIMITE = 15;
int I = 0;
}
● Atributos estáticos possuem o mesmo
valor, independente de quantos
objetos são instanciados

Git, GitHub e OO

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Git, GitHub e OO (20)

Último (7)

Git, GitHub e OO

Notas do Editor