L i n g u a g e m d e P r o g r a m a ç ã o I

Transcrição

1 Serviço Nacional de Aprendizagem Comercial Escola de ensino Profissional Senac Pelotas Centro Histórico L i n g u a g e m d e P r o g r a m a ç ã o I A b o r d a g e m P r á t i c a U t i l i z a n d o J a v a Prof. Roberto Aguiar Jr. (raguiar.jr@gmail.com) Prof. William da Cruz Sinotti (sinottiw@gmail.com) Pelotas, julho de 2013

2 Sumário 1. INTRODUÇÃO O que é Java? Compilador Porque desenvolver em Java? JVM (Java Virtual Machine): Máquina Virtual Java Plataformas Java Java SE (Standard Edition) Java EE (Enterprise Edition) Download do Java O NETBEANS Download do NetBeans Plug-ins Visão Geral do NetBeans Criando o Primeiro Projeto no NetBeans ESTRUTURA BÁSICA DE UM PROGRAMA JAVA Conceitos Javadoc Executando o primeiro projeto no NetBeans NOMENCLATURA NA LINGUAGEM JAVA Padrão UpperCamelCase Padrão lowercamelcase Padrão UpperCase Case Sensitive Comentários no Código Fonte PALAVRAS RESERVADAS TIPOS DE DADOS VARIÁVEIS Declaração de Variáveis O COMANDO IMPORT MÉTODOS DE ENTRADA E SAÍDA DE DADOS Entrada de Dados via Teclado... 13

3 9.2. Saída de Dados via Tela Realizando a Montagem da Saída de Dados LISTA DE EXERCÍCIOS OPERADORES Operadores Aritméticos Incremento e Decremento Precedência dos operadores aritméticos Operadores Relacionais Operadores Lógicos Precedência de Operadores Lógicos e Relacionais Principais Métodos Matemáticos Math.abs(x) Math.pow(x, y) Math.sqrt(x) Double.ParseDouble(String) e Float.ParseFloat(String) Integer.ParseInt(String) e Long.ParseLong(String) LISTA DE EXERCICIOS COMANDOS CONDICIONAIS E ESTRUTURAS DE CONTROLE Comandos Condicionais O comando if-else O comando if-elseif-else O comando switch-case Laços de Repetição Uso do Laço for Uso do Laço while Uso do laço do-while LISTA DE EXERCICIOS UTILIZAÇÃO DE ARRAYS Arrays Unidimensionais Arrays Bidimensionais/Multidimensionais LISTA DE EXERCICIOS FUNÇÕES COM STRINGS Método length... 43

4 17.2. Método charat Métodos touppercase e tolowercase Método substring Método trim Método replace Método valueof Método indexof Método equals LISTA DE EXERCÍCIOS ORIENTAÇÃO A OBJETOS: INTRODUÇÃO Classes, Objetos e Métodos Criando uma classe para criação de objetos Criando uma classe juntamente com o método main LISTA DE EXERCÍCIOS ORIENTAÇÃO A OBJETOS: CONCEITOS Encapsulamento Construtores Herança Polimorfismo LISTA DE EXERCÍCIOS

5 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 5 1. INTRODUÇÃO 1.1. O que é Java? Java é uma linguagem de programação orientada a objetos desenvolvida pela Sun Microsystems Compilador É um programa que, a partir de um código escrito em uma linguagem de programação, código fonte, cria um programa semanticamente equivalente, porém escrito em outra linguagem, código objeto Porque desenvolver em Java? É uma linguagem projetada para ser pequena, simples e portátil a todas as plataformas e sistemas operacionais. Esta portabilidade é obtida pelo fato da linguagem ser interpretada. Outra característica importante é a orientação a objetos que inicialmente imaginaremos como uma prática de programação que permite reutilizar diversos trechos do nosso código JVM (Java Virtual Machine): Máquina Virtual Java É um programa que carrega e executa os aplicativos Java, convertendo os bytecodes em código executável de máquina. Os bytecodes são interpretados pelas Máquinas Virtuais Java após o código ser compilado. A JVM é responsável pelo gerenciamento dos aplicativos, à medida que são executados Plataformas Java Java SE (Standard Edition) É uma ferramenta que permite desenvolver e implantar aplicativos Java em desktops e servidores Java EE (Enterprise Edition) Esta plataforma inclui todas as funcionalidades existentes na Java SE, acrescida de todas as funcionalidades necessárias para o desenvolvimento e execução de aplicações em um ambiente corporativo Download do Java Você encontra a plataforma acessando o link abaixo:

6 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 6 2. O NETBEANS O NetBeans é um ambiente de desenvolvimento, IDE (Ambiente Integrado de Desenvolvimento), open-source escrito totalmente em Java. Ele permite que você desenvolva rapidamente e facilmente aplicações desktop, móvel e web, além de fornecer ótimas ferramentas para PHP e desenvolvedores de C / C + +. O NetBeans é gratuito, de código aberto e tem uma grande comunidade de usuários e desenvolvedores no mundo inteiro Download do NetBeans Para fazer o download do software acesse o link Plug-ins Além dos recursos já existentes com a instalação da ferramenta, você também poderá instalar alguns plug-ins específicos distribuídos pelo próprio grupo NetBeans Visão Geral do NetBeans Na Figura 1: Visão Geral do NetBeans podemos observar a janela da IDE com suas principais características. Figura 1: Visão Geral do NetBeans

7 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 7 Barra de Título: Sempre exibe o nome do projeto. Barra de Menu: Permite fazer todas as tarefas gerais. As opções disponíveis em cada menu também mudarão dependendo do que estiver selecionado. Barra de Ferramentas: Permite executar tarefas gerais e específicas para itens selecionados. Janelas: Mostram grupos de objetos relacionados, desde seu projeto até a saída da execução de um código Java. Paletas: Guias dos arquivos abertos Criando o Primeiro Projeto no NetBeans a) Clique no menu Arquivo b) Clique em Novo Projeto c) No assistente que aparece, selecione a categoria Java e o projeto Aplicação Java d) Clique em Próximo e) Digite o nome para seu projeto (seguindo as orientações da seção 3.1) f) Clique no botão Finalizar 3. ESTRUTURA BÁSICA DE UM PROGRAMA JAVA package exemplo1; public class Exemplo1 { public static void main(string[] args) { System.out.println("Início do aprendizado."); System.out.println("Meu primeiro arquivo Java!"); Exemplo 1: Primeiro contato com o Java 3.1. Conceitos Classe (class): Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis através de seus atributos. Exemplo: Exemplo1 é o nome da classe acima. Chaves ({ ): Indica o inicio ou fim do Bloco. Ponto-e-vírgula (;): Finalizar a instrução.

8 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 8 public: É um qualificador do método que indica que ele é acessível externamente a essa classe. Isso é útil quando uma classe necessita utilizar alguma funcionalidade de outra classe. static: Qualificador que indica que o método de ser compartilhado por todos os objetos que são criados a partir dessa classe. void: É o valor de retorno do método. Quando não há nenhum retorno, ela retorna void, uma espécie de valor vazio que deve ser especificado. main: é o método executor, ou seja, sempre que seu código precisar ser executado como programa, este método deverá constar no código fonte. (String args[ ]) ou (String[ ] args): É um argumento do método main e como este método é o principal, ele é o argumento de todo o programa. Ele é um vetor de Strings formado por todos os argumentos passados ao programa na linha de comando do sistema operacional quando o programa é invocado. System: É uma classe do pacote java.lang que possui vários campos e métodos úteis. Podemos destacar como principal facilidade a utilização para entrada e saída de dados via terminal. System.out: Campo out representa o fluxo de saída. System.out.println(String s): O método println(string s) pertence a classe PrintStream. Quando utilizamos este método, ele invoca PrintStream(String) Javadoc API (Interface de Programação de Aplicativos) é um conjunto de rotinas e padrões estabelecidas por um software para utilização de suas funcionalidades. Javadoc é um gerador de documentação criado pela Sun Microsystems para documentar a API dos programas em Java, a partir do código-fonte. Para visualizar o documento, basta acessar o link Executando o primeiro projeto no NetBeans Agora iremos visualizar na prática o resultado do código exposto na estrutura básica. Estando com a ferramenta aberta, faça: a) Clique no botão Executar Projeto localizado na barra de ferramentas ou; b) No teclado, pressione a tecla F6. c) Observe o resultado na janela Saída localizada na parte inferior do NetBeans.

