Use o código e tenha 10% de desconto!

Desbravando Java e Orientação a Objetos Um guia para o iniciante da linguagem

Rodrigo Turini
Capa

Desbravando Java e Orientação a Objetos: Um guia para o iniciante da Linguagem

"À minha esposa Jordana e ao maior presente que um dia sonhei receber, nossa filha Katherine."

Agradecimentos

Não há outra maneira de começar este livro que não seja agradecendo a todos que incentivaram e contribuíram direta ou indiretamente em sua edição. Victor Harada, Maurício Aniche e Guilherme Silveira foram alguns deles.

Fica um agradecimento especial ao Paulo Silveira, não só pela sua detalhada revisão e suas diversas sugestões e melhorias para esse livro, mas também pela influência direta que tem em meu dia a dia profissional.

Gostaria também de estender o agradecimento para toda equipe da Caelum. São profissionais exemplares que me incentivam a aprender e ensinar diariamente.

Sumário

  • 1 - Java
    • 1.1 - Nosso primeiro código Java
    • 1.2 - Algumas regras e convenções
    • 1.3 - Entendendo o método main
    • 1.4 - Trabalhando com uma IDE
    • 1.5 - Acesse o código desse livro e entre em contato conosco
  • 2 - Variáveis e tipos primitivos
    • 2.1 - Nosso projeto
    • 2.2 - Declaração e atribuição de variáveis
    • 2.3 - Tipos primitivos
    • 2.4 - Casting de valores
    • 2.5 - Adicionando condicionais
    • 2.6 - Loopings e mais loopings
  • 3 - Orientação a objetos
    • 3.1 - Criando um molde de livros
    • 3.2 - Criando um novo método
    • 3.3 - Objetos para todos os lados!
    • 3.4 - Entendendo a construção de um objeto
    • 3.5 - Vantagens da orientação a objetos
  • 4 - Encapsulamento
    • 4.1 - Limitando desconto do Livro
    • 4.2 - Isolando comportamentos
    • 4.3 - Código encapsulado
    • 4.4 - Getters e Setters
    • 4.5 - Definindo dependências pelo construtor
  • 5 - Herança e polimorfismo
    • 5.1 - Trabalhando com livros digitais
    • 5.2 - Reescrevendo métodos da superclasse
    • 5.3 - Regras próprias de um LivroFisico
    • 5.4 - Vendendo diferentes tipos de Livro
    • 5.5 - Acumulando total de compras
    • 5.6 - Herança ou composição?
  • 6 - Classe abstrata
    • 6.1 - Qual o tipo de cada Livro?
    • 6.2 - Minilivro não tem desconto!
    • 6.3 - Método abstrato
    • 6.4 - Relembrando algumas regras
  • 7 - Interface
    • 7.1 - O contrato Produto
    • 7.2 - Diminuindo acoplamento com Interfaces
    • 7.3 - Novas regras da interface no Java 8
  • 8 - Pacotes
    • 8.1 - Organizando nossas classes
    • 8.2 - Modificadores de acesso
  • 9 - Arrays e Exception
    • 9.1 - Trabalhando com multiplicidade
    • 9.2 - As diferentes exceções e como lidar com elas
    • 9.3 - Muitas e muitas Exception
    • 9.4 - Também podemos lançar exceções!
  • 10 - Conhecendo a API
    • 10.1 - Todo objeto tem um tipo em comum
    • 10.2 - Wrappers dos tipos primitivos
    • 10.3 - O pacote java.lang
  • 11 - Cellection Framework
    • 11.1 - O trabalho de manipular arrays
    • 11.2 - Ordenando nossa List de produtos
    • 11.3 - Gerenciando cupons de desconto
    • 11.4 - java.util.Map
  • 12 - Streams e novidades do Java 8
    • 12.1 - Ordenando com Java 8
    • 12.2 - forEach do Java 8
    • 12.3 - Filtrando livros pelo autor
  • 13 - Um pouco da história do Java
    • 13.1 - Origem da linguagem
    • 13.2 - Escreva uma vez, rode em qualquer lugar!
    • 13.3 - Linha do tempo
  • 14 - Continuando seus estudos
    • 14.1 - Entre em contato conosco
Capítulo1

Java

