Java SE - Aula 15 e 16

STEP Computer Academy
Prof: Luciano Módulo: Java SE Aula 15 e 16
Java SE
© Prof. Luciano
prof.luciano.rj
1
Este material didático foi elaborado com o princípio de que o aluno já tenha alguma noção de
lógica de programação em qualquer linguagem. A propriedade intelectual deste material é do
Professor Paulo Luciano, e-mail de contato: lucianosyq@yahoo.com.br
Sumário
Revisão.................................................................................................................................................3
Aula 15 e 16........................................................................................................................................12
Operador Ternário..........................................................................................................................12
Regras de nomenclatura em Java...................................................................................................15
Métodos em Java...........................................................................................................................17
Método sem retorno.......................................................................................................................18
Métodos com retorno.....................................................................................................................19
Dever de Casa.....................................................................................................................................35
2
Revisão
Tipos Primitivos
byte Inteiro de 8 bits

short Inteiro de 16 bits
int Inteiro de 32 bits
long Inteiro de 64 bits
float Real ou ponto flutuante de 32 bits
double Real ou ponto flutuante de 64 bits
char Um caracter de 16 bits
boolean Boleano (true/ false) 1 bits
Operadores de atribuição
= (“recebe”)
Operadores Aritméticos
+ Soma e Concatenação
- Subtração
* Multiplicação
/ Divisão
% Módulo( resto da divisão)
Operadores incrementação e decrementação

Operadores unários
++ ( prefixo) Primeiro soma 1, depois usa o atributo

-- ( prefixo) Primeiro subtrai 1, depois usa o atributo
++ ( sufixo) Usa o atributo e depois soma + 1
--(sufixo) Usa o atributo e depois subtrai - 1
Operadores Relacionais
> Maior que

< Menor que
>= Maior ou igual
<= Menor ou igual
== Igual
!= Diferente
Obs: O resultado de uma operação com operadores relacionais é sempre um valor booleano
(true/false)
3
Operadores Lógico
&& E
|| OU
! Negação
^ XOU (ou exclusivo)
& E binário
| Ou Binário
Obs: Os operadores lógicos servem para unir mais de uma condição e obter um único
resultado boleano.
Comando de Entrada
Scanner ler = new Scanner(System.in);
float numF = ler.nextFloat();