9 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 9 4. NOMENCLATURA NA LINGUAGEM JAVA O Java nos permite nomear variáveis, atributos, classes, constantes e métodos com qualquer tipo de palavra, exceto palavras reservadas (Seção 3), buscamos, enquanto desenvolvedores, padronizar de códigos, a fim de permitir uma melhor leitura e interpretação do código. Para isso utilizamos algumas notações que nos permitirão um melhor desenvolvimento e conhecimento do tipo de informação que estamos manuseando, bem como auxílio na interpretação de códigos durante as futuras manutenções Padrão UpperCamelCase Utilizado em classes, atributos e métodos. Todas as palavras que nomeiam a informação iniciam por letras maiúsculas e os espaços são removidos, onde enxergamos a separação através das letras em caixa alta. Exemplo: O que queremos utilizar: data de nascimento Padronizando o mesmo: DataNascimento 4.2. Padrão lowercamelcase Utilizado em variáveis e parâmetros. A primeira palavra que nomeia a informação deve ser toda em minúsculo e as demais palavras iniciando por maiúsculo. Também removese os espaços existentes entre as palavras. Exemplo: O que queremos utilizar: data de nascimento Padronizando o mesmo: datanascimento 4.3. Padrão UpperCase Utilizado em constantes. Todas as letras devem estar em maiúsculo. Exemplo: O que queremos utilizar: data Padronizando o mesmo: DATA 4.4. Case Sensitive A linguagem de programação Java é do tipo Case Sensitive (sensível ao tamanho), ou seja, realiza a diferenciação de letras minúsculas de maiúsculas. Exemplo: Java java java JaVa java

10 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Comentários no Código Fonte É de extrema valia adicionarmos comentários no decorrer do código, principalmente quando nos deparamos com trechos complexos. Existem duas formas de adicionar comentário dentro de nosso código como podemos ver na Tabela 1: Comentários no Código. Em uma linha 5. PALAVRAS RESERVADAS Mais de uma linha //comentário /* * comentário */ Tabela 1: Comentários no Código Como visto anteriormente, o Java nos permite denominarmos nossos elementos com qualquer palavra. Porém existem algumas palavras, chamadas de Reservadas. Na Tabela 2: Palavras Reservadas podemos observar as palavras que nunca devem ser utilizadas para nomear variáveis, classes, métodos e outros elementos, pois as mesmas possuem um significado especial para o compilador. abstract boolean break byte case catch char class const continue default do double else extends false final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transiente true try void volatile While Tabela 2: Palavras Reservadas 6. TIPOS DE DADOS No Java, existem poucos tipos de dados nativos, ou seja, dados que fazem parte da programação e que não são objetos (instâncias) de outras classes. Cada tipo destes dados nativos possuem suas limitações e características diferentes, que podem ser observadas na Tabela 3: Tipos de Dados Nativos.

11 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 11 Tipo Tipo Valor Faixa de Valores Observações boolean Lógico true (verdadeiro) e false (falso) Valor que assume as constantes true (verdadeiro) ou false (falso) char Numérico e 0 a Quando representando Literal caracteres literais, deve ser apresentado entre aspas simples ( ). Ocupa um total de 16 bits. byte Numérico -128 a 127 Inteiro de 8 bits de precisão Inteiro com sinal short Numérico a Inteiro de 16 bits de precisão Inteiro com sinal int Numérico a Inteiro de 32 bits de precisão Inteiro com sinal long Numérico a Inteiro de 64 bits de precisão Inteiro com sinal float Numérico e-45 a Ponto flutuante simples de Decimal e bits de precisão, com sinal double Numérico e-324 a Ponto flutuante simples de Decimal e bits de precisão, com sinal String Cadeia de Tamanho limitado à memória Não é um item nativo do Caracteres disponível Java, mas pela sua simplicidade de aplicação, semelhante aos tipos nativos se encontra entre os mesmos. Representa uma cadeia de caracteres, devendo este ser representado entre aspas duplas ( ). Tabela 3: Tipos de Dados Nativos

12 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java VARIÁVEIS São endereços na memória RAM, destinadas ao armazenamento temporário de informações. O tamanho ocupado na memória RAM é definido através do tipo de dados (seção 8) que a mesma for declarada Declaração de Variáveis Como visto na seção 4.2, variáveis seguem o padrão lowercamelcase, então a mesma deve ser informada desta maneira. Abaixo segue a estrutura da declaração de variáveis: Sintaxe: tipodedadobase listadevariaveis Onde: tipodedadobase: deve ser um tipo de dado válido (seção 6). ListaDeVariaveis: um ou mais nomes separados por vírgula. Exemplo: int x, y, z; float precocusto, precovenda; Observação: quando declaramos uma variável, podemos também inicializar seu valor, ou seja, quando o programa inicia, a variável já possuirá um valor antes de qualquer ação do usuário. Para isto basta que, na declaração da variável, atribuímos (=) a mesma um valor. Exemplo: int x = 10; 8. O COMANDO IMPORT O comando import faz o compilador incluir um pacote de classes dentro de nosso programa fonte. Cada pacote destes possui diversas classes. Exemplo: import java.util.scanner; //pacote java.util e a //classe Scanner import java.swing.*; //pacote java.swing e * //informa que será utilizada //todas as classes do pacote