1.1 - Nosso primeiro código Java

No lugar de começar com conceitos e teorias, vamos logo partir para uma boa dose de prática! Abra seu editor de texto preferido e escreva o seguinte código Java:

class MeuPrimeiroPrograma {
  
  public static void main(String[] args) {
    System.out.println("O primeiro de muitos!");
  }
}

Esse programa imprime um texto simples. Confuso? Não se preocupe, em breve cada uma dessas palavras terá seu sentido bem claro.

Salve o arquivo em algum diretório de sua preferência, mas é importante que ele se chame MeuPrimeiroPrograma.java.

Nosso próximo passo será compilar esse código fonte. Faremos isso manualmente utilizando o javac, compilador padrão da Oracle.

Abra seu terminal e digite javac MeuPrimeiroPrograma.java. Note que para isso você precisa estar na mesma pasta do arquivo, ou passar o caminho completo para ele.

Navegando pelas pastas e listando arquivos

Você pode utilizar o comando cd (change directory) para navegar pelas suas pastas via terminal. Um exemplo em Windows seria:

D:\> cd Desktop\livro
D:\Desktop\livro>

O mesmo comando pode ser utilizado em um ambiente Unix (Linux ou Mac OS). Para listar, há uma diferença. Em Windows utilizamos o comando dir:

D:\Desktop\livro> dir
  MeuPrimeiroPrograma.java 
  MeuPrimeiroPrograma.class

Porém, nos outros sistemas que foram citados o comando será ls. Repare:

turini ~ $ cd Desktop/livro
turini/Desktop/livro ~ $ ls
  MeuPrimeiroPrograma.java 
  MeuPrimeiroPrograma.class

Note que, se nenhum erro de compilação ocorrer, no mesmo diretório agora existirá um novo arquivo com o mesmo nome de nossa classe Java (neste caso, MeuPrimeiroPrograma), porém a sua extensão será .class. Este novo arquivo é o bytecode gerado pelo compilador.

Para executá-lo, ainda pelo terminal, digite o comando java MeuPrimeiroPrograma. O comando java é o responsável por executar a JVM (máquina virtual, ou Java Virtual Machine) que irá interpretar o bytecode de seu programa. Repare que neste comando não passamos a extensão do arquivo:

turini/Desktop/livro ~ $ java MeuPrimeiroPrograma
  O primeiro de muitos!

E pronto! Você já compilou e executou o seu primeiro programa em Java.

Não se preocupe, a JVM, bytecode e outros conceitos e siglas importantes serão melhor detalhados mais à frente.

Instalação do Java

Para executar os códigos deste livro, você precisará ter o JDK (Java Development Kit) instalado. Se precisar, você pode seguir as instruções do link a seguir para instalar de acordo com seu sistema operacional:

http://www.caelum.com.br/apostila-java-orientacao-objetos/apendice-instalacao-do-java/

Precisa de ajuda? Não deixe de nos mandar um e-mail no grupo:

https://groups.google.com/d/forum/livro-java-oo

1.2 - Algumas regras e convenções

Você pode ter reparado que seguimos algumas regras e convenções até agora. Vamos entendê-las um pouco melhor.

Podemos começar pelo nome de nosso arquivo, MeuPrimeiroPrograma. Em Java, o nome de uma classe sempre se inicia com letra maiúscula e, quando necessário, as palavras seguintes também têm seu case alterado. Dessa forma "esse nome de classe" vira "EsseNomeDeClasse". Essa abordagem é bastante conhecida como CamelCase.

Um arquivo .java possui a definição de uma classe. É uma prática recomendada nomear a classe e o arquivo da mesma forma, caso contrário poderá existir alguma confusão no momento de executá-la. Por exemplo, considere que temos um arquivo meu-primeiro-programa.java contendo a classe que chamamos de MeuPrimeiroPrograma. Para compilá-lo faremos:

turini/Desktop/livro ~ $ javac meu-primeiro-programa.java

Porém, o arquivo compilado (com o bytecode) terá o nome MeuPrimeiroPrograma.class. Como executar esse programa? A resposta será com o nome da classe, e não do arquivo. Neste caso:

turini/Desktop/livro ~ $ java MeuPrimeiroPrograma