int num1 = ler.nextInt();
byte byte1 = ler.nextByte();
long lg1 = ler.nextLong();
boolean b1 = ler.nextBoolean();
double num2 = ler.nextDouble();
String nome = ler.nextLine();
String nome = ler.next();
char n = ler.next().charAt(0);
Estrutura de Decisão
Comando IF
O comando if possui a seguinte sintaxe:
if (condição) {
// corpo do comando if
4
Estrutura de Decisão
Comando IF/ELSE
if (condição) {
} else {
Comando if- else- if ou Estrutura de Decisão Encadeada/aninhada

Estrutura sintaxe do comando if/else encadeado
// comando if-else encadeado, usando chaves para definir o corpo de cada bloco
if (condição){
}
else {
if (condição){
}
else{
}
}
// comando if-else encadeado, simplificado, sem

usar chaves
if (condição)
1 comando sem o uso de chaves
else if (condição)
else
5
Comando switch()
Estrutura sintaxe do comando switch() ,sem break.

Obs: no comando switch, sempre que ele entra em um case, ele
executa todos os comandos até o final do corpo do comando switch().
switch( opção )
{
case opção1:
// comandos caso a opção 1 tenha sido escolhida
case opção2:
case opção3:
//comandos caso a opção 3 tenha sido escolhida
default:
//comandos do default
}
Estrutura sintaxe do comando switch() ,com break.
switch( opção )
{
case opção1:
break;
case opção2:
break;
case opção3:
//comandos caso a opção 3 tenha sido escolhida
break;
default:
//comandos do default
}
6
// opção sendo número

// Exemplo de comando Switch com tipo inteiro
// Considerando que a variável op sendo inteiro, todas a opções do case devem ser valores inteiros
int op;
switch (op) {
case 1:
case 2:
case 3:
default:
}
// Exemplo de comando Switch com tipo char

// opção sendo char
// Considerando que a variável op sendo caracter(char), todas a opções do case devem ser valores
char
char op;
switch (op) {
case 'a':
case 'b':
case '6':
case '-':
case '*':
default:
}
// Exemplo de comando Switch com String

// opção sendo String
// Considerando que a variável op sendo String, todas a opções do case devem ser valores String
String op;
switch (op) {
case "casa":
case "h":
case "sair":
case "9876":
case "1ª":
default:
}
7
Operador Composto
+= a+=2 a=a+2
-= b-=3 b=b-3
*= c*=4 c=c*4
/= d/=5 d=d/5
%= e%=3 e=e%3
Estrutura de repetição
Comando while
while( condicao ) {
// bloco de instruções
}
Comando do/while
No comando do-while, o comando while sempre é executado pelo menos 1 vez. A condição fica no
final da instrução.
do {
} while( condicao );
Comando for
for( inicialização de variável ; condição ; incrementação ) {
}
Comando for each

for(tipo variavelAuxiliar : vetor){
}
8
Comando break
Break significa quebrar, parar, frear, interromper.
Quando o Java encontra esse comando pela frente, ele interrompe o laço/estrutura de controle
ATUAL, como o while, for, do/while e o switch
Comando Continue
O comando continue é usado somente em laços de repetição. Quando ele é executado, o laço volta
imediatamente para o teste de condição do laço de repetição. Normalmente, usamos o comando
continue em um teste.
Vetores
int v[]; // declaração e variárel do tipo vetor
v=new int[10]; // instanciando espaço na mémoria para usar o vetor
ou
int v[]= new int[10]; // forma completa de declarar e instanciar um vetor/ array
v[i], corresponde ao i-ésimo elemento do veto a, sendo que o valor da variável i deve
pertencer ao intervalo dos índices do vetor: ((i >= 0) && (i < a.length)).
Manipulação de String
Método charAt()
Extrai um caracter de uma String.
Método length()
Retorna o tamanho de uma String em inteiro
Método compareTo()
Esse método retorna um número inteiro. Retornar 0 se as Strings forem iguais, um número negativo
se a String que invoca o compareTo for menor que a String que é passada como um argumento e um
número positivo se a String que invoca o compareTo for maior que a String que é passada como
argumento.
9
Método equals()
É um método da classe Object sobrescrito na classe String, que serve para comparar dois objetos.
Este método retorno um valor boleano. True se o conteúdo dos objetos forem iguais e False se
forem diferentes.
Método equalsIgnoreCase()
Esse método ignora a distinção entre letras maiúsculas e minúsculas entre as duas Strings
comparadas.
Método replace()
Retorna um novo objeto contendo a String original com um trecho especificado substituído por
outra expressão indicada. Esse método deixa a String original inalterada. O método replace é o que
chamamos no Word da função substituir. Onde podemos substituir uma letra ou um conjunto de
letras.
Método trim()
Gera um novo objeto string, removendo todos os caracteres de espaço em branco que aparecem no
início ou no fim da string em que o método opera. O método retorna um novo objeto string
contendo a string sem espaço em branco inicial ou final. A string original permanece inalterada.
Método isEmpty()
Um método muito utilizado e comum que verifica se uma String está ou não vazia, mas tenha
atenção neste método, pois a verificação baseia-se se sua String possui tamanho = 0, ou seja, o
String.length() = 0. Isso significa que caso você tente utilizar o isEmpty() em uma String que possui
valor NULL você receberá um erro de exceção: NullPointerException.
Método toLowerCase() e toUpperCase()

O método toLowerCase converte toda a String para caixa baixa e o toUpperCase faz o inverso,
convertendo toda a String para caixa alta.
Contains()
É similar a função localizer no Word, ele verifica se uma letra ou palavra esta contida na String, ou
seja, ele verifica se a String contem alguma informação que estamos procurando.
O método contains() retorna um valor boleano, True se a String contem a informação procurada, e
False se a String não contem.
IndexOf()
Esse método é simples, ele é parecido com a função localizar no Word.
A grande diferença é que o método indexOf() localiza a primeira ocorrência daquilo que estamos
procurando e retorna o índice dele na String. Caso ele não encontre o valor, por default retorna -1.
Em resumo o método IndexOf retorna um inteiro. Caso ele encontre, retornará um valor >=0, caso
ele não encontre retorna -1.
10
lastIndexOf()
Já o método lastIndexOf(), é similar ao comando IndexOf(), a única diferença é que o lastIndexOf()
localiza a ultima ocorrência daquilo que estamos procurando na String.
Método substring() Permite extrair substrings de strings. Fornece 2 métodos substring para
permitir que um novo objeto seja criado copiando parte de um objeto String existente. Cada método
retorna um novo objeto desse tipo. Neste método existem duas versões que são:
1ª versão – aceita um argumento inteiro, esse número especifica o índice inicial na String
especificada, a partir da qual os caracteres devem ser copiados. A substring retornada contém
uma cópia dos caracteres desde o índice inicial até o final da Sting.
2ª versão – aceita dois argumentos do tipo inteiro – o índice inicial a partir do qual copia os
caracteres da String original e o índice um a mais além do último caractere que será copiado
(copiar até, mas não incluindo, esse índice na String). A substring retornada contém uma cópia
dos caracteres especificados da String original.
substring(posição_inicial)
substring(posição_inicial, Posição_ Final +1)
Métodos startsWith() e endsWith()

Os métodos startsWith e endsWith aceitam uma String ou uma String e um número inteiro como
argumentos, retornando um valor booleano que indica se a String inicia ou termina,
respectivamente, com o texto informado a partir da posição dada.
Método toCharArray()
Converte uma String em um vetor(array) de Char.
Obs: é um modo mais prático para fazer o Exemplo 1.
Método Split()
Corta, divide uma String em pedaços, conforme o valor determinado no comando Split.
Ele é ideal para quebrar string e armazenar em vetor.
11
Aula 15 e 16
Operador Ternário
No comando if/else temos:

int a=10;
int b;
if (a > 0){
b = 1;
}else{
b = 2;
}
Com o operador ternário ficaria:
b = (a > 0) ? 1 : 2;
A sintaxe é:
(Condição) ? retorna o Valor se a condição for True : retorna Valor se for False
Exemplo 01
Verifique se o número digitado é maior que zero.
package aula_15_16;
import java.util.Scanner;
public class Ex_01 {
public static void main(String[] args) {

System.out.println(" Digite um número maior que zero:");

int n1 = ler.nextInt();
String b = (n1 > 0) ? "sim" : "não";

System.out.println(b);
// ou
System.out.println((n1 > 0) ? "sim" : "não");
ler.close();
}
12
Exemplo 2
String retorno;
int numero = 20;
retorno = ( numero % 2 == 0) ? "Par" : "Impar";

System.out.println(retorno);
System.out.println( numero % 2 == 0) ? "Par" : "Impar");
Verifique se o número digitado é par ou ímpar.
package aula_15_16;

System.out.println(" Digite um Número :");

System.out.println("O número " + n1 + " é " + ( (n1 % 2 == 0) ? "Par" : "ímpar") );
ler.close();
13
Exemplo 3
Para somar digite “s”, para somar.
package aula_15_16;

int a=5, b=8;
System.out.println(" Digite :\n S para somar");
char op = ler.next().charAt(0);
System.out.println(op=='s' ? a+b: "Opção Inválida" );
ler.close();
}
}
14
Regras de nomenclatura em Java
Regra Básica para declaração de qualquer nome (Boas Práticas de Programação):
1. Escrever–se tudo em minúsculo;*

