Aula 10: Java Essencial

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:

Heap 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

Exemplo de Escopo

Exemplo de Escopo 1

Exemplo de Escopo 2

Exemplo de Escopo 2

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.

Outros Artigos:

21 comentários para “Aula 10: Java Essencial”

  1. Nilton disse:

    No final da aula 10, onde mostra exemplo de escopos, 02 imagens não estão sendo carregadas.

  2. Luciano disse:

    oi prefessor,

    o atalho é ALT+Shift+F, e não Ctrl+Shift+F.

    Ctrl+Shift+F abre a janela de busca (find).

    Tecnoclasta responde:
    Obrigado Luciano, texto devidamente corrigido.

  3. João Carlos disse:

    Em determinada parte está escrito:

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

    Na verdade esse código instancia 40 objetos integer, e não 50 como está no comentário.

    Também ficou faltando o ; no fim da declaração :-)

    Abs,

    Tecnoclasta responde:
    Muitíssimo obrigado pela correção. Os alunos agradecem!

  4. Olá professor, gostaria de postar meus exercicios aqui para que voce pudesse corrigir e para que os alunos que estivesserem com dificuldades arranjarem um pequeno “norte” sobre o assunto.

    Ate logo.

  5. //Exercicio 1: Listar numeros pares;
    public static void listaNumeros() {
    System.out.print(“São pares:\n”);
    for(int i=1;i<=100;i++){

    if(i%2 == 0){
    System.out.print(i+”\n”);
    }
    }
    }

    //Exercicio numero 2; Verificar se um determinado numero é primo
    public static void verificarPrimo(int numeroParaVerificar) {
    boolean ehPrimo = true;
    int divisoes = 1;
    for (int i = 2; i <= numeroParaVerificar; i++) {
    if (numeroParaVerificar % i == 0 && numeroParaVerificar !=i) {
    ehPrimo = false;
    break;
    }
    divisoes++;
    }
    System.out.print(“Fizemos um total de ” + divisoes + ” divisões ate” +
    ” chegarmos a conclusao de que o numero ” + numeroParaVerificar);
    if (ehPrimo) {
    System.out.print(” é primo.”);
    } else {
    System.out.print(” náo é primo.”);
    }

    System.out.print(“\n\n”);
    }

    //Exercicio numero 3; Listar primos de 1 a 50 @ aceita até mais do que 50.
    public static void listarPrimos(int numeroInicial, int numeroFinal){
    boolean ehPrimo = true;
    for(int i=numeroInicial;i<=numeroFinal;i++){
    System.out.print(“O numero “+i);
    for(int j=1;j<=i;j++){
    if(i%j == 0 && i!=j && j!=1){
    ehPrimo = false;
    }
    }
    if(ehPrimo)
    System.out.print(” é primo.”);
    else {
    System.out.print(” não é primo.”);
    ehPrimo =true;
    }

    System.out.print(“\n”);
    }
    }

    Amanha terminarei os outros!
    :}

  6. [...] Onde colocar o import? Vá fazer uma revisão em minha aula sobre java básico. [...]

  7. Lucas Santana disse:

    cara to com muita dificuldade nos exercicios !
    os exercicios acima estão corretos ?

  8. Claudio Filho disse:

    Professor porque o package appalomundo espera uma class se logo embaixo dele está a “public class AloMundo”???
    [code]

    /*
    * AloMundo.java
    *
    * Created on 17 de Fevereiro de 2010, 00:40
    *
    * To change this template, choose Tools | Template Manager
    * and open the template in the editor.
    */
    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();

    }
    }

    package appalomundo;

    /* Aqui ele acusa o seguinte erro:"D:\DOCUMENTOS\claudinho\java\AppAloMundo\src\appalomundo\AloMundo.java:25: class, interface, or enum expected
    "

    /**
    *
    * @author Administrador
    */
    public class AloMundo {

    /** Creates a new instance of AloMundo */
    public AloMundo() {
    System.out.println("Alô Mundo!!!");

    }

    /**
    * @param args the command line arguments
    */
    public static void main(String[] args) {
    AloMundo objeto = new AloMundo();

    // TODO code application logic here
    }

    }
    [/code]

    • Não sei se entendi, mas isso é um arquivo só? Se for, você está tentando definir classes em packages separados (appalomundo e ola) no mesmo arquivo, e isso não é permitido.

      Revise o arquivo, mantendo uma única chamada a package, e uma única classe.

  9. Claudio Filho disse:

    Prof. Luis Eduardo resolvi o problema:

    Quando vc coloca

    import java.util.System();

    /** isto não dá certo. E ele te dá uma opção de

    add um import java.lang.System();

    Se vc adicionar o erro persiste, mas se ao invés disso vc mudar de:

    import java.util.System();

    para:

    import java.lang.System();

    o programa funciona. **\

    Não sei se teve algum erro de instalação no meu Netbeans acho que não, mas se alguem estiver com o mesmo problema fica aí a solução.

  10. Claudio Filho disse:

    O programa final ficou assim:
    ——————————————

    package olamundo;
    import java.lang.System;

    public class OlaMundo {
    String minhaString;
    void vaiLa(){
    minhaString = new String(“Olá Mundo!!!”);
    System.out.println(minhaString);

    }

    public OlaMundo() {
    }

    public static void main(String[] args) {

    OlaMundo meuOlaMundo = new OlaMundo();
    meuOlaMundo.vaiLa();

    }
    }

  11. Marnei disse:

    Parabéns pelas aulas.

    Encontrei um pequeno erro na explicação sobre While, faltou incrementar a variável i.

    int i = 0;
    while(i<3) {
    System.out.println(i); //imprime 0 1 2
    i++; // se não incrementar o i, ficará num loop infinito.
    }

    Abraço

  12. dhenyson disse:

    oh professor nao to xingano suas aulas ma spq vc nao usa videos aulas ficaria mas facio de entender!
    e acho que ficaria melhor pra voce tbm.só filmar e publicar^^.

    mas ta legal suas aulas..

  13. Oi caríssimo professor, gostaria de parabenizá-lo pelo excelente material disponibilizado; muito obrigado. Abraços.

  14. Suelen disse:

    Olá professor Luiz, boa noite.

    Primeiramente venho lhe parabenizar pela ajuda que você dá aos iniciantes, elas são de grande valia.

    Gostaria do seu auxílio no seguinte problema:
    Preciso calcular dentro do java duas variáveis de data.
    As duas serão digitadas pelos usuário e no fim o programa terá que subtrair uma pela outra pra saber quantos anos se passaram dentre elas.

    Obs.: Ainda não posso utilizar orientação à objetos, sou iniciante mesmo rsrs.

    Agradeço desde já.

  15. Andrei Barbosa disse:

    Olá Prof. Estou seguindo suas aulas, mas não consigo compilar de jeito nenhum os programas deste blog. Estou utilizando o NetBeans IDE 7.2, sugerido no site. Mas quando eu copio algum código e tento compilar, sempre me dá uma msg de erro. Eu tenho uma noção de como utilizar o compilador pelo C++ que era dois passos, compilar e linkar… No Java eu aperto o botão para rodar o programa e aparece erro. Será que você não consegue um passo a passo para iniciantes de como rodar um código básico ??

  16. Luis Alberto Fiuza disse:

    Desculpe, mas uma pessoa que não entende nada de Java, vai chegar aqui e ficar é mais confuso ainda!! Mas, normal, cada um ensina de um jeito. E esse aqui é um dos piores que já encontrei. Quem já conhece algo sobre o assunto vai chegar e se identificar. Mas pros totalmente leigos será triste.

Deixe um comentário