Note também que há um par de chaves {} definindo o inicio e final (escopo) de sua classe e as instruções sempre terminam com ponto e vírgula.

Por fim, é fundamental perceber que esta é uma linguagem case sensitive, ou seja, leva em consideração o case (caixa) em que as instruções são escritas. Escrever System com letra minúscula, por exemplo, resultaria em um erro de compilação.

Você pode ler mais a respeito dessas e de outras convenções da linguagem no documento oficial Code Conventions for the Java Programming Language, disponível no site da Oracle:

http://www.oracle.com/technetwork/java/index-135089.html

1.3 - Entendendo o método main

Ao ser executada, a máquina virtual (JVM) procura pelo bloco main declarado em sua classe. Esse é um bloco especial (ou método, como passaremos a chamar a partir de agora) e se parece com:

public static void main(String[] args) {
  // seu código aqui
}

Suas aplicações Java, em geral, vão possuir apenas um método main, um único ponto de partida. Quando rodamos o comando java passando o nome de nossa classe, dissemos para a JVM executar todo o conteúdo que estiver dentro do corpo (das chaves) desse método. Em nosso exemplo, foi uma simples instrução de impressão, o System.out.println("o primeiro de muitos!").

Há ainda como passar argumentos para o método main ao executar um programa Java. O parâmetro String[] args que o método recebe dentro de seus parênteses será o responsável por armazenar esses argumentos para que possam ser acessados em nosso código. Mas, afinal, o que é esse String[]? Um array de String em Java, porém, por enquanto não estamos interessados em entender um array e todos os seus detalhes, tudo o que precisamos saber é que ele vai armazenar uma multiplicidade de Strings.

Um exemplo dessa passagem de parâmetro seria:

turini/Desktop/livro ~ $ java MeuPrimeiroPrograma Java Rodrigo

Para isso funcionar, modificamos nosso código para exibir o conteúdo guardado nas posições 0 e 1 (args[0], args[1]) desse conjunto de argumentos:

class MeuPrimeiroPrograma {
  
  public static void main(String[] args) {
    System.out.println("O primeiro de muitos códigos 
      escritos em " +args[0]+ " pelo " +args[1]+ "!");
  }
}

Execute para conferir o resultado! Não se esqueça que, como modificamos nosso código, precisaremos compilar novamente:

turini/Desktop/livro ~ $ javac MeuPrimeiroPrograma.java
turini/Desktop/livro ~ $ java MeuPrimeiroPrograma Java Rodrigo

Nesse exemplo, o resultado impresso será:

O primeiro de muitos códigos escritos em Java pelo Rodrigo!

Erro de compilação?

Um erro de digitação, a falta de um ponto e vírgula ou uma diferença de case em seu código são alguns dos muitos motivos que podem resultar em um erro de compilação. Conhecer e entender esses erros é fundamental, talvez você queira inclusive provocar algum deles para ver como seu código se comparta.

Qual será a mensagem caso eu esqueça de escrever um ponto e vírgula? Escreva um teste simples pra descobrir! Um exemplo:

System.out.println("sem ponto-e-virgula")

A mensagem de erro será:

Syntax error, insert ";" to complete BlockStatements

Lembre-se que você pode e deve tirar todas as suas dúvidas no GUJ, em http://guj.com.br.

1.4 - Trabalhando com uma IDE

Escrever, compilar e executar seu código Java em um bloco de notas junto com terminal é bastante trabalhoso. É fundamental conhecer esse processo, mas em seu dia a dia você provavelmente vai preferir utilizar alguma das mais diversas ferramentas de desenvolvimento conhecidas para ajudá-lo nesse trabalho.

Essas ferramentas são chamadas de IDE (Integrated Development Environment) e podem tornar seu desenvolvimento muito mais produtivo e interessante, oferecendo-lhe recursos como syntax highlight e auto complete das instruções de seu código.

No decorrer deste livro, vamos utilizar o Eclipse, você pode fazer o download de sua versão mais recente em:

https://www.eclipse.org/downloads/

Essa é uma IDE gratuita e open source, sem dúvida uma das preferidas do mercado e instituições de ensino. Seus diversos atalhos e templates prontos são grandes diferenciais.

Existem diversas outras boas opções no mercado, como por exemplo o NetBeans da Oracle, ou o IntelliJ IDEA, sendo este último pago.

 

Criando seu primeiro projeto no Eclipse

 

Depois de fazer o download, você não precisará instalar a IDE. Esta é uma executável inteiramente escrita em Java, basta executá-la e escolher a pasta onde será a sua área de trabalho (workspace). Escolha um local de sua preferência.

Vamos criar nosso projeto! Para isso, você pode por meio do menu escolher as opções File > New > Java Project. Vamos chamar o projeto que desenvolveremos durante o curso de livraria.

Repare que, depois de concluir, esse projeto será representando em seu sistema operacional como uma pasta, dentro do workspace que você escolheu. Por enquanto, dentro desse diretório você encontrará a pasta src, onde ficará todo o seu código .java e também a pasta bin, onde ficará o bytecode compilado.

 

Produtividade extrema

 

Agora que já criamos o projeto, vamos criar nossa primeira classe pelo Eclipse. Você pode fazer isso pelo menu File > New > Class. Para conhecer um pouco da IDE, vamos criar novamente a classe MeuPrimeiroPrograma.

Depois de preencher o nome, selecione a opção finish e veja o resultado:

public class MeuPrimeiroPrograma {
  
}

A estrutura de sua classe já está pronta, vamos agora escrever seu método main. Para fazer isso, escreva a palavra main dentro de sua classe e pressione o atalho Control + Espaço.

Esse é o atalho de code completion da IDE. Se tudo correu bem, seu código ficou assim:

public class MeuPrimeiroPrograma {
  