2. Pode conter “_”, underline;
3. Não pode começar com número;
4. Não pode conter somente números;
5. Não pode conter letras acentuadas (ç, á, î, ã, Á, À);
6. Não pode conter pontuação;
7. Não deve possuir caracteres especiais (@, !, %, &).
8. Não pode conter espaço;
9. Caso um nome de uma variável possua um nome composto, toda primeira letra a
partir da segunda palavra, deverá ficar em maiúsculo;
10. Não pode ser uma palavra reservada;
Nomes de Classes
Para nomearmos uma classe em Java devemos seguir as seguintes regras:
As regras básicas mais:

Toda classe deve começar com a primeira letra em Maiúsculo.
Exemplos:
PrimeiraClasse
MinhaClasse
OlaMundo
Nomes de Pacotes
As regras básicas mais:

Escrever-se tudo em minúsculo, até palavras compostas.
Pode usar o caracter “.” Ponto.
Exemplos:
modelo
controle
conexão.banco.dados
br.com.empresa
15
Nomes de Variáveis
As regras básicas.
Exemplos:
_x
$a
b1
c
calculadoraCientifica
Nomes de Métodos
As regras básicas mais;

Todo nome de método é seguido de parênteses “()”.
Exemplos:
imprimir()
imprimirTela()
calcularMedia()
Nomes de Constantes
As regras básicas mais;

