PM 14/09/2011

// notasdogarcia.blog.com
//
// Aula de hoje parece que vai iniciar um novo tópico, que é a linguagem Java.

  Começamos falando de James Gosling e sua equipe (sun, 1995)
  Foi ele que veio com a ideia do Java e também quem o criou.
  Java é uma linguagem compilada para uma linguagem assembly de uma máquina virtual (máquina virtual Java).
  Esse código assembly é posteriormente interpretado para uma máquina real.

  Uma das grandes vantagens disso é a portabilidade.
  Pois dada qualquer arquitetura voce consegue criar uma maquina virtual Java para a mesma, e essa máquina deve ser capaz
  de interpretar o Java Bytecode de qualquer programa java, de forma que um mesmo programa não precisa ser recompilado para arquiteturas diferentes.

  É uma linguagem:
  - Simples orientada a objetos,
  - Robusta e segura.
  - Arquiteturalmente neutra e portável.
  - Alto Desempenho - (isso não é tão verdade, é ate funcional, mas como é uma interpretação é umas 10 vezes mais lento que um programa traduzido)
  - Interpretada, multi-thread e dinâmica.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Java é mais simples que C++.

 - Sem ponteiros, apenas referências.
 - Sem funções (ponteiros para funções) apenas métodos estáticos.
 - Não tem variaveis globais, apenas atributos estáticos.
 - Sem free e delete, mas tem um coletor de lixo que cuida disso pra voce.
 - Sem arquivos de header, (mas tem interfaces).
 - Sem sobrecarga de operadores apenas de metodos.
 - Sem preprocessador, mas com membros final.
 - Sem herança multipla de classes mas com herença multipla de interfaces.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Java é mais segura que C++, voce não consegue apontar para qualquer lugar na memória, voce é vigiado.
  - Não existe aritimetica de ponteiros.
  - Não existem casts não-verificados. Exemplo: (char*) 2
  - Não existem acessos além dos limites de um vetor: ex: buffer[-1];

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Vasta gama de bibliotecas para:
  - Construção de interfaces gráficas (java.awt e javax.swing)
  - Programação distribuída (java.rmi)
  - Programação multithread (java.lang.threads)
  - Entrada/saída e redes: (java.io, java.net)
  - Estruturas de dados (java.util)
  - Bancos de dados (java.sql)
  - etc

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Todo programa dentro de java fica dentro de uma classe.

  ex:

  //arquivo HelloWorld.java:

public class HelloWorld
{
  public static void main ( String [] args)
  {
    System.out.println("Hello, World!");
  }
}

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Sintaxe e os tipos primitivos de java são basicamente os mesmo do C++, sem nenhuma mudança notável exceto talvez pelo tipo String
  que é um tipo primitivo em java mas não o é em C.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Em Java todos os objetos voce inicializa com new e todos ficam armaezenados no heap.
  Como em Java não existem ponteiros, não existe a sintaxe: Objeto->variável
  Ao invés disso sempre se usa um . para como se Objeto não fosse um ponteiro.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Coletor de Lixo:

  Seu programa não roda sozinho, de tempos em tempos é lançado uma thread responsável por buscar e desalocar objetos que já não estão mais em uso.

  Isso é muito útil já que a maioria dos erros em C e C++ são devido a ponteiros, e liberações de memória,
  Tirando a responsábilidade de desalocagem de memória das mãos do programador, voce tira uma grande fonte de erros.

  - Vantagem: - Simplifica a vida do programador

  - Desvantagens: - Torna a execução do programa mais lenta.
                  - Pode acontecer de voce desperdiçar algum espaço de memória temporáriamente até que o coletor consiga realizar seu trabalho adequadamente.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Se voce declarar um metodo chamado de finalize() em uma classe a cada vez que o coletor de lixo desalocar um objeto dessa classe ele irá chamar o finalize().
  // É equivalente a função destruidora do C++.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Em java não tem criação de objetos por valor!, apenas por referência!
  ou seja se eu declaro:

  point p1;

  p1 é um ponteiro e só terá valor se for incializado na forma:

  p1 = new Point();

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Em uma função não estática, voce pode usar o this assim como em C++, porém ao invés da setinha "->" use o ponto para referenciar suas variáveis.

  A classe string é um tipo em Java para cadeias constantes de caracteres, e possui várias funções pré-criadas para ela.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Em java não existe o comando "virtual" ao se criar um método.
  A maioria dos métodos já são considerados virtuais por default.
  Ou seja chamadas de métodos são dinâmicas.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Toda classe direta ou indiretamente é sub-classe da classe Object.

  Utilidade: Uma variável do tipo objetct pode se referir a qualquer instancia de qualquer classe.

  É semelhante à tipagem dinâmica em C, voce pode igualar uma variável object a uma string, um struct, uma classe qualquer coisa.

  Se uma coerção falhar em tempo de execução é lançada uma exceção: ClassCastException.
  Ou seja se voce fizer str = inteiro; da erro em tempo de execução.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Voce pode evitar que uma classe seja herdada por outras usando a seguinte declaraçào:

  final class batata {...}

  Assim se eu fizer:

  class feijao extends batata { ... } // da erro.

  A vantagem disso é que existe carregamento dinâmico de classes em Java, assim alguém pode colocar uma redefinição
  dinâmica de alguma função da sua classe possivelmente provocando algum efeito malicioso em seu software, e escrever final previniria isso.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Um método final int metodo(){...}

  é um método que não pode ser redefinido em um dos filhos de sua classe.

  A vantagem deste é a mesma descrita anteriormente.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  final int pi=3.1415; // É uma variável cujo valor não pode ser alterado.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Classes e métodos abstratos:

  abstract class Figura
  {
    abstract int area();
    abstract int circunferencia();
  }

  Se uma classe tiver uma única função abstrata ela também deve ser abstrata e carregar abstract em sua definição assim como no exemplo acima.
  // Acho que voce não pode alocar um objeto do tipo abstract, apenas declara-la e iguala-la a uma classe filha.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Interface:

  Interface pode ser definido como uma classe cujo todos os métodos são abstratos, e não é necessário escrever abstract na frente deles.

  ex:

  interface Comparable
  {
    int compareTo(Objetct o);
  }

  Como se usa isso?

  Voce garante que tudo o que "implementar" uma interface vai conter um conjunto de características.
  Gerando um tipo que voce seguramente pode usar em uma função.

  ex:

  class batata implements Comparable { ... }

  Uma classe desse tipo tem a obrigação de redefinir todas as funções da interface, sem exceção.

  Assim eu posso saber que minha classe batata é comparável ou seja "compativel com a interface Comparable",
  e deve ter uma função compareTo que funcionará de maneira adequada.
  Então posso pedir como parâmetro de função um "func(Comparable C)"

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Assim eu posso adicionar à uma classe várias características que me pareçam coerentes.
  Se quero que exista uma meio de comparar meu tipo batata uso implements Comparable, se quero que exista um jeito de somar
  uso implements Somavel, e assim por diante, só tenho de garantir que a cada implements eu vou de fato implementar as funções respectivas.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Se uma interface b extends uma classe voce ao implementar essa interface tem de redefinir também os métodos de B.

// Fim da aula.