Sejam bem vindos, esta é a décima aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Na última aula fizemos uma introdução ao ambiente Java, incluindo a instalação do ambiente de desenvolvimento NetBeans. Hoje, vamos fazer uma viagem sobre a linguagem vendo o que ela tem de essencial.

Em minha opinião esta é a mais importante aula do curso até agora.

Java é uma linguagem Orientada a Objeto

A programação em java consiste em manipulação e criação de objetos.

Objeto

Em programação, objetos são representações computacionais de entidades reais, ou abstratas. Eles representas pessoas, entidades. Ou mesmo coisas mais ou menos abstratas, como uma música, ou uma conta bancária.

Todos objetos tem estados: uma pessoa tem nome, idade, Rg, etc. Uma música tem título, interprete, etc. Uma conta bancária tem seu saldo, seu número de identificação, titular da conta, etc.

Programadores podem chamar métodos ou ações no objeto para realizar computações que podem potencialmente modificar o estado do objeto:

• Programador: Quantos anos você tem ? <<método
• Objeto: Eu tenho 10. <<valor de retorno do método
• Programador: Hoje é seu aniversário! <<outro método
• Objeto: Eu tenho que somar 1 à minha idade. <<provocou mudança

• Programador: Qual seu saldo?
• Objeto Conta Bancária: Saldo igual a R$ 2940,00
• Programador: Sacar 100 reais
• Objeto: Eu tenho que atualizar o saldo para R$ 2840,00

Um programa em Java:

package ola;
import java.util.System;
class OlaMundo {
  String minhaString;
  void vaiLa() {
    minhaString = new String("Olá, Mundo!“);
    System.out.println(minhaString);
  }
  public static void main(String[] args) {
    AloMundo meuAloMundo = new AloMundo();
    meuAloMundo.vaiLa();
  }
}

Classes

Classes por sua vez são modelos para fazer Objetos. Programar em Java consiste em escrever classes. Todo o código de Java está dentro de classes.

class HelloWorld { //nome da classe
  ... <toda a programação> ...
}

Campos

Campos também chamados variáveis, são usadas para armazenar o estado do Objeto.

class Pessoa {
  int idade; // <<= variável ou campo
}
<classe do objeto> <nome da variável/campo>;

Construindo Objetos

Pessoa luis = new Pessoa();

Para a construção de um objeto usa-se o código “new” conforme o exemplo acima. Objetos são criados a partir de uma classe, são instâncias das classes. O código “new Pessoa()” cria um objeto na memória do computador, especificamente no Heap do Java.

No código acima luis é um ponteiro para o objeto. Isto é, o Objeto que foi criado é armazenado em uma área de memória do computador, a variável luis armazena o endereço desta posição de memória.

O código acima “luis = ” atribui o endereço do objeto na memória para a variável luis.

<tipo> <nome da variável> = new <nome da classe>();

Usando objetos

Depois de criado, um objeto pode ser usado assim:

Pessoa luis = new Pessoa();
luis.idade=33; //use "." para acessar os campos
Pessoa elaine = new Pessoa();
elaine.idade=32;
System.out.println(luis.idade); // imprime 33 na tela
System.out.println(elaine.idade); //imprime 32 na tela

Tipos Primitivos

Em Java nem tudo são objetos. Algumas coisas são tão simples, que não compensa usar objetos para representá-los: boolean, byte, short, int, long, double, float, char. São respectivamente tipo lógico, número, inteiro curto, inteiro, inteiro longo, número ponto flutuante duplo, ponto flutuante simples, caracter.

boolean

Um valor verdadeiro ou falso.

byte

Valor numérico inteiro com sinal de 8 bits

short

Valor numérico inteiro com sinal de 16 bits

char

Caracter unicode de 16 bits

int

Valor numérico inteiro com sinal de 32 bits

long

Valor numérico inteiro com sinal de 64 bits

float

Valor numérico de ponto flutuante padrão IEEE754 de 32 bits

double

Valor numérico de ponto flutuante padrão IEEE754 de 64 bits

Para armazenar texto, não usamos um tipo primitivo, temos uma classe String:
String nome=new String(“José das Couves”);

Métodos

São ações que podemos realizar sobre os objetos, que podem mudar seu estado.

<tipo do retorno> <nome do método>(<parâmetros>) {
<corpo do método>
}

No exemplo AloMundo no inicio da aula temos dois métodos definidos: vaiLa e main:

meuAloMundo.vaiLa();
// use ‘.’ para acessar o método

Construtores

Construtores são tipos especiais de métodos que não retornam valores, usados para iniciar campos, aceitam parâmetros e tem corpo de método normal. Tem o mesmo nome da classe, inclusive iniciando com letra maiúscula:

class Pessoa{
  int idade;