Variáveis Constantes devem ser escritos TODA em letras maiúsculas.
Usamos o underline (“_”) para separar nomes compostos.
Exemplos:
TAMANHO
PARAR_DE_EXECUTAR
PI
TESTE_JOGO
16
Métodos em Java
Sem retorno (void)

Com retorno (tipo, uso do return)
Obs: nos métodos, podem ou não haver passagem de argumento.

O termos passagem de argumento refere-se ao ou aos valores passados para o método.
Quando declaramos um método e caso ele tenha algum argumento de entrada, devermos declarar o
seu tipo e o nome dele.
Todo argumento do método é uma variável local e só existe dentro do mesmo.
Métodos devem ser declarados dentro da classe.
Eles podem ser declarados em qualquer parte do bloco da classe. No início ou no final. Em Java não
faz diferença.
17
Método sem retorno
Todo método sem retorno usa a palavra reservada void

Por exemplo o método main() é do tipo void. Logo é um método sem retorno.
Exemplo 04
package Aula_15_16;

menu();
int op = ler.nextInt();
System.out.println("Voce escolheu a opção " + op);

ler.close();
public static void menu() {

System.out.println("Menu");
System.out.println(" Escolha uma opção:");
System.out.println(" 1 - para somar:");
System.out.println(" 2 - para subtrair:");
18
Métodos com retorno.

Todo método com retorno deve possui pelo menos um “return” dentro do seu método.
Como o método retornará alguma informação, devemos declarar o método conforme o tipo que
desejamos retornar.
Exemplo 5
Faça a soma de 2 números.
package Aula_15_16;

System.out.println("Programa para somar 2 números inteiros.");
System.out.println(" Digite o 1º Número:");
System.out.println(" O resultado da soma é :" + (n1+n2));

ler.close();
}
}
}
19
Exemplo 6
Faça a soma de 2 números usando método (com retorno)
Neste caso, iremos fazer um método receber 2 números inteiros e retornará a somatória dos dois
valores que também será um número inteiro.
Sintaxe de declaração de método com retorno.
tipo_do_retorno nome_do_metodo( declaração_argumentos_entrada){

// corpo do método com suas ações
return valor_a_retornar;
package Aula_15_16;

System.out.println("Programa para somar 2 números inteiros.");
System.out.println(" O resultado da soma é :" + soma(n1,n2));

ler.close();
public static int soma( int a, int b) {
return a+b;
}
20
Exemplo de Declaração de métodos:
// metodo void (sem retorno) sem entrada de argumentos
void saudacao() {
System.out.println("Bom dia a todos");
// metodo void ( sem retorno), com passagem de argumentos

// neste caso, serão passados 2 argumentos do tipo inteiro
// um chamado de n1 e outro de n2
void soma2Valores(int n1, int n2) {

System.out.println("A soma é " + ( n1+n2) );
}
// metodo void, com passagem de um argumento do tipo String, que se chamará nome
void saudacao(String nome) {

System.out.println("Bom dia aluno " + nome);
}
// metodo com retorno, que recebe 3 informações como argumento e

// retorna uma informação do tipo int
int somar ( int n1, int n2, int n3) {
int resultado = n1+n2+n3;

return resultado;
//return n1+n2+n3;
}
21
// metodo com retorno que recebe uma string como argumento e

// retorna um char
char primeiraLetra(String nome) {
return nome.charAt(0);
}
// obs:
// cada argumento deve ser declarado individualmente
// quando tivermos mais de um argumento. declare todos separando por virgula, dentro do ( )
// todos os métodos devem ser declarados dentro da classe.
22
Exemplo 7
Exemplo de métodos com retorno
package aula_15_16;

int resultado= soma(4,6);
System.out.println(resultado);
// ou //System.out.println(soma(4,6));
System.out.println(somaDouble(5.8,9));
System.out.println(parImpar(8));
System.out.println(parImpar2(8));
System.out.println(parImpar3(8));
String[] lista = {"ola", "tudo bem!", "como vai", "como tem passado?", 10", "88", "c", "60,45"};
imprimirVetor(lista);
}
public static int soma(int a, int b) {

return a + b;
}
public static double somaDouble(double a, int b) {

return a + b;
}
public static String parImpar(int x) {

return (x)%2==0? "Par": "ìmpar";
}
public static char parImpar2(int x) {

return (x)%2==0? 'p': 'i';
}
public static boolean parImpar3(int x) {

return (x)%2==0? true: false ;
}
public static void imprimirVetor(String[] v) {

for(int i=0; i<v.length; i++)
System.out.println(v[i]);
}
}
23
Exemplo 8
Faça um programa em Java para exibir o menu abaixo.
Menu
Escolha uma opção
Digite 1 para somar
Digite 2 para subtrair
Digite 3 para dividir
Digite 4 para multiplicar
Digite 5 para sair
Elabore a funcionalidade de cada opção usando método.

Obs : No exemplo abaixo, foram feitos métodos com retorno, parar “retornar” o resultado de cada
operação.
package Aula_15_16;
int op;
do{
System.out.println("Escolha uma opção.");
System.out.println("Digite 1 - para somar.");
System.out.println("Digite 2 - para subtrair.");
System.out.println("Digite 3 - para dividir.");
System.out.println("Digite 4 - para multiplicar.");
System.out.println("Digite 5 - para sair.");
op = ler.nextInt();
}while(!(op>=1 && op<=5));
System.out.println("Digite o 1º Número:");
switch(op){
case 1:
System.out.println("O total da soma é: " + somar(n1,n2));
24
break;
case 2:
System.out.println("O total da subtração é: " + subtrair(n1,n2));
break;
case 3:
System.out.println("O total da divisão é: " + dividir(n1,n2));
break;
case 4:
System.out.println("O total da subtração é: " + multiplicar(n1,n2));
break;
case 5:
break;
default:
System.out.println("Você escolheu uma opção inválida");
ler.close();
}
} // fim do void main
// declaração de métodos com retorno

