Java_Basico2

Prévia do material em texto

Java Básico
 
Aula 1
 
O que é uma máquina virtual
Uma máquina virtual é uma implementação em software de 
uma máquina que executa programas como um computador 
real. 
Os programas que executam em uma máquina virtual só têm 
acesso aos recursos e abstrações providos pela máquina 
virtual.
A Máquina Virtual Java (JVM)
Linux
Dell
JVM para Linux
Minha aplicação 1
Windows
Sony
JVM para Windows
Minha aplicação 1
O que a máquina virtual Java faz?
Executa aplicação Java compilada em bytecode.
Permite que uma mesma aplicação Java seja executada em 
sistemas operacionais diferentes sem necessidade de 
modificação ou recompilação em bytecode. (portabilidade)
Como a JVM é distribuída para os 
usuários?
● Java Runtime Environment (JRE)
○ executa aplicações Java compiladas em bytecode 
através do comando java.
● Java Development Kit (JDK)
○ compila código Java em bytecode através do comando 
javac.
○ executa aplicações Java compiladas em bytecode 
através do comando java.
Obs.: você deve baixar o JDK do site da Oracle e instalar no 
seu computador antes de prosseguir com o curso.
Como é o código de uma aplicação 
Java?
// arquivo OlaMundo.java
public class OlaMundo { // isto é uma classe pública
 public static void main(String[] args) { // isto é o método main
 System.out.println("Olá, mundo!"); // imprime na tela
 } // fim do método main
} // fim da classe OlaMundo e do arquivo OlaMundo.java
Obs. 1: os caracteres a partir de // até o fim da linha são 
comentários e são ignorados pela máquina virtual Java.
Obs. 2: toda aplicação Java tem ao menos uma classe 
pública.
Obs. 3: uma classe pública deve ser salva em um arquivo com 
o mesmo nome da classe e a extensão ".java".
Obs. 4: toda aplicação Java tem um método main dentro de 
uma classe pública.
Como é o código de uma aplicação 
Java?
// arquivo OlaMundo.java
public class OlaMundo { // isto é uma classe pública
 public static void main(String[] args) { // isto é o método main
 System.out.println("Olá, mundo!"); // imprime na tela
 } // fim do método main
} // fim da classe OlaMundo e do arquivo OlaMundo.java
Obs. 5: o conteúdo do método main é o que será executado 
pela máquina virtual Java.
Obs. 6: a linguagem Java é case-sensitive (maiúsculas e 
minúsculas são diferenciadas).
Obs. 7: por convenção, nomes de classes começam com 
letras maiúsculas e nomes de métodos com letras minúsculas.
Obs. 8: as palavras em vermelho são palavras reservadas.
Como compilar e executar um código 
Java?
No Linux, abra o Terminal ou Console e navegue até o diretório 
onde está salvo o arquivo a ser compilado.
No Windows, abra o Prompt de Comando (cmd) ou Prompt do 
MS-DOS e navegue até a pasta onde está salvo o arquivo a 
ser compilado.
Então, digite "javac OlaMundo.java" e pressione Enter para 
compilar o código. Será gerado o arquivo "OlaMundo.class".
Agora, digite "java OlaMundo" e pressione Enter para 
executar a aplicação. Nesse momento, o método main é 
invocado.
Aula 2
 