  Pessoa(){ //início do contrutor
    idade=18; // ao criar um objeto do tipo Pessoa a idade será iniciada
                   // com 18 anos em todos os objetos;
    } //fim do construtor
}

Corpo do Método

String primeiroNome(String nomeCompleto) {
  int espaco = nomeCompleto.indexOf(“ ”); //posição onde está o espaço
  String palavra = nomeCompleto.substring(0, espaco);
  return palavra;
}

Pode-se definir qualquer número de parâmetros, separando por vírgula (no exemplo nomeCompleto). Pode-se declarar variáveis locais(espaco, palavra). Deve sempre retornar alguma coisa (String palavra). No caso de um método não necessitar retorno usa-se void no tipo de retorno (void=nada).

void seuAniversario(){ >>exemplo de método void para a classe Pessoa
  idade++;
}

Controle de Fluxo

O comando “if” permite controle sobre ações que devem ser realizadas de acordo com as situações do programa:

if(luis.idade<18){
  System.out.println("Proibido para menores");
} else if(luis.temCartaoCredito(){
  System.out.println("Seja bem vindo!");
} else {
  System.out.println("Sai fora, tá pensando que é de graça?");
}

if(condição 1){
…
} else if (condição2) {
…
} else if (condiçãoN) {
…
}else { … }

Condições

As condições do “if” são expressões que são booleanas, valem Verdadeiro ou Falso. Para construir usar os operadores:

• < menor
• > maior
• == igual
• <= menor ou igual
• >= maior ou igual
• ! negação

Exemplos:

caixa.isVazia();
caixa.numeroLivros()==0
!(caixa.numeroLivros()>1) negação: número de livros na caixa NÃO é maior que 1)
caixa.numeroLivros!=MAX_NUMBER_BOOKS
caixa.numeroLivros%2==0 //verifica se o resto da divisão por 2 é zero (isso é, se o número de livros é par)

Repetição For (loops)

Repete um trecho de código, controlando por uma variável:

for (int i = 0; i < 3; i++) {
  System.out.println(i); // imprime 0 1 2
}

for (<inicialização> ; <condição> ; <incremento>) {
…. // trecho de código que repete
}

Inicialização é executado uma única vez antes do trecho repetido. A condição é verificada após a inicialização e antes de repetir o trecho. Incremento é realizado todas as vezes após o trecho repetido.

Para de repetir quando a condição passa a ser falsa.

Repetição While

Repetição de um trecho de código enquanto (while) uma condição for verdadeira.

int i = 0;
while(i<3) {
  System.out.println(i); //imprime 0 1 2
  i++;
}

while (<condição>) {
…
}

Combinando Condições

Quando temos mais de uma condição para testar usamos “&&”: E lógico ou “||”: OU lógico.

• luis.idade>=18 && luis.temCartaoCredito()
• alguem.nome.equals(“Luis”)||alguem.nome.equals(“Lima”)
• (!true || false)&& true (resposta=false)

Matrizes ou arrays

Lista de objetos identificados com um único nome, mais números de ordem.

String[] animais = new String[2]; // dois objetos String
animais[0] = new String("Rex");
animais[1] = "Lulu"; // forma simples de criar String
String[] animais= new String[] {"Rex","Lulu"};
System.out.println(animais.length); // 2 ítens na matriz

Objetos wrapper dos tipos Primitivos

Os tipos primitivos em algumas situações são interessantes serem manipulados como objetos. A biblioteca Java possui classes que representam cada tipo de variável primitiva: Integer para int, Float para float, Double para double, Boolean para boolean, etc.

Usando os wrappers

Integer a= new Integer(3); // cria objeto Integer e inicia com valor 3;
Integer sum = a.add(5); // cria objeto Integer com o valor de a+5;

Wrappers em Arrays

Integer notas= new Integer[50]; // 50 objetos Integer

Cuidado ao usar Objetos

• Não tentar acessar array fora de faixa
  animais[5] >> excessão ArrayOutOfBoundsException;
• Acessar variável sem criar objeto correspondente
  String[] str;
  str.length >> NullPointerException
• Erros de interpretação de uso
  Integer a = new Integer(3); //a=>3
  a.add(5); //calcular a+5, não muda valor de a=>3
  a=a.add(5); //agora sim: a=>8

Resumo

• Variáveis
  • Variáveis apontam para objetos;
  • Variáveis apontam objetos de uma classe em particular;
  • Integer x; Declara uma variável;
• Objetos
  • Classes definem objetos
  • Objetos são instâncias de uma classe em particular;
  • new Integer(3); Constrói um objeto;

Representação Objeto vs Variáveis

Um exemplo visual de objetos e variáveis durante a execução de um programa java:

Temos dois objetos da classe Integer com o valor 3 armazenado. E temos 4 variáveis: num, x, y e z. As variáveis num e x apontam para o mesmo objeto. A variável z não aponta para nenhum objeto.

Null

Variáveis sem objetos relacionados apontam para null. null não é um objeto, é apenas uma indicação para a não existência de objeto relacionado com uma variável.

Utilizar uma variável com valor Null para verificar um campo de um objeto irá causar um erro (NullPointerException):

Pessoa joao;
joao.idade=10; // NullPointerException, não existe objeto relacionado à variável joao, portanto não existe o campo idade.

Mudando um objeto através das variáveis

Para atribuir um objeto à uma variável, utilize o operador “=”. Com isso é possível fazer mais de uma variável apontar para o mesmo objeto. Este recurso pode provocar um efeito chamado mutação de objetos compartilhados:

public class MutationExample {
  public static void main(String[] args) {
    List<String> a = new ArrayList<String>();
    List<String> b;
    b= a; // b e a compartilham a lista
    a.add(“Alo, Mundo!”);
    System.out.println(b); // imprime "Alô, Mundo!"
  }
}

No exemplo, a e b são variáveis apontando para a mesma lista. Usando “a.add(…” modificamos o objeto lista. Quando imprimimos “b”, a variável aponta para o mesmo objeto modificado, e portanto mostra o valor “Alô, Mundo!”.

Campos e Métodos Estáticos e Não estáticos

Campos e métodos também são chamados membros de uma classe. Por padrão são não estáticos.

Membros estáticos são aqueles que são compartilhados entre cada Instância/Objeto da classe.

Um campo estático, compartilha seu valor entre cada objeto da classe.

Campos não Estáticos

public class Livro {
  public int livroCounter = 0;
  public Livro() {
    livroCounter++;
  }
  public static void main(String[] args) {
    new Livro(); new Livro();
    Livro biblia = new Livro();
    System.out.println(biblia.livroCounter); // Imprime 1
  }
}

Campos Estáticos

public class Livro {
  public static int livroCounter = 0; // <<== campo estático
  public Livro() {
    livroCounter++;
  }
  public static void main(String[] args) {
    new Livro(); new Livro(); new Livro();
    System.out.println(Livro.livroCounter); // Imprime “3”: observe Livro se refere à classe
  }
}

Campos Estáticos devem ser chamados a partir do nome da Classe. São únicos para todos os objetos da classe.

Métodos Não Estáticos

public class livro {
  private boolean lido = false;
  public void leiaLivro() {
    lido = true;
  }
  public static void main(String[] args) {
    Livro livro = new Livro();
    livro.leiaLivro(); // Invocado através do objeto
  }
}

Métodos Estáticos

public class Livro {
  private boolean lido = false;
  public static void leiaLivro(Livro livro) {     // <<== metodo estático
    livro.lido = true;
  }
  public static void main(String[] args) {
    Livro livro = new Livro();
    Livro.leiaLivro(livro); // método invocado através da classe
    // “livro.leiaLivro(livro);” válido mas desaconselhado!
  }
}

Métodos estáticos são chamados através da classe, e só tem acesso a dados estáticos.

Objetos passados por referência

Parâmetros de métodos podem ser por referência ou valor. Objetos por padrão são passados por referência. Isso é, mudanças no objeto dentro da função se propagam para fora da mesma.

public static <T> void removePrimeiro(List<T> lista) {
  lista.remove(0);
}
public static void main(String[] args) {
  List<String> minhaLista = new ArrayList<String>();
  minhaLista.add(“Gato”);
  minhaLista.add(“Cachorro”);
  removePrimeiro(minhaLista);
  System.out.println(minhaLista); // imprime [Cachorro]
}

Tanto a variável “minhaLista” no método “main” e a variável “lista” no método “removePrimeiro” se referem ao mesmo objeto na memória (veja a e b em “Mudando um objeto através das variáveis” acima)

Escopo

Escopo de variáveis está relacionado à que partes do programa podem acessar uma variável. Dependendo de onde a variável está definida seu escopo muda.

As Chaves {…} definem uma área de escopo. Quando uma variável é definida dentro de uma área de escopo, é somente visível dentro desta área. Ao final da execução de uma área de escopo, as variáveis internas são automaticamente destruídas.

O escopo dos campos das classes são todos os métodos da classe. Isso é, um campo de um objeto da classe é acessível por todos os métodos daquele objeto.

Os parâmetros de um método, funcionam exatamente como uma variável do método. Existe até o fim da execução do método.

Exemplos de Escopo

Alguns toques:

• Atribução: variáveis apontam objetos. Cuidado com ponteiros nulos;
• Static: não invocar métodos estáticos pelos objetos
• Passagem por referência: faça uma cópia se quizer se prevenir de uma mudança acidental;
• Escopo: minimize o escopo das variáveis o mais possível. Não faça tudo global

Como você pode ver, esta é a aula mais pesada do curso. Não deixe as dúvidas acumularem. Faça os exercícios. Tire suas dúvidas no Fórum, é para isso que está disponível. Não se acanhe. O curso só melhora com a participação de vocês.

Aprofundando

• Procure no Java Tutorial da Sun, os tópicos abordados nesta aula.
• Faça um estudo de operadores Java.
• Faça um estudo da classe java.lang.Math.
• Faça um estudo da classe java.lang.String.
• Qualquer dúvida vá ao fórum.

Exercícios

• Faça um programa para mostrar os números pares de 1 a até 100;
• Faça um método que verifique se um número é primo; (chamado isPrimo)
• Faça um programa para mostrar os números primos de 1 a 50;
• Transforme o método isPrimo em um método estático;
• Refaça o programa para usar o método estático;
• Faça uma função que verifique os números primos de uma lista e exclua todos os números não primos da mesma.

Na Seqüência

• dia 18 de dezembro: Classes, Interfaces e Polimorfismo.
• dia 25 de dezembro: folga é Natal. Entraremos em recesso com o curso, estaremos de volta dia 22 de janeiro, ao final de minhas férias.
• dia 22 de janeiro: Coleções, Hashing e Comparadores.

Dúvidas? vá para o fórum.

Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.