public static int somar(int a , int b){
return a+b;
}

public static int subtrair(int a, int b){
return a-b;
}

public static double dividir(int a, int b){
return a/b;
}

public static int multiplicar( int a, int b){
return a*b;
}
}// fim da classe
Obs: Observem que no exemplo acima, quando escolhemos a opção 5(sair), ele pede 2 números pa-
ra depois dizer sair. O ideal seria que cada interação com o usuário, estivesse dentro do seu respecti-
vo “case”.
25
Exemplo 9
Faça um programa em Java para exibir o menu abaixo.
Menu
Escolha uma opção
Digite 1 para somar
Digite 2 para subtrair
Digite 3 para dividir
Digite 4 para multiplicar
Digite 5 para sair
Elabore a funcionalidade de cada opção usando método.

Obs : No exemplo abaixo, foram feitos métodos sem retorno. Em cada método foram feitos toda a
funcionalidade pedida.
package Aula_15_16;

int op;
do{
System.out.println("Escolha um opção abaixo.");
op = ler.nextInt();
}while(!(op>=1 && op<=5));
switch(op){
case 1:
somar();
break;
case 2:
26
subtrair();
break;
case 3:
dividir();
break;
case 4:
multiplicar();
break;
case 5:
System.out.println("Saindo do programa.");
break;
default:
}
System.out.println("Fim do programa.");
ler.close();
} // fim da classe
// declaração de métodos sem retorno

public static void somar(){
System.out.println("O total da soma é: "+(n1+n2));
}
public static void subtrair(){
System.out.println("O total da subtração é: "+(n1-n2));
}
public static void dividir(){
27
System.out.println("O total da divisão é: "+(n1/n2));
}
public static void multiplicar(){
System.out.println("O total da multiplicação é: "+(n1*n2));
28
Exemplo 10
Declarando ler como atributo da classe.
package Aula_15_16;
public static Scanner ler;

int op;
ler = new Scanner(System.in);
// declaração do atributo ler como atributo da classe, logo toda a classe tem acesso a
esta variável/ atributo.
do{
op = ler.nextInt();
}while(!(op>=1 && op<=5));
switch(op){
case 1:
somar();
break;
case 2:
subtrair();
break;
case 3:
dividir();
break;
case 4:
multiplicar();
break;
case 5:
break;
default:
29
}
ler.close();
} // fim da classe