Palavras reservadas
abstract continue for new switch
assert default goto package synchronize
dboolean do if private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while
Tipos primitivos e tipo String
byte 8 bits -128 a 127
short 16 bits -32768 a 32767
int 32 bits -2147483648 a 2147483647
long 64 bits -9223372036854775808L a ...
float 32 bits decimais de precisão única (1.5F, -1.5F, ...)
double 64 bits decimais de precisão dupla (1.5, -1.5, ...)
boolean 1 bit* true, false
char 16 bit 'a', 'B', ' ', '-', '3', '/', '=', ...
String* variável "aB -3/=", ...
Declarando e usando variáveis
public class Variaveis {
 public static void main(String[] args) {
 byte b = 127; // declara e inicializa variável b do tipo byte
 short s = 32767; // declara e inicializa variável s do tipo 
short
 int i = 2147483647; // ...
 long l = 9223372036854775807L; // não esqueça do L
 float f = 1.5F; // não esqueça do F
 double d = 1.5; // casas decimais são separadas por '.'
 boolean bo = true; 
 char c = 'A'; // use aspas simples para caracteres
 String st = "minha String"; // use aspas duplas para Strings
 System.out.println(b); // imprime valor da variável b
 }
}
Declarando e usando variáveis
public class Variaveis {
 public static void main(String[] args) {
 byte limiteInferior = -128;
 byte limiteSuperior = 127;
 System.out.println(limiteInferior); // case-sensitive
 System.out.println(limiteSuperior); // case-sensitive
 limiteInferior = 50; // atribui novo valor a limiteInferior
 System.out.println(limiteInferior); 
 byte limiteSuperior = 0; // outra variável com mesmo 
nome?!
 System.out.println(limiteSuperior); 
 }
}
Aula 3
 
