Orientação a Objetos - 24/10/2012, 26/10/2012, 31/10/2012

História da OO:

1963: Sketchpad
  - Editor gráfico que introduz o conceito de objeto
  - http://www.youtube.com/watch?v=mOZqRJzE8xg
  - http://pt.wikipedia.org/wiki/Sketchpad
1962-8: Simula
  - Linguagem para simulação, introduz o conceito de classes
  - http://pt.wikipedia.org/wiki/Sketchpad
1972-80: Smalltalk
  - Primeira linguagem OO pura, tudo em Smalltalk são
    objetos, instâncias de alguma *classe* que respondem
    a *mensagens*. As próprias classes são objetos!
  - http://pt.wikipedia.org/wiki/Smalltalk
  - http://www.youtube.com/watch?v=JLPiMl8XUKU
  - Implementação moderna: http://www.squeak.org
1995: Java
  - Sintaxe inspirada em C/C++
  - Modelo de execução mais parecido com o de Smalltalk
  
1. Dados primitivos

São os átomos de dados da linguagem Java, usamos os tipos
abaixo como base para compor objetos mais complexos. Inteiros,
reais e booleanos são manipulados com os operadores pré-definidos
da linguagem (+, -, /, *, &&, ||, etc.), enquanto strings
são objetos manipulados através de chamadas a métodos, como
qualquer outro objeto (ainda vamos ver isso!), exceto pela
operação de concatenação (+).

* inteiros (int) - com sinal, 32 bits, ~-2e9 a ~2e9
  - operações como em C
  - 2, 5, 42, 1000000, -1
* "reais" (double) - ponto flutuante
  - operaçoes como em C
  - 1.23, 2.56e7, 0.0
* booleanos (boolean) - verdadeiro (true) e falso (false)
 - operações como os "booleanos" de C
 - && (e), || (ou), ! (negação)

* cadeias (String) - cadeias de símbolos
 - aspas duplas, códigos de escape (\n, \\, \t, \", ...)
 - "Olá Mundo", "Uma linha\nOutra linha",
 - "Ele disse, \"Olá!\""
 - uma operação pré-definida: concatenação (+)
 - "Olá " + "Mundo" = "Olá Mundo"
 - Concatenação não muda os operandos, mas cria uma nova string!
 - Strings não são modificáveis em Java: são *imutáveis*

* vetores (int[], double[], String[], int[][]...)
  - 'int[] foo' ao invés de 'int foo[]'
  - não existe 'int[5] foo'
  - criados com 'new int[5]'
  - depois de criados, acessados com [] como em C
  - não existe free ou delete, o espaço de um vetor é
    retomado por Java quando ele se torna *inacessível*

2. Classes

Unidade de estruturação de um programa Java. No nível
mais básico funciona como uma *struct* de C, servindo
para agrupar diversos valores, chamados de *campos*,
em uma mesma entidade.

Os campos de uma classe podem ter qualquer tipo, inclusive
outras classes! A inicialização dos campos pode ser feita na
sua declaração, mas comumente é feita por um dos *construtores*
da classe. A função dos construtores é inicializar um objeto
recém-criado. Dentro de um construtor a variável *this* aponta
para o objeto que acabou de ser criado.

* Modelagem "Space Invaders"
* Classe Alien
  - Campos e construtor
  - Construtor *inicializa* um objeto recém-criado
  - Objetos criados com new: new Alien(10, 50)
  - Identidade de objetos (==) vs. "igualdade"
    Cada chamada a new cria um objeto distinto. O operador
    == só é true se os dois lados são o mesmo objeto. Em
    particular, new Alien(10, 50) == new Alien(10, 50) é
    false
  - Variáveis *apontam* para objetos
    Se a1 e a2 são variáveis do tipo Alien e faz-se
    a1 = a2 = new Alien(10, 50) então a1 == a2 será true,
    pois a1 e a2 estarão apontando para o mesmo objeto
* Classe Cor
  - Uma classe pode ter mais de um construtor, o construtor
    chamado vai depender do número e tipo dos argumentos
    passados na chamada para new
  - Campos podem ser referências para objetos de outras
    classes (campo cor das classes Alien, Canhao, Tiro)
* Inicialização de campos fora do construtor
  - Executa depois de cada chamada a "new", mas antes
    do construtor, em uma inicialização como
    public Cor cor = new Cor("azul"); cada objeto vai
    receber uma instância diferente da cor azul!
* Variáveis da classe (static)
  - Compartilhada por todas as instâncias daquela classe
  - mudou em uma, mudou em todas
  - Pode ser acessado via classe: Alien.vx
  - Em uma declaração como public static Cor cor = new Cor("azul");
    todas as instâncias compartilharaão a *mesma* instância
    da cor azul.
* Classe Canhao
  - O construtor pode receber bem poucos parâmetros, devendo
    se concentrar apenas nos parâmetros que a gente quer mudar
    de objeto para objeto. Todos os canhões serão basicamente
    iguais, exceto pela posição deles no eixo x.
* Classe Tiro
  - Instâncias de Tiro "sabem" de qual canhão saíram: campo
    de tipo Canhao. Quando um tiro é criado o canhão que o criou
    deve ser passado como parâmetro para o construtor
* Juntando tudo: classe Jogo
  - dois jogadores
  - vetor de alienígenas (número de alienígenas não aumenta)
  - tiros precisam ser criados e esquecidos: vetor é incoveniente.
    Vamos usar uma classe que java já oferece para isso:
    java.util.ArrayList. Pense nela como um vetor que cresce
    e diminui automaticamente à medida que elementos são
    adicionados e removidos.
  - construtor de Jogo não tem parâmetros, já que toda instância
    de Jogo "nasce" igual às outras. O construtor é complicado
    por causa do posicionamento dos alienígenas.

3. Métodos
  
Métodos definem as operações que um objeto pode fazer. São
declarados de modo parecido com funções, só que sem o atributo
"static". Dentro de um método, a variável this é uma referência
para o objeto no qual esse método foi chamado.

A sintaxe para chamar um método é uma mistura da sintaxe de
se acessar um campo com a sintaxe de chamar uma função. O objeto
que está sendo usado para chamar o método vira o this do método,
e os argumentos da chamada são os parâmetros do método.