public static void somar(){
//Scanner ler = new Scanner(System.in); // não precisa declarer novamente,
pois ler não esta mais local no void main.
System.out.println("O total da soma é: "+(n1+n2));
}
public static void subtrair(){
//Scanner ler = new Scanner(System.in);
System.out.println("O total da subtração é: "+(n1-n2));
}
public static void dividir(){
System.out.println("O total da divisão é: "+(n1/n2));
}
public static void multiplicar(){
System.out.println("O total da multiplicação é: "+(n1*n2));
30
Exemplo 10
Obs : No exemplo abaixo, foram feitos métodos sem retorno com passagem de argumento. Cada
método realiza 2 tarefas: calcular a operação e exibir a informação para o usuário.
package Aula_15_16;

int op;
do{
op = ler.nextInt();
}while(!(op>=1 && op<=5));
switch(op){
case 1:{
somar(n1, n2);
break;
}
case 2:{
subtrair(n1, n2);
break;
}
case 3:{
31
dividir(n1, n2);
break;
}
case 4:{
multiplicar(n1, n2);
break;
}
case 5:
break;
default:
}
ler.close();
// declaração de métodos sem retorno com passagem de argumento

public static void somar(int v1, int v2){
System.out.println("O total da soma é: "+(v1+v2));
}

public static void subtrair(int v1, int v2){
System.out.println("O total da subtração é: "+(v1-v2));
}

public static void dividir(int v1, int v2){
System.out.println("O total da divisão é: "+(v1/v2));
}

public static void multiplicar(int v1, int v2){
System.out.println("O total da multiplicação é: "+(v1*v2));
}
}// fim da classe
32
Exemplo 11
Obs : No exemplo abaixo, foram feitos métodos com retorno e com passagem de argumento. Cada
método realiza somente 1 tarefa: calcular a operação e retorna o resultado para quem o chama.
package Aula_15_16;

int op;
do{
op = ler.nextInt();
}while(!(op>=1 && op<=5));
switch(op){
case 1:{
System.out.println("O total da soma é: " + somar(n1, n2));
break;
}
case 2:{
System.out.println("O total da soma é: "+ subtrair(n1, n2));
break;
}
case 3:{
33
System.out.println("O total da divisão é: "+ dividir(n1, n2));
break;
}
case 4:{
System.out.println("O total da multiplicação é: "+ multiplicar(n1, n2));
break;
}
case 5:
break;
default:
}
ler.close();
// declaração de métodos com retorno e com passagem de argumento

public static void somar(int v1, int v2){
return (v1+v2);
}

public static void subtrair(int v1, int v2){
return (v1-v2);
}

public static void dividir(int v1, int v2){
return (v1/v2);
}

public static void multiplicar(int v1, int v2){
return (v1*v2);
}
}// fim da classe
34
Dever de Casa
Exercícios
Refaça alguns exercícios anteriores, usando métodos para realizar as tarefas.
Faça usando métodos void e com retorno. Com ou sem passagem de argumentos.
1. Faça um programa em Java para ler um número inteiro. O método deverá dizer se o número
é par ou ímpar.
2. Faça um programa em Java para ler um número inteiro. O método deverá dizer se o número
é negativo positivo ou nulo.
3. Faça um programa em Java para ler o ano. O método deverá dizer se ele é bissexto.
4. Faça um programa em Java, onde o usuário deverá digitar seu nome completo. O método
deverá informar seu primeiro nome, sobrenome e nome do meio, caso haja.
5. Faça um programa em Java, onde o usuário deverá digitar uma frase. O método deverá
contar quantas vogais, consoantes, números e pontuação existem. Além disso deverá
informar quantas palavras têm na frase.
6. Faça um programa em Java para armazenar o nome e o e-mail do usuário. O usuário deverá
digitar o nome e o e-mail. Valide o e-mail digitado. O método deverá verificar se no e-mail,
contém caracteres inválidos como: ç, ~, ã, õ, -, /, |, \, #, $, %, ¨, &, espaço_vazio, *, (, ), +,
=, e se contem . e @.
7. Faça um programa em Java onde o usuário deverá digitar alguma informação como String.
Faça um método para verificar se a informação digitada é uma palavra, número inteiro ou
número real. Considere sendo uma palavra qualquer conjunto de caracteres que contenha
somente vogais e consoantes em qualquer ordem.
8. Faça um programa em Java, onde o usuário deverá digitar o nome completo. Faça um
método que deverá colocar cada primeira letra de cada nome em maiúsculo. Exceto as
conjunções, como as palavras “de”, “da”, “dos” e etc que ligam 2 nomes. Exiba na tela o
nome editado.
9. Faça um programa em Java para desenhar um quadrado de @. O usuário deverá informar o