  public static void main(String[] args) {
    

  }
}

Interessante, não acha? Além de termos mais produtividade ao escrever, evitamos que erros de digitação aconteçam.

Vamos além, agora dentro do método main, digite syso e pressione Control + Espaço para fazer code completion novamente.

Você pode e deve usar e abusar desse recurso!

public class MeuPrimeiroPrograma {
  
  public static void main(String[] args) {
    System.out.println("O primeiro de muitos!");
  }
}

Agora, com o código pronto, as próximas etapas seriam compilar e executá-lo, mas a compilação já está pronta!

Isso mesmo, conforme você vai escrevendo seu código, a IDE já cuida de compilá-lo. Repare que se você apagar o ponto e vírgula, por exemplo, essa linha ficará sublinhada em vermelho. Essa é uma indicação visual de que seu código não está compilando.

Para executar o código, você pode clicar com o botão direito do mouse em sua classe e selecionar as opções Run As > Java Application . Ou por atalho, pressionando Control + F11.

Repare que a saída de seu código vai aparecer na aba Console.

O primeiro de muitos!

Atalhos do Eclipse

Conhecer os atalhos da IDE vai torná-lo um programador muito mais produtivo. Você pode ler mais a respeito e conhecer mais atalhos pela documentação do Eclipse em:

https://www.eclipse.org/users/

E também no post:

http://blog.caelum.com.br/as-tres-principais-teclas-de-atalho-do-eclipse/

Se esse for o seu primeiro contato com a linguagem, recomendamos que você pratique bastante a sintaxe antes de partir para os próximos capítulos. Sinta-se confortável com o processo de escrever, compilar e executar seu código Java. Tenho certeza de que em breve essa será sua rotina.

1.5 - Acesse o código desse livro e entre em contato conosco

Todos os exemplos deste livro podem ser encontrados no repositório:

https://github.com/Turini/livro-oo

Mas claro, não deixe de escrever todo o código que vimos para praticar a sintaxe e se adaptar com os detalhes da linguagem. Além disso, sempre que possível faça novos testes além dos aqui sugeridos.

Ficou com alguma dúvida? Não deixe de me mandar um e-mail. A seguinte lista foi criada exclusivamente para facilitar o seu contato conosco e com os demais leitores:

https://groups.google.com/d/forum/livro-java-oo

Suas sugestões, criticas e melhorias serão muito mais do que bem-vindas!

Outro recurso que você pode usar para esclarecer suas dúvidas e participar ativamente na comunidade Java é o fórum do GUJ, espero encontrá-lo por lá.

http://www.guj.com.br/

Dados do produto

Número de páginas:
210
ISBN:
978-85-5519-058-2
Data publicação:
11/2014

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter