Java
210 pág.

Java


DisciplinaProgramação Orientada A Objetos3.948 materiais57.615 seguidores
Pré-visualização43 páginas
Caso contrário, a seqüência de comandos cercada por colchetes após a palavra
else é executada. O comando else é opcional. E caso após o if ou após o else exista apenas um comando, o uso de
colchetes também se torna opcional. Exemplos de uso:
Exemplo 1:
if(elemento1>elemento2)
 System.out.println("O primeiro elemento é maior"); //Repare que 
não são usados colchetes, pois este é o único comando a ser executado 
neste bloco
else{
 elemento1=elemento2;
 System.out.println("O primeiro elemento era menor, mas agora já 
recebeu o valor do segundo elemento");
}
Exemplo 2:
if(elemento2==elemento1) //Este é um exemplo de "if" sem um "else". Se os números não forem iguais, nenhum comando é executado
 System.out.println("Os numeros são iguais");
Exemplo 3:
Comandos de seleção 13
int nota; //Vários "if"s e "else"s podem ser combinados formando vários caminhos que o seu programa pode seguir 
if(acertos==0)
 nota=0;
else if(acertos<20)
 nota=10;
else if(acertos<50)
 nota=40;
else if(acertos<80)
 nota=60;
else 
 nota=100;
Repare que no exemplo acima, só um dos comandos de atribuição será executado. Mesmo que o valor da variável
&quot;acerto&quot; satisfaça mais de uma das condições. O comando a ser executado será o primeiro cujo valor de condição
seja &quot;verdadeiro&quot;. Mas caso os &quot;else&quot;s sejam removidos no exemplo acima, os comandos que seriam executados
seriam todos aqueles cujo valor de condição sejam verdadeiros - e não apenas o primeiro.
O comando switch-case
O comando switch-case é bastante semelhante ao if-then-else. A diferença é que ele é mais recomendado caso o seu
programa tenha muitos caminhos a serem seguidos por ser um comando mais fácil de ser escrito e interpretado. A
sintaxe do comando é
switch(VARIÁVEL){
 case VALOR1: comandos; break;
 case VALOR2: comandos; break;
 (...)
 case VALORn: comandos; break;
 default: comandos; break;
}
Onde VARIÁVEL pode ser qualquer variável de qualquer tipo e VALOR pode ser qualquer literal do mesmo tipo
que a variável. Os comandos a serem executados são aqueles posicionados entre a literal que possuir o mesmo valor
que a variável e o comando &quot;break&quot;. Caso nenhum literal tenha o mesmo valor que a variável, os comandos
posicionados logo após o &quot;default&quot; são executados. O &quot;default&quot; é opcional. Exemplos de uso:
int mes=5;
switch (mes) {
 case 1: System.out.println(&quot;Janeiro&quot;); break;
 case 2: System.out.println(&quot;Fevereiro&quot;); break;
 case 3: System.out.println(&quot;Março&quot;); break;
 case 4: System.out.println(&quot;Abril&quot;); break;
 case 5: System.out.println(&quot;Maio&quot;); break;
 case 6: System.out.println(&quot;Junho&quot;); break;
 case 7: System.out.println(&quot;Julho&quot;); break;
 case 8: System.out.println(&quot;Agosto&quot;); break;
 case 9: System.out.println(&quot;Setembro&quot;); break;
 case 10: System.out.println(&quot;Outubro&quot;); break;
 case 11: System.out.println(&quot;Novembro&quot;); break;
 case 12: System.out.println(&quot;Dezembro&quot;); break;
Comandos de seleção 14
 default: System.out.println(&quot;Mês inválido.&quot;);break;
} 
No exemplo acima, a string &quot;Maio&quot; será impressa na tela.
Como funciona o primeiro programa
O primeiro programa
Olá mundo!
Código-fonte
class Olamundo{
 public static void main(String[] args){
 System.out.println(&quot;Olá mundo!&quot;);
 }
}
Compilação
javac Olamundo.java
O que cada parte faz
class Olamundo
{
}
Declara uma classe (através da palavra-chave class) a ser desenvolvida no bloco entre chaves.
A linguagem Java é organizada numa biblioteca de classes. Também, qualquer programa criado será uma
extensão de uma classe preexistente (ancestral). Para declarar qual classe é a ancestral, utiliza-se o comando
extends. Como não foi utlizado esse comando, assume-se como padrão a superclasse Object. Para
exemplificar, a declaração acima corresponde exatamente a:
class Olamundo extends Object
{
}
Como funciona o primeiro programa 15
public static void main(String[] args)
{
}
É a declaração do método principal (main) da classe Olamundo. Este método é o bloco de programação que
será iniciado pelo interpretador ao acessar a classe Olamundo.
A palavra-chave void indica que esse método não retornará nenhum resultado.
O modificador static indica que esse método é inerente à classe, ou seja, a classe não precisa ser instanciada
num objeto para esse método ser executado.
O modificador de acesso public indica que o método main pode ser executado a partir de outras classes, ou
seja, torna o método main &quot;público&quot;.
String[] args é a declaração dos parâmetros que podem ser enviados, via linha de comandos, para executar o
nosso programa Olamundo. Esses parâmetros formam um vetor de objetos da classe String. Estes objetos são
acessado através dos índices do vetor (a ser estudado) args, por exemplo: args[0], args[1] etc.
Como este programa (depois de compilado) é executado através do comando
 java Olamundo
não estamos usando os argumentos args. Porém, caso o programa fosse executado
 java Olamundo Meu Nome
poderíamos tentar interpretar estes argumentos. Isto é feito no exemplo 2.
 System.out.println(&quot;Olá mundo!&quot;);
&quot;Olá mundo!&quot; é uma instância (não declarada) da classe de cadeia de caracteres String. Para parecer um pouco
mais claro, podemos assumir que &quot;Olá mundo!&quot; é um dado, um conjunto de caracteres.
println é um método que imprime a String &quot;Olá mundo!&quot;.
println é um método da subclasse PrintStream denominada out na classe String. Este método escreve na tela a
cadeia de caracteres que lhe é passada como parâmetro (nesse casso, Olá mundo!) e faz uma quebra de linha
(faz com que a próxima escrita na tela seja na próxima linha).
Simplificando e resumindo
Para simplificar o entendimento vamos incluir comentários no programa:
class Olamundo // declara a classe Olamundo que corresponde ao nome do 
programa
{
 public static void main(String[] args) // declara o método 
principal (main)
 // que será executado ao iniciar a classe
 {
 System.out.println(&quot;Olá mundo!&quot;); // escreve ''Olá mundo!'' na 
tela
 }
}
Como funciona o primeiro programa 16
Nos capítulos adiante serão explicados os termos que ainda não foram descritos aqui (vetores, classes etc.)
Constante
Constantes
As constantes em Java são declaradas através do modificador final. Um modificador de acesso também pode
ser adicionado opcionalmente com o fim de determinar o escopo da constante. A sintaxe para declaração de
uma constante é a seguinte:
 modificador final tipo identificador=literal;
Onde:
\u2022 modificador = modificador de acesso (opcional);
\u2022 tipo = tipo de dado primário;
\u2022 identificador = nome (identificador) da constante;
\u2022 literal = literal que atribui informação à constante.
Exemplo:
 public final int dez=10;
O exemplo acima cria uma constante pública (pelo modificador de acesso public) com o tipo de dado inteiro
int com o valor 10.
Conversão de tipos
De String para tipo básico
int num = Integer.parseInt(numInt);
double num = Double.parseDouble(numDou);
Implícitas
Entre inteiros: tipos menores para tipos maiores;
byte b = 10; short s = 10; int i = 10; long l = 10;
s = b; i = b; i = s; l = b; l = s; l = i;
i = 10; l = 100;
Explícitas
Type Casting
varTipo1 = (tipo1) varOuValTipo2;
Entre inteiros: tipos maiores para tipos menores;
byte b = 10; short s = 10; int i = 10; long l = 10;
b = (byte) s; b = (byte) i; s = (short) i; b = (byte) l; s = (short) l;
 i = (int) l;
b = (byte) 10; s = (short) 10;
Conversão de tipos 17
Cuidado para que o valor que está sendo atribuído não extrapole o tamanho máximo possível do tipo que está
recebendo.
Criando e executando o primeiro programa
Criação de um programa
A criação de um programa