tamanho do quadrado. Faça um método para desenha o quadrado.
35
10. Faça um programa em Java para desenhar um triângulo retângulo de #. O usuário deverá
informar a altura do triângulo. A Base do triângulo varia conforme a altura. Ex: 4 de altura, a
base deverá ter 4 #. Faça um método para desenhar o triângulo.
11. Faça um programa para fazer a média aritmética das notas do ano. Leia 4 notas do tipo
double. Exiba na tela a média aritmética e se o aluno está aprovado ou reprovado. A média
aritmética é a soma das 4 notas, dividido por 4 e a nota de aprovação da média é 5.0.
Refaça alguns exercícios das aulas anteriores. Usar o operador ternário, no lugar do
IF. Use métodos para realizar as tarefas desejadas.
12. Faça um programa para ler 2 números inteiros e diga qual é o menor número.
13. Faça um programa para ler 2 números double e diga qual é o maior número.
14. Faça um programa para ler 2 palavras. Diga se elas são iguais ou são diferentes.
15. Faça um programa para ler um número inteiro. Faça um método para dizer se o número
digitado é par ou ímpar.
36

Java SE - Aula 15 e 16

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Java SE - Aula 15 e 16

Enviado por

Direitos autorais:

Formatos disponíveis

STEP Computer Academy

Prof: Luciano Módulo: Java SE Aula 15 e 16

byte Inteiro de 8 bits

Operadores incrementação e decrementação

++ ( prefixo) Primeiro soma 1, depois usa o atributo

> Maior que

Scanner ler = new Scanner(System.in);

float numF = ler.nextFloat();

O comando if possui a seguinte sintaxe:

Comando if- else- if ou Estrutura de Decisão Encadeada/aninhada

// comando if-else encadeado, simplificado, sem

Estrutura sintaxe do comando switch() ,sem break.

Estrutura sintaxe do comando switch() ,com break.

// opção sendo número

// Exemplo de comando Switch com tipo char

// Exemplo de comando Switch com String

Comando for each

Método toLowerCase() e toUpperCase()

Métodos startsWith() e endsWith()

No comando if/else temos:

Verifique se o número digitado é maior que zero.

public class Ex_01 {

public static void main(String[] args) {

System.out.println(" Digite um número maior que zero:");

String b = (n1 > 0) ? "sim" : "não";

retorno = ( numero % 2 == 0) ? "Par" : "Impar";

Verifique se o número digitado é par ou ímpar.

public class Ex_02 {

public static void main(String[] args) {

System.out.println(" Digite um Número :");

public class Ex_03 {

public static void main(String[] args) {

Regras de nomenclatura em Java

Regra Básica para declaração de qualquer nome (Boas Práticas de Programação):

1. Escrever–se tudo em minúsculo;*

Para nomearmos uma classe em Java devemos seguir as seguintes regras:

As regras básicas mais:

As regras básicas mais:

As regras básicas mais;

As regras básicas mais;

Sem retorno (void)

Obs: nos métodos, podem ou não haver passagem de argumento.

Método sem retorno

Todo método sem retorno usa a palavra reservada void

public class Ex_04 {

public static void main(String[] args) {

System.out.println("Voce escolheu a opção " + op);

public static void menu() {

Métodos com retorno.

Faça a soma de 2 números.

public class Ex_05 {

public static void main(String[] args) {

System.out.println(" O resultado da soma é :" + (n1+n2));

Sintaxe de declaração de método com retorno.

tipo_do_retorno nome_do_metodo( declaração_argumentos_entrada){

public class Ex_06 {

public static void main(String[] args) {

System.out.println(" O resultado da soma é :" + soma(n1,n2));

public static int soma( int a, int b) {

Exemplo de Declaração de métodos:

// metodo void (sem retorno) sem entrada de argumentos

// metodo void ( sem retorno), com passagem de argumentos

void soma2Valores(int n1, int n2) {