13 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java MÉTODOS DE ENTRADA E SAÍDA DE DADOS 9.1. Entrada de Dados via Teclado Para realizar a entrada de dados em nossos programas, nós podemos utilizar, inicialmente, a biblioteca já carregada no Java: Scanner, destinada a entrada de dados via terminal. Abaixo é visto um exemplo de programa utilizando a entrada de dados com a biblioteca Scanner: package exemplo2; import java.util.scanner; public class Exemplo2{ public static void main(string[] args){ Scanner entrada = new Scanner(System.in); String nome; System.out.print("Digite seu nome: "); nome = entrada.nextline(); System.out.println("Olá " + nome + "!"); Exemplo 2: Entrada e Saída de Dados Destaca-se no programa acima as seguintes linhas de comando: import java.util.scanner; Inclui em nosso programa o pacote java.util e a classe Scanner que o pacote contém. Scanner entrada = new Scanner(System.in); Criamos uma variável entrada do tipo Scanner, ou seja, instanciamos um objeto da classe Scanner.

14 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 14 entrada.nextline(); Informamos que o dado que o usuário irá informar é do tipo String. Este método retorna a entrada digitada no terminal. A variável nome armazena o retorno do método. Essa variável foi criada na instrução String nome;. Veja na Tabela 4: Tipos de Entrada no Scanner os métodos para cada tipo de dados para entrada via Scanner. Tipo de Dado Boolean Char Byte Short Int Long Float Double String Método da Classe Scanner nextboolean(); nextline(); nextbyte(); nextshort(); nextint(); nextlong(); nextfloat(); nextdouble(); nextline(); Tabela 4: Tipos de Entrada no Scanner 9.2. Saída de Dados via Tela Para realizarmos a apresentação de informações no terminal, devemos utilizar o objeto System.out, que é um objeto de apresentação de Strings na tela do terminal, acrescido de seus métodos, que podem ser observados na Tabela 5: Métodos do objeto System.out. System.out.println(); Realiza a quebra de linha após inserir a String na tela do console. System.out.print(); Insere a String na tela do terminal e o cursor permanece na mesma linha. Tabela 5: Métodos do Objeto System.out 9.3. Realizando a Montagem da Saída de Dados Note no Exemplo 2 (seção 9.1), que a última linha de instrução possui o comando: System.out.println("Olá " + nome + "!");

15 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 15 Para montarmos esta String de saída utilizamos o operador de concatenação, ou seja, o operador que une dois dados. Imagine que a variável nome = João, será concatenado, ou seja, unido, a String Olá com o nome João, através do operador de adição (+), que resultará em uma única String Olá João. Depois ainda é realizada a concatenação de Olá João com!, que resultará em Olá João!. Ressalta-se que a concatenação não é realizada apenas entre Strings, mas entre uma String e qualquer tipo de dados básicos do Java. Sendo assim, podemos realizar a concatenação entre uma String e um int, uma String e um float, etc. 10. LISTA DE EXERCÍCIOS Escreva um programa que leia nome e após exiba a mensagem: Olá fulano, seja bem vindo! Exercício 10.1 ================================= Nome: João Augusto ================================= Olá João Augusto, seja bem Vindo! Escreva um programa que receba nome e idade de uma pessoa e apresente o Nome e Idade da Pessoa. Exercício 10.2 ================================= Nome.: Lucas da Silva Idade: 18 ================================= Lucas da Silva 18 anos Escreva um programa que leia código (01, 02,...), nome e preço de um produto e em seguida apresente o produto da seguinte maneira: Código... R$ preço... Produto. Exercício 10.3 ================================== Código..: 01 Produto.: Café Preço R$: 2.50 ================================== LISTA DE PRODUTOS

16 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java R$ Café Escreva um programa que leia código (01, 02,...), nome e preço de três produtos e em seguida apresente a listagem destes produtos. Exercício 10.4 ================================== Código..: 01 Produto.: Café Preço R$: Código..: 02 Produto.: Arroz Preço R$: Código..: 03 Produto.: Feijão Preço R$: 2.25 ================================== LISTA DE PRODUTOS R$ Café R$ Arroz R$ Feijão OPERADORES São símbolos que obrigam o compilador a executar operações, podendo estas serem aritméticas, comparativas ou lógicas Operadores Aritméticos Operadores destinados a execução de operações matemáticas. Na Tabela 6: Operadores Aritméticos podemos observar os símbolos e suas funções. Operador Aritmético Ação - Subtração + Adição * Multiplicação / Divisão % Módulo -- Decremento (Seção ) ++ Incremento (Seção ) Tabela 6: Operadores Aritméticos

17 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Incremento e Decremento Operadores simplificados de soma e adição. Exemplo: x++; ou ++x; // x = x + 1; x--; ou --x; // x = x 1; Observação: Quando o precede à variável (--x ou ++x) o calculo é realizado antes de utilizar o valor da mesma. Se estiver após a variável (x++ ou x--), será utilizado o valor atual da variável e depois será realizado o cálculo. Exemplo: x = 10; y = ++x; //y será 11 e x será 11; x = 10; y = x++; //y será 10 e x será 11; Precedência dos operadores aritméticos Representa a hierarquia das operações, ou seja, o que é realizado primeiro, segundo, etc. Podemos ver esta precedência na Tabela 7: Precedência de Operações. Ordem Operação 1 Parênteses 2 Métodos Matemáticos (Math) (menos unário): Representação de Números Negativos 5 * / % Tabela 7: Precedência de Operações Operadores Relacionais Operadores que permitem comparar valores. Muito utilizado em condições. Veja a Tabela 8: Operadores Relacionais, onde estão ilustrados os símbolos e sua denominação. Operador Ação > Maior que >= Maior ou igual a < Menor que <= Menor ou igual a

18 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 18 == Igual a!= Diferente de Tabela 8: Operadores Relacionais Após a leitura da condição é retornado um valor booleano, true (0) ou false (!0) Operadores Lógicos Utilizado em comandos que possuem mais de uma condição. Veja a Tabela 9: Operadores Lógicos a simbologia e as ações dos operadores. Operador Ações && AND (E) OR (Ou) - Pipeline! NOT (Não) Tabela 9: Operadores Lógicos Após a leitura da condição é retornado um valor booleano, true (0) ou false (!0). Exemplo: Inicio numeroum, numerodois: Inteiro; numeroum 10; numerodois 20; Se numeroum < numerodois E numeroum >= 10 entao Fim Exiba O numero informado está entre 10 e 20 ; Precedência de Operadores Lógicos e Relacionais Representa a hierarquia das operações, ou seja, o que é realizado primeiro, segundo, etc. Podemos ver esta precedência na Tabela 10: Precedência de Operadores Lógicos e Relacionais. Ordem Operação 1! 2 > >= < <= 3 ==!= 4 &&

19 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 19 5 Tabela 10: Precedência de Operadores Lógicos e Relacionais Principais Métodos Matemáticos No Java podemos utilizar de diversos métodos para cálculo de funções matemáticas. A seguir podemos observar as principais: Math.abs(x) Retorna o valor absoluto de um número, ou seja, valores positivos. Exemplo Math.pow(x, y) int x = -10, y; y = Math.abs(x); //y será 10 Retorna o valor da potência (x y ). Exemplo Math.sqrt(x) int x = 12, y = 2, z; z = Math.pow (x,y); //z será 144 Retorna o valor da raiz quadrada (x). Exemplo int x = 9, y; y = Math.sqrt (x); //y será Double.ParseDouble(String) e Float.ParseFloat(String) Converte uma String em Double ou em Float. Exemplo String s = 10,5 ; Double d; Float f; d = Double.ParseDouble(s); //d será o valor 10.0 f = Float.ParseFloat(s); //f será o valor Integer.ParseInt(String) e Long.ParseLong(String) Converte uma String em int ou em long. Exemplo: String s = 10 ; int i;

20 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 20 long l; i = Integer.ParseInt(s); //i será o valor 10 l = Long.ParseLong(s); //l será o valor Outros Métodos Matemáticos Você pode visualizar outros métodos matemáticos através do site Java Free Org, através do link LISTA DE EXERCICIOS Escreva um programa que leia um número inteiro e retorne o dobro do valor informado e o triplo do resultado do dobro obtido. Exercício 12.1 =================== Número: 2 =================== O dobro de 2 é 4 O triplo de 4 é 12 =================== Escreva um programa que leia dois números e após realize os cálculos de: soma, subtração, multiplicação e divisão entre os números. Exercício 12.2 ==================== Primeiro Número: 4 Segundo Número.: 2 ==================== = = 2 4 * 2 = 8 4 / 2 = 2 ==================== Escreva um programa que receba nome de um produto e o valor de custo. Após deve calcular o valor de venda do produto (pc + 10%) e apresenta-lo. Exercício 12.3 ======================= Produto: Café Valor de Custo R$: 2,50 ======================= Lista de Produtos

21 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 21 Café... R$ 2.75 ======================= Escreva um programa que receba nome de três produtos e o valor de cada um. Após deve mostrar a lista de compras e o valor total da compra Exercício 12.4 ================= Produto.: Café Preço R$: 2, Produto.: Arroz Preço R$: 2, Produto.: Feijão Preço R$: 2,25 ================= LISTA DE COMPRAS Café... R$ 2.50 Arroz... R$ 2.00 Feijão.. R$ TOTAL... R$ 6.75 ================= Escreva um programa que receba nome e idade do usuário. Após o mesmo deve apresentar a mensagem: Fulano, você nasceu em xxxx. Exercício 12.5 =============================== Nome.: João Vitor Idade: 18 =============================== João Vitor, você nasceu em 1995 =============================== Escreva um programa que leia o ano atual e receba nome e ano de nascimento do usuário. Após o mesmo deve apresentar a mensagem: Fulano, você tem xx anos. Exercício 12.6 =============================== Ano Atual: 2015 Nome...: João Vitor Ano Nasc.: 1995 =============================== João Vitor, você tem 20 anos

22 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 22 =============================== Escreva um programa que leia dois números (x, y). Após deve calcular a potência do primeiro número elevado ao segundo (x y ) e a potência do segundo número elevado ao primeiro (y x ). Após deve mostrar a raiz quadrada de ambos. Exercício 12.7 =========================================== Primeiro Número: 2 Segundo Número.: 4 =========================================== 2.0 elevado a 4.0º potência é elevado a 2.0º potência é 16.0 =========================================== A raiz quadrada de 2.0 é A raiz quadrada de 4.0 é 2.0 =========================================== Escreva um programa que leia dois números e realize a subtração. Importante: Só pode apresentar números positivos. Exercício 12.8 ==================== Primeiro Número: 2 Segundo Número.: 4 ==================== 2-4 = 2 ==================== Escreva um programa que receba 4 números (x, y, w, z). Após o mesmo deve realizar o seguinte calculo: somar o resultado da subtração de x e y do resultado da potência de w elevado a raiz quadrada de z ( ). Importante: Mesmo que o resultado seja negativo, deve ser apresentado como positivo. Exercício 12.9 =============================== Primeiro Número: 4 Segundo Número.: 40 Terceiro Número: 2 Quarto Número..: 9 =============================== O resultado da expressão é 28.0 ===============================

23 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java COMANDOS CONDICIONAIS E ESTRUTURAS DE CONTROLE Comandos Condicionais Possibilitam que a execução de um programa seja desviada de acordo com certas condições. Os comandos condicionais do Java são if-else e switch-case e possibilitam executar diferentes trechos de um programa com base em certas condições O comando if-else O if, em conjunto com o else, é uma estrutura que permite a seleção entre dois caminhos distintos para a execução, dependendo do resultado (verdadeiro ou falso) de uma expressão lógica. Se a condição for verdadeira, são executadas as instruções que estiverem posicionadas entre os comandos if/else. Sendo a condição falsa, são executadas as instruções que estiverem após a instrução else. Sintaxe: if (<condição>){ <Instruções para condição verdadeira> else{ <Instruções para condição falsa> Observações: A condição sempre deve aparecer entre parênteses, item obrigatório na linguagem Java. Assim como a maioria das instruções em Java, o conjunto if else deve ser utilizado com minúsculas e, caso haja apenas uma instrução a ser executada, tanto no if como no else, o uso das chaves é desnecessário. Abaixo temos o exemplo 3 que mostra na prática como utilizar o comando if-else juntamente com a classe JOptionPane que dispõe de uma forma gráfica para entrada e saída de informações. Para usarmos essa classe em nosso programa será necessário importar o pacote javax.swing. Exemplo 3: Ler dois valores numéricos, efetuar a adição. Caso o valor somado seja maior ou igual a 40, este deverá ser apresentado somando-se a ele mais 5; caso o valor somado não seja maior ou igual 40, este deverá ser apresentado subtraindo-se 7. package exemplo3;

24 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 24 import javax.swing.joptionpane; public class Exemplo3 { public static void main(string[] args) { int x, y, soma, resultado; String valorlido; valor de x:"); valorlido = JOptionPane.showInputDialog("Digite o x = Integer.parseInt(valorlido); valor de y:"); valorlido = JOptionPane.showInputDialog("Digite o y = Integer.parseInt(valorlido); soma = x + y; if (soma >= 40) resultado = soma + 5; else resultado = soma - 7; JOptionPane.showMessageDialog(null, "Resultado: \n" + resultado); Exemplo 3: Comando if-else Destaca-se no programa acima as seguintes linhas de comando: valorlido = JOptionPane.showInputDialog("Digite..."); A variável valorlido é do tipo String e irá armazenar a informação digitada na caixa de dialogo do JOptionPane.

25 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 25 O método showinputdialog da classe JOptionPane é responsável por abrir a caixa de diálogo e permitir a digitação da informação. x = Integer.parseInt(valorlido); Como o JOptionPane retorna um valor do tipo String, ele precisa ser convertido em número por meio de Integer.parseInt. JOptionPane.showMessageDialog(null, "Resultado: \n" + resultado); O método showmessagedialog abre a caixa de dialogo e apresenta o resultado armazenado na variável resultado. \n é utilizado para quebrar uma linha dentro de uma caixa de dialogo O comando if-elseif-else O comando if-elseif-else permite a seleção de mais de dois caminhos distintos em uma execução, dependendo sempre do resultado avaliado na estrutura, que retorna verdadeiro ou falso em uma expressão lógica. Abaixo temos o exemplo 4 que mostra na prática como utilizar o comando if-elseifelse. Sintaxe: if (<condição 1>){ <Instruções para condição 1 verdadeira> else if (<condição 2>){ <Instruções para condição 2 verdadeira > else if (<condição 3>){ <Instruções para condição 3 verdadeira >... else <Instruções para condição falsa> package exemplo4; import javax.swing.joptionpane; public class Exemplo4 {

26 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 26 public static void main(string[] args) { String texto = JOptionPane.showInputDialog(null, "Informe um número inteiro:"); int numero = Integer.parseInt(texto); if (numero > 100){ JOptionPane.showMessageDialog(null, "O número " + numero + " é maior que 100."); else if (numero < 100){ JOptionPane.showMessageDialog(null, "O número " + numero + " é menor que 100."); else{ JOptionPane.showMessageDialog(null, "O número " + numero + " é igual a 100."); Exemplo 4: Comando if-elseif-else Destaca-se no programa acima as seguintes linhas de comando: else if (numero < 100){ Se o número lido não for maior que 100, nesta linha cria-se outra condição, ou seja, se o número for menor que O comando switch-case A estrutura switch-case se refere a uma outra modalidade de desvio da execução do programa de acordo com certas condições, semelhante ao uso da instrução if. O comando switch-case constitui uma estrutura de controle com múltipla escolha. A estrutura switch-case equivale a um conjunto de instruções if encadeadas, fornecendo maior inteligibilidade e eficiência durante a execução. Sintaxe: switch (<expressão>){ case 1:

27 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 27 instruções; break; case 2: instruções; break; case 3: instruções; break; default: instruções; Onde: switch: variável ou expressão que será avaliada. case: compara o valor da variável ou expressão, executando o bloco de instruções quando a variável ou expressão coincidir com o valor colocado na frente do case. switch-case. break: encerra o switch e faz a execução do programa desviar para o ponto após a chave de encerramento do switch. default: essa diretiva é opcional e será executada caso nenhuma diretiva case possua o valor correspondente da expressão. Abaixo temos o exemplo 5, que demonstra de forma clara a utilização da estrutura Exemplo 5: Desenvolva um programa que simula a aplicação de uma impressora de cheques, em que o usuário entra com um número inteiro de 0 a 9 e o programa retorna o extenso desse número. package exemplo5; import javax.swing.joptionpane; public class Exemplo5 { public static void main(string[] args) { String numerolido = JOptionPane.showInputDialog(null, "Forneça um número inteiro entre 0 e 9:"); int numero = Integer.parseInt(numerolido); String extenso; switch (numero){ case 0: extenso = "Zero";

28 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 28 break; case 1: extenso = "Um"; break; case 2: extenso = "Dois"; break; case 3: extenso = "Três"; break; case 4: extenso = "Quatro"; break; case 5: extenso = "Cinco"; break; case 6: extenso = "Seis"; break; case 7: extenso = "Sete"; break; case 8: extenso = "Oito"; break; case 9: extenso = "Nove"; break; default: extenso = "Número Desconhecido!"; JOptionPane.showMessageDialog(null, "Número fornecido é : " + extenso); Exemplo 5: Comando switch-case Destaca-se no programa acima as seguintes linhas de comando: switch (numero){

29 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 29 case 0: extenso = "Zero"; break; Significa: procure nas instruções case envolvidas pelas chaves se existe o conteúdo armazenado na variável numero. default: extenso = "Número Desconhecido!"; Caso nenhuma condição seja satisfeita, isto é, se o usuário entrou com um número diferente de 0 a 9, então a instrução default será executada Laços de Repetição Possibilitam a repetição da execução de um bloco de instruções em um programa, ou seja, eles determinam que um certo bloco seja executado repetidamente até que uma condição específica ocorra. Os principais comandos de repetição são for e while Uso do Laço for O comando for realizar a contagem de um valor inicial conhecido até um valor final também conhecido, ou seja, ele é tipo um contador. Sintaxe: for (inicialização; condição; incremento ou decremento){ <conjunto de instruções> Onde: inicialização: é o valor inicial da variável de controle do laço. condição: é a variável que controla a continuação do laço. incremento ou decremento: é o passo com que a variável de controle será acrescida ou decrescida. Exemplo 6: Criar a tabuada do número 5. package exemplo6; import javax.swing.joptionpane; public class Exemplo6 { public static void main(string[] args) { String tabuada = ""; for (int i = 0; i <= 10; i++) {

30 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 30 tabuada = tabuada + i*5 + "\n"; JOptionPane.showMessageDialog(null, "Tabuada do numero 5 \n" + tabuada); Exemplo 6: Tabuada do número 5 Observação: A variável i pode ser declarada e inicializada na própria estrutura do for. Neste caso ela é reconhecida apenas dentro da estrutura do for, ou seja, entre as chaves de abertura e encerramento. Após o encerramento do laço, a variável perde sua referencia e não pode mais ser usada, salvo se declarada novamente. Destaca-se no programa acima as seguintes linhas de comando: for (int i = 0; i <= 10; i++) A variável i é inicializada com zero e enquanto o valor de i for menor que 10 o conjunto de instruções entre chaves é repetido. Cada vez que o conjunto de instruções é executado, o valor de i é incrementado. Veja abaixo outro exemplo: for (double i = 5; i <= 10; i = i + 0.5) Conta de 5 até 10 com passo de 0.5, isto é: 5.0, 5.5, 6.0, 6.5,..., 9.5, tabuada = tabuada + i*5 + "\n"; A variável tabuada que foi definida como String recebe o valor i multiplicado por Uso do Laço while Com o comando while, um conjunto de instruções que são repetidas enquanto o resultado de uma expressão lógica (uma condição) é avaliado com o verdadeiro. O comando while avalia o resultado da expressão (condição) antes de executar as instruções do bloco, portanto é possível que as instruções do bloco nunca sejam executadas, caso a condição seja inicialmente falsa. Sintaxe: while (<condição>){ <conjunto de instruções>

31 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 31 Exemplo 7: Ler uma nota. Caso o valor esteja entre 0 e 10, mostrar a mensagem: Nota Válida! e encerrar a aplicação; caso o valor não esteja na faixa, mostra a mensagem: Nota Inválida! e efetuar a leitura da nota novamente. package exemplo7; import javax.swing.joptionpane; public class Exemplo7 { public static void main(string[] args) { double nota; nota = Double.parseDouble(JOptionPane.showInputDialog(null, "Digite Nota:")); while (nota < 0 nota > 10) { JOptionPane.showMessageDialog(null, "Nota Inválida!"); nota = Double.parseDouble(JOptionPane.showInputDialog(null, "Digite Novamente a Nota:")); JOptionPane.showMessageDialog(null, "Nota Válida!"); System.exit(0); Exemplo 7: Laço while Observação:

32 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 32 Um problema típico, relacionado a avaliação da condição while, é o laço infinito, pois caso a condição nunca se torne falsa, o laço será repetido infinitamente. Destaca-se no programa acima as seguintes linhas de comando: while (nota < 0 nota > 10) Enquanto a variável nota for menor que zero ou maior que 10 a solicitação da nota será solicitada. nota = Double.parseDouble(JOptionPane.showInputDialog(null, "Digite ")); para Duble. A variável nota recebe o conteúdo digitado no JOptionPane convertido de String System.exit(0); O método exit da classe System finaliza normalmente a aplicação a partir do argumento 0 (zero). Por convenção, um código de status diferente de zero indica finalização anormal Uso do laço do-while É parecido com o while, porém o conjunto de instruções é executado antes da avaliação da expressão lógica. Isto faz com que essas instruções sejam executadas pelo menos uma vez. Sintaxe: do{ <conjunto de instruções> while (<condição>); Exemplo 8: Usando a estrutura do-while desenvolva um programa que leia uma nota. Caso o valor esteja entre 0 e 10, mostrar a mensagem: Nota Válida! e encerrar a aplicação; caso o valor não esteja na faixa, mostra a mensagem: Nota Inválida! e efetuar a leitura da nota novamente. package exemplo8; import javax.swing.joptionpane; public class Exemplo8 { public static void main(string[] args) {

33 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 33 double nota; do { nota = Double.parseDouble(JOptionPane.showInputDialog(null, "Digite Nota:")); Inválida!"); if (nota < 0 nota > 10) JOptionPane.showMessageDialog(null, "Nota while (nota < 0 nota > 10); JOptionPane.showMessageDialog(null, "Nota Válida!"); System.exit(0); Exemplo 8: Estrutura do-while 14. LISTA DE EXERCICIOS 3 Desenvolva os exercícios abaixo utilizando a caixa de dialogo com a classe JOptionPane para entrada e saída de dados Faça um programa que peça dois números e mostre os números lidos o maior deles. A figura abaixo ilustra a execução do exercício.

34 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 34 Figura 2: Exercício Faça um programa que peça um valor e mostre na tela se o valor é positivo ou negativo e o número lido. A figura abaixo ilustra a execução do exercício. Figura 3: Exercício Faça um programa para a leitura do nome de um aluno e duas notas parciais. O programa deve calcular a média alcançada por aluno e apresentar nome do aluno, a média e: A mensagem "Aprovado", se a média alcançada for maior ou igual a sete; A mensagem "Reprovado", se a média for menor do que sete; A mensagem "Aprovado com Distinção", se a média for igual a dez. A figura abaixo ilustra a execução do exercício.

35 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 35 Figura 4: Exercício Crie uma classe que receba o nome de um produto e dois valores pelo teclado: o valor do produto e um código de aumento, segundo a tabela abaixo seguinte: Código % aumento Tabela 11: Exercício 14.4 Utilizando a estrutura switch-case, mostre na tela o nome produto e o novo valor depois de crescida a porcentagem correspondente Apresente uma classe que mostre a soma dos cem primeiros números inteiros ( ). A figura abaixo ilustra resultado da execução do exercício. 5050

36 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 36 Figura 5: Exercício Construa uma classe que calcule o produto dos inteiros ímpares 1 a 15 e exiba o resultado na tela. A figura abaixo ilustra o resultado da execução do exercício Figura 6:Exercício DESAFIO: Elabore uma classe para o cálculo do salário liquido em que três valores devem ser informados pelo usuário na linha de comando: a quantidade de horas trabalhadas, o salário-hora e o número de dependentes. O programa de mostrar na tela as informações que estão no lado esquerdo da tabela seguinte. Os cálculos correspondentes aparecem no lado direito. Informações Cálculo Salário Bruto Horas trabalhadas * Salário Hora + (50 * Número de Dependentes) Desconto INSS - Se Salário Bruto for menor ou igual a 1000, INSS é igual a Salário Bruto * 8.5/100 - Se Salário Bruto for maior que 1000, INSS é igual a Salário Bruto * 9/100 Desconto IR - Se Salário Bruto for menor ou igual a 500, IR é igual a zero - Se Salário Bruto for maior que 500 e menor ou igual a 1000, IR é igual a Salário Bruto * 5/100 - Se Salário Bruto for maior que 1000, IR é igual a Salário Bruto * 7/100 Salário Líquido Salário Bruto subtraído INSS e IR Tabela 12: Desafio

37 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 37 A figura abaixo ilustra a execução do exercício. Figura 7: Exercício 14.7 Desafio 15. UTILIZAÇÃO DE ARRAYS O array (vetor) é uma variável que pode armazenar e manipular um conjunto de dados do mesmo tipo sem que seja necessário declarar muitas variáveis, por exemplo, manipular ao mesmo tempo os conceitos de cada aluno da turma. Os itens são armazenados em forma de tabelas de fácil manipulação, sendo diferenciados e referenciados e por um índice numérico. No método public static void main(string[] args) utilizado anteriormente, o argumento String[] args é um array de Strings.

38 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Arrays Unidimensionais Esses tipos de arrays possuem apenas um índice para acessar seu conteúdo. Sintaxe: tipo_de_dado nome_do_array[] = new tipo_do_dado [quantidade]; Onde: variáveis. tipo_de_dado: pode ser qualquer tipo de variável primitiva ou classe. nome_do_array: qualquer nome, desde que respeite as regras de criação de new: esse operador cria uma nova instância de uma array. Neste caso, os índices são inicializados, por exemplo: Na prática: 0 (zero) para arrays numéricos; falso para boolean ou; NULL para objetos, ou seja, tipos não primitivos. int exemplovetorinteiro[ ] = new int [100]; => cria um vetor de nome exemplovetorinteiro com espaço para armazenar 100 elementos do tipo int e seu índice varia de 0 a 99. String mes[] = new String[12]; => cria um vetor de nome mes com espaço para armazenar 12 elementos do tipo String e seu índice varia de 0 a 11. Atribuindo informações ao vetor: Observação: Veja abaixo como atribuir o valor a um elemento do array: exemplovetorinteiro[0] = 500; exemplovetorinteiro[99] = 0; mes[0] = Janeiro ; mes[1] = Fevereiro ; Podemos criar e inicializar um array ao mesmo tempo, por exemplo: String diasemana[] = { Segunda, Terça, Quarta, Quinta, Sexta, Sábado, Domingo ; Exemplo 9: Escreva uma classe que permita a leitura das notas de uma turma de 20 alunos. Calcular a média da turma e contar quantos alunos obtiveram nota acima desta média calculada. Escrever a média da turma e o resultado da contagem. package exemplo9; import javax.swing.*;

39 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 39 public class Exemplo9{ public static void main(string[] args) { double vetornotas[] = new double[20]; double media, notas = 0; int contador = 0; for (int i=0; i<=19; i++){ vetornotas[i] = Double.parseDouble(JOptionPane.showInputDialog("Digite nota " + (i+1))); notas = notas + vetornotas[i]; media = notas/20; for (int i=0; i<=19; i++){ if (vetornotas[i] > media){ contador++; JOptionPane.showMessageDialog(null, "Média: " + media + "\ncontagem: " + contador); System.exit(0); Exemplo 9: Utilizando Array Destaca-se no programa acima as seguintes linhas de comando: vetornotas[i] = Double.parseDouble(JOptionPane.showInputDialog("Digite nota " + (i+1))); A variável i do vetor vetornotas[i] é a mesma do comando for.

40 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Arrays Bidimensionais/Multidimensionais Esses arrays permitem a criação de vetores com dois ou mais índices, ou seja, tabelas de valores que consistem em informações organizadas em linhas e colunas. Sintaxe: tipo_de_dado nome_do_array[][] = new tipo_do_dado [<indice1>] Onde: [<indice2>]; [<indice1>] refere-se ao número de linhas. [<indice2>] refere-se ao número de colunas. Exemplo 10: Escreva um programa que permita a digitação de 2 notas de 3 alunos (total de 6 notas). Uma vez armazenadas, o programa solicita ao usuário o número de um aluno para mostrar suas notas e a média delas. package exemplo10; import javax.swing.*; public class Exemplo10 { public static void main(string[] args) { float notas[][] = new float[3][2]; int numeroaluno = 0, contador; while (numeroaluno < 3){ contador = 0; while (contador < 2){ notas[numeroaluno][contador] = Float.parseFloat( JOptionPane.showInputDialog( "Forneça a nota " + (contador+1) + " do aluno " + (numeroaluno+1)) ); contador ++; numeroaluno ++;

41 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 41 numeroaluno = Integer.parseInt (JOptionPane.showInputDialog( "Forneça o número do aluno a consultar: ")); 1][0] + Alunos JOptionPane.showMessageDialog(null, ALUNO 1 "CONSULTA DE NOTAS: " + ALUNO 2 "\naluno: " + numeroaluno + ALUNO 3 "\nnota 1: " + notas[numeroaluno - "\nnota 2: " + notas[numeroaluno - 1][1] + "\nmédia: " + ((notas[numeroaluno - 1][0] + notas[numeroaluno - 1][1])/2) ); System.exit(0); Exemplo 10: Array Bidimensional A tabela abaixo se refere ao exemplo acima: Índice NOTA 1 NOTA 2 1 NOTA 1 NOTA 2 2 NOTA 1 NOTA 2 Tabela 13:Array Bidimensional Destaca-se no programa acima as seguintes linhas de comando: notas[][] = new float[3][2]; Cria um array de 3 linhas e 2 colunas. notas[numeroaluno][contador] = Float.parseFloat( JOptionPane.showInputDialog( "Forneça a nota " + (contador+1) +

42 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 42 " do aluno " + (numeroaluno+1)) ); As notas fornecidas pelo usuário são armazenadas no array notas. numeroaluno = Integer.parseInt (JOptionPane.showInputDialog( "Forneça o número do aluno a consultar: ")); Essa linha faz a leitura do código do aluno a ser pesquisado. 16. LISTA DE EXERCICIOS 4 Desenvolva os exercícios abaixo utilizando a caixa de dialogo com a classe JOptionPane para entrada e saída de dados Ler um vetor1 de 10 números inteiros. Após, ler mais um número e guardar em uma variável numero. Armazenar em um vetor2 o resultado de cada elemento do vetor1 multiplicado pelo numero lido. Logo após, mostrar o vetor2. A figura abaixo ilustra resultado da execução do exercício. Figura 8: Exercício Crie uma classe que leia cinco valores inteiros quaisquer e no final mostre o menor e o maior número lido. A figura abaixo ilustra resultado da execução do exercício. Figura 9: Exercício Faça um algoritmo para ler 15 números e armazenar em um vetor. Após a leitura total dos 15 números, o algoritmo deve escrever esses 15 números lidos na ordem inversa.

43 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Leia um número inteiro e armazene-o na variável numerolido. Crie um vetor de tamanho 12, leia 6 números quaisquer e armazene entre as posição 0 e 5. Logo após, armazene entre as posições 6 e 11 o resultado da subtração dos números lidos por numerolido DESAFIO: Faça um algoritmo para ler um valor qualquer (que será o tamanho dos vetores) e armazenar na variável tamanho. Após, ler dois vetores vetor1 e vetor2 (de tamanho lido cada um) e depois armazenar em um terceiro vetor vetorsoma a soma dos elementos do vetor1 com os do vetor2 (respeitando as mesmas posições) e escrever o vetorsoma. 17. FUNÇÕES COM STRINGS String é um conjunto de caracteres que são instanciadas da classe String. Neste caso são gerados objetos que possuem propriedades e métodos que permitem ser manipulados de várias formas, ou seja, é possível verificar o comprimento da string, retirar um pedaço da mesma, acessar ou mudar caracteres individuais. Sintaxe: <nome_da_string>.<nome_do_metodo>(<argumentos>) Onde: utilizados Método length <nome_da_string> => mesmas regras de definição de variáveis. <nome_do_metodo> => a seguir serão apresentados os métodos mais É utilizado para retornar o tamanho de uma determinada string, ou seja, o total de caracteres que a string possui, incluído os espaços em branco. Neste caso, o retorno será sempre um valor tipo int. Exemplo: Na prática: String frase = "Lógica de Programação."; int tamanho = frase.length(); System.out.print("Tamanho: " + tamanho);

44 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 44 O conteúdo da variável tamanho é 22. Qual é o resultado da variável tamanho no código abaixo? int tamanho = "Lógica de Programação.".length(); Método charat Retorna um caractere de uma determinada String de acordo um índice especificado. Sintaxe: Onde: <String>.charAt(<índice>) <String> => Texto. (<índice >) => Refere-se a posição do caractere na string: 0 é o índice do primeiro caractere na string; 1 é o segundo caractere; 2 é o terceiro e assim segue para a demais posições. Exemplo: String frase = "Linguagem de Programação."; char caractere = frase.charat(0); System.out.print("Caractere: " + caractere); Na prática: O conteúdo da variável caractere é L. Qual é o conteúdo da variável caractere no código abaixo? char caractere = frase.charat(21); Métodos touppercase e tolowercase O método touppercase transforma todos os caracteres de uma determinada string em maiúsculos. Já o método tolowercase transforma todos os caracteres de uma determinada string em minúsculos. Exemplo: String palavra = "Java"; System.out.println("Maiúsculos: " + palavra.touppercase()+ "\nminúsculos: " + palavra.tolowercase()); Na prática: Temos como saída as seguintes informações: Maiúsculos: JAVA Minúsculos: java

45 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Método substring Esse método retorna a cópia de caracteres de uma string a partir de dois índices inteiros especificados. Sintaxe: <String>.substring(<índice inicial>, [<índice final>]) Onde: <String> => Texto. (<índice inicial>) => especifica o índice a partir do qual se inicia a cópia dos caracteres. [(<índice final>)] => especifica o índice final, ou seja, a posição em que termina a cópia dos caracteres, entretanto esse índice deve especificar um índice além do último caractere. Exemplo: String frase = "Programando em Java."; System.out.print("Palavra 1: " + frase.substring(0, 11) + "\npalavra 2: " + frase.substring(12, 14) + "\npalavra 3: " + frase.substring(15)); Na prática: Temos como saída as seguintes informações: Palavra 1: Programando Palavra 2: em Palavra 3: Java Método trim Ele remove os espaços em branco no inicio e no final de uma determinada string, mantendo os espaços em branco entre as palavras. Exemplo: String frase = " Programando em Java. "; System.out.print("Removendo espaços: " + frase.trim()); Na prática: Segue abaixo a saída do exemplo acima: Método replace Removendo espaços: Programando em Java. É utilizado para substituição de caracteres em uma determinada string. Sintaxe:

46 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 46 <String>.replace(<caracteres a serem substituídos>, <substituição>) Exemplo: String frase = " Programando em Java. "; String frase1 = frase.replace(".", "!"); String frase2 = frase.trim().replace(" ", "-"); String frase3 = frase.replace("ndo", ""); String frase4 = frase.replace(" ", ""); System.out.println(frase); System.out.println(frase1); System.out.println(frase2); System.out.println(frase3); System.out.println(frase4); Na prática: Segue abaixo a saída do exemplo acima: Método valueof em Strings. Programando em Java. => Frase com espaços no inicio e fim da string. Programando em Java! => Foi substituído o. pelo caractere!. Programando-em-Java. => Foi substituído o pelo caractere -, além de remover os espaços no inicio e final da string. Programa em Java. => Foi substituído ndo pelo caractere. ProgramandoemJava. => Foi substituído pelo caractere. Esse método é usado para converter diversos tipos de dados (int, float, double, outros) Exemplo: int a = 100; float f = 300; double d = ; System.out.println(String.valueOf(a) + " - " + String.valueOf(f) + " - " + String.valueOf(d)); Na prática: Segue a saída do exemplo acima:

47 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java Método indexof Esse método é usado para localizar caracteres em uma String retornando a posição em que o caractere ou conjunto de caracteres se encontram. Sintaxe: String.indexOf(<caractere ou substring a ser localizada>, [<posição inicial>)]) Onde: [<posição inicial>)] => é opcional e indica a posição em que o método de iniciar a pesquisa. Exemplo: String frase = "Programando em Java."; String letra = "a"; System.out.print(frase.indexOf(letra, 10)); Na prática: Segue a saída do exemplo acima: Método equals Esse método compara se o conteúdo de duas Strings é igual. Exemplo: Na prática: String palavra1 = "teste", palavra2 = "teste"; if (palavra1.equals(palavra2)) System.out.println("As palavras são iguais."); O método equals( ) compara se o conteúdo da palavra1 é igual a palavra LISTA DE EXERCÍCIOS 5 Desenvolva os exercícios abaixo utilizando a caixa de dialogo com a classe JOptionPane para entrada e saída de dados Construa uma classe que receba uma frase qualquer e mostre-a de forma invertida, como mostra a figura abaixo:

48 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 48 Figura 10: Exercício Escreva um algoritmo que permita a leitura dos nomes de 10 pessoas e armazene os nomes lidos em um vetor. Após isto, o algoritmo deve permitir a leitura de mais 1 nome qualquer de uma pessoa e depois escrever a mensagem ACHEI, se o nome estiver entre os 10 nomes lidos anteriormente (guardados no vetor), ou NÃO ACHEI caso contrário Crie uma classe que calcule quantos metros cúbicos de água suporta uma determinada caixa d água em forma de cubo (todos os lados são iguais). O usuário deve informar o valor do lado, e o volume de água será calculado pela fórmula Volume = Lado 3. Arredonde o resultado para seu inteiro anterior DESAFIO 1: Elabore uma classe que mostre o efeito representado na figura abaixo: Figura 11: Exercício DESAFIO 2: Elabore um programa que mostre o efeito representado na figura abaixo:

49 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 49 Figura 12: Exercício ORIENTAÇÃO A OBJETOS: INTRODUÇÃO Atualmente, estávamos criando programas chamados de Programas Lineares, ou seja, o computador deve executar linha a linha os passos do programa até chegar no final da classe. Em orientação a objetos, trocamos o conceito linear por Módulos, isto é, a programação passa a ser modular, visto que 10 programas de 10 linhas rodam de forma muito mais rápida que um único programa. A maior vantagem desse conceito está na simplicidade da tradução e interpretação do código, é totalmente preferível tratar pequenos módulos a programas grandes e complexos Classes, Objetos e Métodos As classes representam um conjunto de objetos, ou seja, definem o comportamento (as ações possíveis sobre o objeto) dos objetos através de seus métodos e os estados (conjunto de propriedades do objeto) através de seus atributos (variáveis). O objeto é uma abstração dos objetos reais existentes, por exemplo, alunos, cadeiras, mesas etc. Uma classe é um molde, um modelo, um protótipo a partir do qual os objetos podem se criados, como exemplo poderia citar a Sala de Aula. Métodos são trechos de códigos que permitem modularizar o sistema, isto é, são pequenos blocos que, juntos, compõem um sistema maior. Podemos classificar as classes em dois tipos: 1. A classe usada para criação de objetos (seção ); 2. A classe executável, ou seja, a que possui o método main (seção ).

50 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 50 Para definir uma classe usamos a palavra reservada class seguida do nome da classe, mais o par de chaves, como veremos na próxima seção Criando uma classe para criação de objetos Segue abaixo estrutura para criação de uma classe com variáveis e métodos: Sintaxe: qualificador class Nome_da_Classe{//Inicio da classe //Declaração de variáveis //Declaração dos métodos qualificador tipo_do_retorno nome_metodo([lista_argumentos]){ Códigos do corpo declaração do método2{ Códigos do corpo //final das declarações da classe Onde: qualificador da classe (opcional) => indica como a classe pode ser usada por outras classes. Existem vários qualificadores da classe, seguem dois: public: indica que o conteúdo da classe pode ser usado livremente por outras classes do mesmo pacote ou de outro pacote. Como pacote é um diretório, uma classe pode ser usada por classes armazenadas em outros diretórios. private: indica que o conteúdo da classe é privado e pode ser usado apenas por classes do mesmo pacote, isto é, classes do mesmo diretório. qualificador do método (opcional) => conhecido como modificador de acesso ou nível de acesso, define a visibilidade do método. O qualificador do método pode ser do tipo: public: o método é visível por qualquer classe. private: o método é visível apenas pela própria classe.

51 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 51 protected: o método é visível pela própria classe, por suas subclasses e pelas classes do mesmo pacote. tipo_de_retorno => refere-se ao tipo de dado retornado pelo método. Um método pode retornar qualquer tipo primitivo (int, float, Double, etc.), um vetor ou um objeto qualquer. Métodos que não retornam valores devem possuir nesse parâmetro a palavra void. nome_do_métod => qualquer palavra ou frase, desde que iniciada por letra minúsculo. lista_argumentos => trata-se de uma lista de variáveis opcionais, que podem ser recebidas pelo método para tratamento interno. Códigos do corpo => trata-se dos códigos em Java que realizam os processos internos e retornam os valores desejados. Observação: A identificação do nome do método e a lista de argumentos formam a assinatura do método, isto é, toda vez que o método é chamado (invocado), a assinatura deve ser obedecida. Se a assinatura do método for diferente, ou seja, se qualquer um dos componentes não coincidir com a declaração, o método não pode ser utilizado. um método. Abaixo temos o exemplo 11 que mostra como criar uma classe, declarando variáveis e package lpi.orientacoobjetos; public class Produto { //declaração das variáveis String nome; double preco; static double total; //declaração do método public void atualizapreco(double porc){ preco = preco + (preco * porc/100);

52 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 52 Exemplo 11: Criando uma classe. Destaca-se na classe acima as seguintes linhas de comando: public class Produto { Nesta linha foi criada a classe Produto1 pública, ou seja, pode ser utilizada por outras classes, independente do pacote. Observação: Quando o qualificador public não é usado, a classe torna-se privada (private) por default. String nome; double preco; Essas variáveis são conhecidas como variáveis de instância, pois podem ser instanciadas pelos objetos. Todos os objetos criados a partir dessa classe contêm essas variáveis. static double total; A variável total foi declarada do tipo estática (static), esta característica faz com que o conteúdo da variável seja controlado pela própria classe e não pelos objetos individualmente. Na seção veremos na prática esta funcionalidade. public void atualizapreco(double porc){ O método atualizapreco recebe um valor percentual do tipo double através da variável porc. Esse valor é usado para calcular o novo valor da variável preco. O método não retorna nenhum valor (void) Criando uma classe juntamente com o método main A classe que possui o método main é uma aplicação que pode utilizar outras classes externas. No exemplo 12 temos a utilização da classe Produto criada anteriormente: package lpi.orientacoobjetos; import javax.swing.joptionpane; public class UsaProduto {

53 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 53 public static void main(string[] args) { String valorlido; double percentual; Produto produto1 = new Produto(); Produto produto2 = new Produto(); System.out.println("Conteúdo variável nome: " + produto1.nome); System.out.println("Conteúdo variável preco: " + produto1.preco); produto1.nome = JOptionPane.showInputDialog("Digite o nome do produto 1:"); valorlido = JOptionPane.showInputDialog("Digite o preço do produto 1:"); produto1.preco = convertedouble(valorlido); valorlido = JOptionPane.showInputDialog("Digite o percentual de aumento para produto 1:"); percentual = convertedouble(valorlido); produto1.atualizapreco(percentual); //produto1.total += produto1.preco; Produto.total += produto1.preco; produto2.nome = JOptionPane.showInputDialog("Digite o nome do produto 2:"); valorlido = JOptionPane.showInputDialog("Digite o preço do produto 2:"); produto2.preco = convertedouble(valorlido);

54 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 54 valorlido = JOptionPane.showInputDialog("Digite o percentual de aumento para produto 2:"); percentual = convertedouble(valorlido); produto2.atualizapreco(percentual); //produto2.total += produto2.preco; Produto.total += produto2.preco; JOptionPane.showMessageDialog(null, "Produto 1: " + produto1.nome + "\npreço Final: R$ " + produto1.preco + "\nproduto 2: " + produto2.nome + "\npreço Final: R$ " + produto2.preco + "\ntotal: R$ " + Produto.total); //Método que realiza a validação do dados digitados pelo usuário public static double convertedouble(string valor) { double numero = -1; //Tenta converter a String para Double. try { numero = Double.parseDouble(valor); catch (NumberFormatException erro) {//Erro de conversão. System.out.println("Erro: " + erro); JOptionPane.showMessageDialog(null, "Digite apenas caracteres numericos!", "******** Erro ********", JOptionPane.ERROR_MESSAGE); System.exit(0); finally{//opcional, mas sempre será executado. System.out.println("Método convertedouble finalizado.");

55 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 55 return numero; Exemplo 12: Utilizando Objetos Destaca-se na classe acima as seguintes linhas de comando: Produto produto1 = new Produto(); Para utilizar um objeto precisamos: 1. Declarar o objeto: mesmo padrão de declaração para os tipos primitivos. Sintaxe: Nome_da_Classe nome_do_objeto. Exemplo: Produto produto1. 2. Instanciar o objeto: ao instanciar objetos, são reservados espaços de memória para armazenar dados correspondentes. Sintaxe: nome_do_objeto = new( Inicialização_ do_objeto ). Exemplo: produto1 = new Poduto(). 3. Inicializar o objeto: corresponde ao processo de definir valores iniciais às variáveis do objeto. Para inicializar o objeto produto, foi usado o método construtor em sua forma default, isto é, com o mesmo nome da classe sem nenhum parâmetro associado (as variáveis não possuem um valor inicial definido na classe, é considerado zero para variáveis numéricas, false para variáveis boolean e null para Strings e outros objetos). Exemplo: Produto produto1 = new Poduto(). Nas linhas abaixo do Exemplo 12, escrevemos o conteúdo das variáveis nome e preco dos objetos produto1 e produto2 inicializadas com o construtor padrão (Poduto()). System.out.println("Conteúdo variável nome: " + produto1.nome + " - " + produto2.nome); System.out.println("Conteúdo variável preco: " + produto1.preco + " - " + produto2.preco); Para manipularmos as variáveis de um objeto usamos nome_do_objeto.variavel. produto1.nome = JOptionPane.showInputDialog("Digite o nome do produto 1:"); Nesta linha, foi atribuído o conteúdo do JOptionPane na variável nome do objeto produto1.

56 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 56 valorlido = JOptionPane.showInputDialog("Digite o percentual de aumento para produto 1:"); Nesta linha, foi atribuído o conteúdo do JOptionPane na variável valorlido. percentual = convertedouble(valorlido); Nesta linha é invocado a execução do método convertedouble que recebe uma String e retorna um valor do tipo double. produto. produto1.atualizapreco(percentual); Contem a utilização do método atualizapreco que se encarrega de ajustar o preço do //produto1.total += produto1.preco; //produto2.total += produto2.preco; Produto.total += produto2.preco; A variável total acumula o valor presente na variável preco do objeto 1b (produto1) e objeto 2 (produto2). public static double convertedouble(string valor) { O método criado tenta efetuar a conversão de uma String para double e usa uma estrutura de manipulação de erros. As exceções em Java referem-se aos erros que podem ser gerados durante a execução de um programa. Esses erros podem ser controlados (tratados) por meio da estrutura trycatch-finally. O comando try(tente) trabalha junto com catch, no bloco o try o Java tenta executar suas instruções, mas se algum erro ocorrer, a execução será desviada para o bloco catch que apresentará o erro de conversão (NumberFormatException). O bloco finally é opcional e fornece um conjunto de códigos que é sempre executado, independente de uma exceção ocorrer ou não. Sintaxe: try{ <conjunto de instruções> catch (Nome da Exceção){ <tratamento do erro 1>

57 Linguagem de Programação I: Uma Abordagem Prática Utilizando Java 57 catch (Nome da Exceção){ <tratamento do erro 2> finally{ <conjunto de instruções> try { numero = Double.parseDouble(valor); A instrução do boco try converte variável valor para double e armazena o resultado na variável numero. catch (NumberFormatException erro) {//Erro de conversão. Neste bloco é apresentado o erro gerado. finally{//opcional, mas sempre será executado. Este bloco sempre é executado na estrutura try-catch-finally. return numero; Todo método que não for declarado com void, isto é, que retornar algum valor, necessita, obrigatoriamente, utilizar o método return() para retornar um valor. 20. LISTA DE EXERCÍCIOS Elabora uma classe que receba o raio de uma esfera (do tipo double) e chame o método volumeesfera para calcular e exibir o volume da esfera na tela, conforme ilustra a figura abaixo. Para cálculo do volume deve ser usada a fórmula seguinte: volume = (4.0/3.0) * PI * raio 3. Figura 13: Exercício 20.1.