Declarando e usando constantes
public class Constantes {
 public static void main(String[] args) {
 final byte B = 127; // declara e inicializa constante B do tipo 
byte
 final char CH = 'p'; // convenção: constante com letra 
maiúscula
 System.out.println(CH); // imprime valor da constante CH
 CH = '-'; // atribui novo valor à constante CH?!
 System.out.println(CH);
 byte b = 0;
 System.out.println(b);
 }
}
Operadores aritméticos
Adição
+
Subtração
-
Multipl.
*
Divisão
/
Módulo
%
1 + 2 = 3
1.0 + 2 = 3.0
5 - 3 = 2 
5 - 3.0 = 2.0
2 * 3 = 6
2.0 * 3 = 6.0
5 / 2 = 2
5 / 2.0 = 2.5
7 % 2 = 1
7.0 % 2 = 1.0
int a = 1;
int b = 2;
int c = a + b;
int a = 5;
int b = 3;
int c = a - b;
int a = 2;
int b = 3;
int c = a * b;
int a = 5;
int b = 2;
int c = a / b;
int a = 7;
int b = 2;
int c = a % b;
Operadores de atribuição
Atribuição
=
int a = 2; // o valor de a é 2
Atrib. e soma
+=
int a = 2;
a += 3; // o valor de a é 2+3
Atrib. e subtração
-=
int a = 2;
a -= 3; // o valor de a é 2-3
Atrib. e multipl.
*=
int a = 2;
a *= 3; // o valor de a é 2*3
Atrib. e divisão
/=
int a = 2;
a /= 3; // o valor de a é 2/3
Atrib. e módulo
%=
int a = 7;
a %= 2; // o valor de a é 7%2
Operadores de incremento
Incrementa 1 e usa
++var
int a = 2;
System.out.println(++a);
// valor de a é 3 e imprime 3
Decrementa 1 e usa
--var
int a = 2;
System.out.println(--a);
// valor de a é 1 e imprime 1
Usa e incrementa 1
var++
int a = 2;
System.out.println(a++);
// imprime 2 e valor de a é 3
Usa e decrementa 1
var--
int a = 2;
System.out.println(a--);
// imprime 2 e valor de a é 1
Operadores relacionais
Menor 
<
2 < 3 int a = 2;
int b = 3; boolean c = a < b;
Maior
>
3 > 2 int a = 3;
int b = 2; boolean c = a > b;
Menor
ou igual
<=
2 <= 3
2 <= 2
int a = 2;
int b = 3;
boolean c = a <= b;
Maior
ou igual
>=
3 >= 2
3 >= 3
int a = 3;
int b = 2;
boolean c = a >= b;
Igual
==
3 == 3 int a = 3;
int b = 3; boolean c = a == b;
Diferente
!=
2 != 3 int a = 2;
int b = 3; boolean c = a != b;
Operadores lógicos
AND
&&
OR
||
NOT
!
true && true (true)
true && false (false)
false && true (false)
false && false (false)
true || true (true)
true || false (true)
false || true (true)
false || false (false)
!true (false)
!false (true)
boolean a = false;
boolean b = true;
boolean c = a && b;
boolean a = false;
boolean b = true;
boolean c = a || b;
boolean a = false;
boolean b = !a;
boolean c = true;
boolean d = !c;
Controles de fluxo (if..else)
public class ControleFluxoIfElse {
 public staticvoid main(String[] args) {
 byte b = 127; // declara e inicializa variável b do tipo byte
 if (b == 127) { // se (condição)
 // comando a ser executado se a condição do if se aplicar
 System.out.println("b é igual a 127");
 } else { // senão
 // comando a ser executado se a condição do if não se 
aplicar
 System.out.println("b NÃO é igual a 127");
 }
 }
}
Controles de fluxo (if..else)
public class ControleFluxoIfElse {
 public static void main(String[] args) {
 byte b = 125; // declara e inicializa variável b do tipo byte
 if (b == 127) { // se (condição)
 System.out.println("b é igual a 127");
 } else if (b == 126) { // senão se (outra condição)
 System.out.println("b é igual a 126");
 } else { // senão
 System.out.println("b NÃO é igual a 127 ou 126");
 }
}
Aula 4
 
Controles de fluxo (switch..case)
public class ControleFluxoSwitchCase {
 public static void main(String[] args) {
 byte b = 1; // declara e inicializa variável b do tipo byte
 switch (b) { // avalie o valor de b
 case 1: // caso b seja igual a 1
 System.out.println("b é igual a 1");
 }
 }
}
Controles de fluxo (switch..case)
public class ControleFluxoSwitchCase {
 public static void main(String[] args) {
 byte b = 1; // declara e inicializa variável b do tipo byte
 switch (b) { // avalie o valor de b
 case 1: // caso b seja igual a 1
 System.out.println("b é igual a 1");
 break;
 case 2: // caso b seja igual a 2
 System.out.println("b é igual a 2");
 }
 }
}
Controles de fluxo (switch..case)
public class ControleFluxoSwitchCase {
 public static void main(String[] args) {
 byte b = 1; // declara e inicializa variável b do tipo byte
 switch (b) {
 case 1: // caso b seja igual a 1
 System.out.println("b é igual a 1");
 break;
 case 2: // caso b seja igual a 2
 System.out.println("b é igual a 2");
 break;
 default: // para qualquer outro valor de b
 System.out.println("b NÃO é igual a 1 ou a 2");
 }
 }
}
Controles de fluxo (switch..case)
public class ControleFluxoSwitchCase {
 public static void main(String[] args) {
 byte b = 1; // declara e inicializa variável b do tipo byte
 switch (b) {
 case 1: // caso b seja igual a 1
 System.out.println("b é igual a 1");
 // sem o break o switch continua
 case 2: // caso b seja igual a 2
 System.out.println("b é igual a 2");
 // sem o break o switch continua
 default: // para qualquer outro valor de b
 System.out.println("b NÃO é igual a 1 ou a 2");
 }
 }
}
Laço for
public class LacoFor {
 public static void main(String[] args) {
 for (int i = 0; i < 10; i++) { // 10 vezes em ordem crescente
 System.out.println(i); // imprime o valor de "i"
 }
 }
}
Laço for
public class LacoFor {
 public static void main(String[] args) {
 for (int i = 0; i < 10; i = i + 2) { // crescente de dois em dois
 System.out.println(i); // imprime pares menores que 10
 }
 }
}
Laço for
public class LacoFor {
 public static void main(String[] args) {
 for (int i = 10; i > 0; i--) { // 10 vezes em ordem decrescente
 System.out.println(i); // imprime o valor de "i"
 }
 }
}
Laço for
public class LacoFor {
 public static void main(String[] args) {
 for (int i = 10; i >= 0; i--) { // 11 vezes em ordem decrescente
 System.out.println(i); // imprime o valor de "i"
 }
 }
}
Laço for
public class LacoFor {
 public static void main(String[] args) {
 for (int i = 10; true; i+=100) { // laço infinito; saltos de cem
 System.out.println(i); // imprime o valor de "i"
 }
 }
}
Comando break com for
public class ComandoBreakComFor {
 public static void main(String[] args) {
 laco: for (int i = 10; true; i+=100) { // saltos de cem
 System.out.println(i); // imprime o valor de "i"
 if (i > 10000) {
 break laco; // quebra o laço
 // "break" pode ser usado com qualquer tipo de laço
 }
 }
 }
}
Aula 5
 
Laço while
public class LacoWhile {
 public static void main(String[] args) {
 int i = 0; // declaração da variável de iteração
 while (i < 10) { // condição de execução do laço
 System.out.println(i); // imprime o valor de "i"
 i++; // incremento da variável de iteração
 }
 }
}
Laço while
public class LacoWhile {
 public static void main(String[] args) {
 int i = 0; // declaração da variável de iteração
 while (i < 10) { // condição de execução do laço
 System.out.println(i); // imprime o valor de "i"
 i += 2; // incremento de 2 em 2
 }
 }
}
Laço while
public class LacoWhile {
 public static void main(String[] args) {
 int i = 10; // declaração da variável de iteração
 while (i > 0) { // 10 iterações
 System.out.println(i); // imprime o valor de "i"
 i--; // decremento da variável de iteração
 }
 }
}
Laço while
public class LacoWhile {
 public static void main(String[] args) {
 int i = 10; // declaração da variável de iteração
 while (i >= 0) { // 11 iterações
 System.out.println(i); // imprime o valor de "i"
 i--; // decremento da variável de iteração
 }
 }
}
Laço while
public class LacoWhile {
 public static void main(String[] args) {
 while (true) { // infinitas iterações
 System.out.println("a"); // imprime "a"
 }
 }
}
Comando break com while
public class ComandoBreakComWhile {
 public static void main(String[] args) {
 int i = 0; // declaração da variável de iteração
 laco: while (i < 100) { // condição de execução do laço
 System.out.println(i); // imprime o valor de "i"
 if (i > 20) {
 break laco; // quebra o laço
 }
 i += 2; // incremento de 2 em 2
 }
 }
}
Laço do...while
public class LacoDoWhile {
 public static void main(String[] args) {
 int i = 0; // declaração da variável de iteração
 do {
 System.out.println(i); // imprime o valor de "i"
 i++; // incremento da variável de iteração
 } while (i < 10); // condição de repetição
 }
}
Laço do...while
public class LacoDoWhile {
 public static void main(String[] args) {
 int i = 0; // declaração da variável de iteração
 do {
 System.out.println(i); // imprime o valor de "i"
 i += 2; // incremento de 2 em 2
 } while (i < 10); // condição de repetição
 }
}
Laço do...while
public class LacoDoWhile {
 public static void main(String[] args) {
 int i = 10; // declaração da variável de iteração
 do {
 System.out.println(i); // imprime o valor de "i"
 i--; // decremento de 1 em 1
 } while (i > 0); // 10 iterações
 }
}
Laço do...while
public class LacoDoWhile {
 public static void main(String[] args) {
 int i = 10; // declaração da variável de iteração
 do {
 System.out.println(i); // imprime o valor de "i"
 i--; // decremento de 1 em 1
 } while (i >= 0); // 11 iterações
 }
}
Laço do...while
public class LacoDoWhile {
 public static void main(String[] args) {
 do {
 System.out.println("a"); // imprime "a"
 } while (true); // infinitas iterações
 }
}
Comando break com do...while
public class ComandoBreakComDoWhile {
 public static void main(String[] args) {
 int i = 0; // declaração da variável de iteração
 laco: do {
 System.out.println(i);// imprime o valor de "i"
 i += 2; // incremento de 2 em 2
 if (i > 20) {
 break laco; // quebra o laço
 }
 } while (i < 100); // condição de repetição
 }
}
Comando continue para for
public class ComandoContinue {
 public static void main(String[] args) {
 laco1: for (int i = 0; i < 1000; i+=100) { // saltos de cem
 if (i < 500) {
 continue laco1; // avança para a próxima iteração do laço
 // "continue" pode ser usado com qualquer tipo de laço
 }
 System.out.println(i); // imprime o valor de "i"
 }
 }
}
Comando continue para while
public class ComandoContinue {
 public static void main(String[] args) {
 int i = 0;
 laco2: while (i < 1000) { 
 i += 100; // saltos de cem
 if (i < 500) {
 continue laco2; // avança para a próxima iteração do laço
 // "continue" pode ser usado com qualquer tipo de laço
 }
 System.out.println(i); // imprime o valor de "i"
 }
 }
}
Comando continue para do...while
public class ComandoContinue {
 public static void main(String[] args) {
 int i = 0;
 laco3: do { 
 i += 100; // saltos de cem
 if (i < 500) {
 continue laco3; // avança para a próxima iteração do laço
 // "continue" pode ser usado com qualquer tipo de laço
 }
 System.out.println(i); // imprime o valor de "i"
 } while (i<1000);
 }
}
Aula 6
 
Arrays unidimensionais
public class ArraysUnidimensionais {
 public static void main(String[] args) {
 String[] valores = new String[4]; // declara/inicializa array
 valores[0] = "0"; // insere valor "0" na posição "0"
 valores[1] = "10"; // insere valor "10" na posição "1"
 valores[2] = "20"; // insere valor "20" na posição "2"
 valores[3] = "30"; // insere valor "30" na posição "3"
 System.out.println(valores[0]); // imprime valor da pos. "0"
 System.out.println(valores[1]); // imprime valor da pos. "1"
 System.out.println(valores[2]); // imprime valor da pos. "2"
 System.out.println(valores[3]); // imprime valor da pos. "3"
 }
}
Arrays unidimensionais
public class ArraysUnidimensionais {
 public static void main(String[] args) {
 String[] valores = new String[4]; // declara/inicializa array
 valores[0] = "0"; // insere valor "0" na posição "0"
 valores[1] = "10"; // insere valor "10" na posição "1"
 valores[2] = "20"; // insere valor "20" na posição "2"
 valores[3] = "30"; // insere valor "30" na posição "3"
 int j = 0;
 while (j < 4) {
 System.out.println(valores[j++]); // imprime valor da pos. "j"
 }
 }
}
Arrays unidimensionais
public class ArraysUnidimensionais {
 public static void main(String[] args) {
 String[] valores = new String[] {"0", "10", "20", "30"};
 int j = 0;
 while (j < 4) {
 System.out.println(valores[j++]); // imprime valor da pos. "j"
 }
 }
}
Arrays unidimensionais
public class ArraysUnidimensionais {
 public static void main(String[] args) {
 int[] inteiros = new int[4]; // declara/inicializa array de int
 inteiros[0] = 0; // insere valor 0 na posição "0"
 inteiros[1] = 10; // insere valor 10 na posição "1"
 inteiros[2] = 20; // insere valor 20 na posição "2"
 inteiros[3] = 30; // insere valor 30 na posição "3"
 int j = 0;
 while (j < 4) {
 System.out.println(inteiros[j++]); // imprime valor da pos. "j"
 }
 }
}
Arrays unidimensionais
public class ArraysUnidimensionais {
 public static void main(String[] args) {
 int[] inteiros = new int[4]; // declara/inicializa array de int
 for (int i = 0; i < 4; i++) {
 inteiros[i] = i * 10; // insere valor i * 10 na posição "i"
 }
 int j = 0;
 while (j < 4) {
 System.out.println(inteiros[j++]); // imprime valor da pos. "j"
 }
 }
}
Arrays unidimensionais
public class ArraysUnidimensionais {
 public static void main(String[] args) {
 int[] inteiros = new int[] {0, 10, 20, 30};
 int j = 0;
 while (j < 4) {
 System.out.println(inteiros[j++]); // imprime valor da pos. "j"
 }
 }
}
Arrays bidimensionais
public class ArraysBidimensionais {
 public static void main(String[] args) {
 String[][] valores = new String[2][3]; // declara/inicializa array
 valores[0][0] = "0"; // insere valor "0" na posição "0,0"
 valores[0][1] = "10"; // insere valor "10" na posição "0,1"
 valores[0][2] = "20"; // insere valor "20" na posição "0,2"
 valores[1][0] = "30"; // insere valor "30" na posição "1,0"
 valores[1][1] = "40"; // insere valor "40" na posição "1,1"
 valores[1][2] = "50"; // insere valor "50" na posição "1,2"
 System.out.println(valores[0][0]); // imprime valor da pos. 
"0,0"
 System.out.println(valores[0][1]); // imprime valor da pos. 
"0,1"
 System.out.println(valores[1][2]); // imprime valor da pos. 
"1,2"
 }
}
Arrays bidimensionais
public class ArraysBidimensionais {
 public static void main(String[] args) {
 String[][] valores = new String[2][3]; // declara/inicializa array
 valores[0][0] = "0"; // insere valor "0" na posição "0,0"
 valores[0][1] = "10"; // insere valor "10" na posição "0,1"
 valores[0][2] = "20"; // insere valor "20" na posição "0,2"
 valores[1][0] = "30"; // insere valor "30" na posição "1,0"
 valores[1][1] = "40"; // insere valor "40" na posição "1,1"
 valores[1][2] = "50"; // insere valor "50" na posição "1,2"
 for (int i = 0; i < 2; i++) {
 for (int j = 0; j < 3; j++) {
 System.out.println(valores[i][j]);
 }
}}}
Arrays bidimensionais
public class ArraysBidimensionais {
 public static void main(String[] args) {
 String[][] valores = new String[][] {
 {"0","10","20"},
 {"30","40", "50"}
 };
 for (int i = 0; i < 2; i++) {
 for (int j = 0; j < 3; j++) {
 System.out.println(valores[i][j]);
 }
}}}
Arrays bidimensionais
public class ArraysBidimensionais {
 public static void main(String[] args) {
 String[][] valores = new String[][] {
 {"0","10","20"},
 {"30","40", "50"}
 };
 for (int i = 0; i < 2; i++) {
 System.out.print("{");
for (int j = 0; j < 3; j++) {
 System.out.print(" " + valores[i][j] + ",");
}
 System.out.println("}, ");
 }
}}
Exercício
Implemente um algoritmo em Java para calcular e imprimir o 
resultado da multiplicação das seguintes matrizes:
A = |2 3|
 |1 0|
 |4 5|
B = |3 1|
 |2 4|
Solução do Exercício
int matrizA[][] = { { 2, 3 }, { 1, 0 }, { 4, 5 } };
int matrizB[][] = { { 3, 1 }, { 2, 4 } };
int[][] matrizC = new int[matrizA.length][matrizB[0].length];
for (int i = 0; i < matrizA.length; i++) {
 for (int j = 0; j < matrizB[0].length; j++) {
 for (int k = 0; k < matrizB.length; k++) {
 matrizC[i][j] += matrizA[i][k] * matrizB[k][j]; }}}
System.out.print("matrizC = { ");
for (int i = 0; i < matrizC.length; i++) {
 System.out.print("{");
 for (int j = 0; j < matrizC[0].length; j++) {
 System.out.print(" " + matrizC[i][j] + ","); }
 System.out.print("}, "); }
System.out.println("}");
Aula 7
 
Entrada de dados (Scanner)
 
Empacotamento de aplicações (JAR)
 
Escopo de variáveis e constantes
 
Transformação de tipos (casting)
 
FIM