Aula 01 - Apostila JAVA

Prévia do material em texto

FACULDADE PITÁGORAS - UNIDADE BETIM 
Curso: Ciência da Computação 
Disciplina: POO - Programação Orientada a Objetos 1 
Professor: Cristiano Martins Nunes 
Período letivo: 2018/2 
 
# Apostila – Linguagem JAVA 
 
01) O MÉTODO main( ) 
 
Um método é uma sequência de declarações e comandos executáveis encapsulados 
juntos como um miniprograma independente. Em outras linguagens de programação, métodos 
são chamados de funções, procedimentos, sub-rotinas e subprogramas. Logo um programa JAVA 
é uma classe com um método main(), com seguinte formato específico: 
 
public static void main(String[ ] args) { 
... 
} 
 
02) DECLARAÇÃO DE VARIÁVEL E ATRIBUIÇÃO DE VALOR 
 
Na linguagem de programação JAVA, cada variável possui um tipo e um valor. O tipo de 
uma variável determina como seu valor é armazenado na memória do computador. 
 
public static void main(String[ ] args) { 
 
 int year = 2018; 
 double salary = 1.500; 
} 
 
03) TIPOS DE DADOS NO JAVA 
 
Os tipos int e double são dois dos oito tipos primitivos que são definidos em JAVA. Os 
outros seis são long, short, char, byte, float e boolean. 
 
Tipos de dados Primitivos: 
 - Numéricos Inteiro { short, int, long } 
 - Numéricos em Ponto Flutuante { float, double } 
 - Caracteres { char } 
 - Binários { byte } 
 - Booleanos { boolean } 
 
Tipos de dados de Referência: 
 - Interfaces 
 - Classes 
 - Arrays 
 
04) COMENTÁRIOS 
 
Como toda linguagem de programação, você pode fazer comentários em seu código-fonte 
tornando assim uma forma de documentar os códigos deixados. 
 
// Variável de entrada 
 
/* Meu primeiro programa em JAVA */ 
 
/** 
 O método calculaNotaAluno( ) é responsável pelo cálculo 
 da nota final do aluno e o seu 
status final no semestre: aprovado, reprovado e exame final. 
*/ 
 
05) COMANDO DE CONTROLE 
 
O comando if permite execução condicional. O comando que é incluído dentro dele será 
executado somente se sua condição for verdadeira. 
 
 if ( condição ) comando; 
 
O comando if... else... é o comando if com uma cláusula else adicionada. Ele funciona do 
mesmo modo que o comando if exceto que quando uma condição é falsa, o comando dentro da 
cláusula else é executado. 
 
 if ( condição ) 
 { Comandos; } 
else 
 { Comandos; } 
 
O comando if... else... permite a execução condicional baseada em duas alternativas. Se 
você tem mais do que duas possíveis alternativas, você pode encadear uma sequência de 
comandos if... else if... else if... else if... else; 
 
 if ( condição1 ) Comando; 
 else if ( condição2 ) Comando; 
 else if ( condição3 ) Comando; 
 else Comando; 
 
A sintaxe de comando if e if... else... permite que quaisquer comandos sejam usados, seja 
em sua cláusula if, ou em sua cláusula else. Isto significa que podemos colocar outros comandos 
if ou if... else... dentro de um comando if ou em uma cláusula else. Isto é chamado de 
aninhamento de comandos dentro de outros comandos. 
 
 if ( condição1 ) { Comandos; } 
 else 
 if ( condição2 ) { Comandos; } 
 else 
 if ( condição3 ) { Comandos; } 
 else 
 if ( condição4 ) { Comandos; } 
 else 
 { Comandos; } 
 
06) COMANDO switch 
 
O comando switch é similar à combinação if... else if... para processar uma alternativa de 
um conjunto de alternativas. 
 
switch (opcao) { 
case 0 : Comando; break; 
case 1 : Comando; break; 
default: Comando } 
07) COMANDO DE ITERAÇÃO 
 
for ( inicialização; condição; incremento ){ 
Comando1; 
 Comando2; 
 Comando3; 
} 
 
while ( condição ) { 
Comando1; 
 Comando2; 
 Incremento; 
} 
 
do 
 Comando1; 
 Comando2; 
 incremento; 
 while ( condição ) 
 
08) OPERADORES MATEMÁTICOS 
 
( A + B ), ( A – B ), ( A * B ), ( A / B ), ( A % B ), A++, B-- 
 
09) OPERADORES MATEMÁTICOS DE ATRIBUIÇÃO 
 
( A += B), ( A-= B ), ( A*= B ), ( A /= B ), ( A%=B ) 
 
10) COMANDO SAÍDA DE DADOS 
 
 int year = 2018; 
 double notaFinal = 6.86; 
 
 // Saída de dados 
 System.out.print("Ano Letivo: " + year); 
 
 // Saída de dados 
 System.out.print("Notal Final: " + notaFinal); 
 
11) COMANDO DE ENTRADA DE DADOS 
 
 // Classe Scanner e Instância da Classe: 
 Scanner dadoEntrada = new Scanner(System.in); 
 
 // Variável Primitiva e Variável Referência 
 int n1; 
 String alunoNome; 
 
 // Entrada e Sde dados 
 System.out.print("-> Informe N1: "); 
 n1 = dadoEntrada.nextInt(); 
 
 System.out.print("-> Informe Nome: "); 
 alunoNome = dadoEntrada.next(); 
 
 
12) CLASSE String 
 
Um string é uma sequência/coleção de caracteres: palavras, frases e nomes são strings. O 
tipo mais simples de string em JAVA é um objeto da Classe String. Tais objetos são imutáveis; eles 
não podem ser alterados. 
 
String alfabeto = “ABCDEFGHIJKLMNOPQRSTUVWXZ” 
 
13) MÉTODOS DA CLASSE String 
 
String alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
 
System.out.println("This string is: " + alfabeto); 
System.out.println("Its length is: " + alfabeto.length()); 
 
System.out.println("The character at index 4 is: "+ alfabeto.charAt(4)); 
System.out.println("The index of the character Z is: " + alfabeto.indexOf('Z')); 
 
System.out.println("Its lower case version is: " + alfabeto.toLowerCase()); 
System.out.println("This string is still: " + alfabeto); 
 
 
14) SUBSTRING 
 
String alpha = "ABCDEFGHIJKLMNOP"; 
System.out.println("alpha: " + alpha); 
 
System.out.println("alpha.length(): " + alpha.length()); 
String sub = alpha.substring(2, 7); 
 
System.out.println("sub=alpha.substring(2, 7): " + sub); 
 
System.out.println("sub.length: " + sub.length()); 
System.out.println("sub.charAt(3): " + sub.charAt(3)); 
System.out.println("alpha.charAt(3): " + alpha.charAt(3)); 
 
sub = alpha.substring(4); 
System.out.println("sub=alpha.substring(4): " + sub); 
 
System.out.println("sub.length: " + sub.length()); 
System.out.println("sub.charAt(4): " + sub.charAt(4)); 
 
 
15) CONCATENAÇÃO 
 
 String first = "Cristiano"; 
 String last = "Nunes"; 
 
 System.out.println(last + ", " + first); 
 String name = first + " " + last; 
 
 System.out.println("name: " + name); 
 name = "Professor"; 
 
 System.out.println("name: " + name); 
 name += " FAP BETIM"; 
 
 System.out.println("name: " + name); 
 
 
16) PESQUISANDO UM STRING 
 
 String str = "This is the Mississippi River."; 
 System.out.println(str); 
 
 int i = str.indexOf('s'); 
 System.out.println("The first index of 's' is " + i); 
 
 i = str.indexOf('s', i+1); 
 System.out.println("The next index of 's' is " + i); 
 
 i = str.indexOf('s', i+1); 
 System.out.println("The next index of 's' is " + i); 
 
 i = str.lastIndexOf('s'); 
 System.out.println("The last index of 's' is " + i); 
 
 System.out.println(str.substring(i)); 
 
17) SUBSTITUINDO UM STRING 
 
String primeiroNome = "Cristiano"; 
System.out.println("Replace Primeiro Nome: " + primeiroNome.replace('i', 'X') ); 
 
18) BRINCANDO COM O JAVA – QUAL O RESULTADO GERADO? 
 
 String[] listaA = { "gato", "cachorro", "galinha", "piriquito", "porquinho da india" }; 
 String[] listaB = { "eu tenho", "eu quero", "eu tinha" }; 
 String[] listaC = { "eu amo", "eu odeio", "eu adoro" }; 
 
 int tamanhoA = listaA.length; 
 int tamanhoB = listaB.length; 
 int tamanhoC = listaC.length; 
 
 int randNumeroA = (int) (Math.random() * tamanhoA);int randNumeroB = (int) (Math.random() * tamanhoB); 
 int randNumeroC = (int) (Math.random() * tamanhoC); 
 
 String frase = listaA[randNumeroA] +" "+ listaB[randNumeroB] +" "+ listaC[randNumeroC]; 
 System.out.println("Frase: " + frase); 
 
 
 
 
 
 
 
19) MÉTODOS SIMPES I: 
 
public class TestCube { 
public static void main(String[] args) { 
for (int i = 0; i < 6; i++) 
 System.out.println(i + "\t" + cube(i)); 
} 
 static int cube(int n) { 
 return n*n*n; } 
} 
 
20) MÉTODOS SIMPES II: 
 
import java.util.Random; 
 
public class TestMin { 
public static void main(String[] args) { 
Random random = new Random(); 
 for (int i = 0; i < 5; i++) { 
 int m = random.nextInt(100); 
int n = random.nextInt(100); 
int y = min(m, n); 
System.out.println("min(" + m + ", " + n + ") = " + y); } 
} 
 static int min(int x, int y) { 
if (x < y) return x; 
 else return y; } 
} 
21) MÉTODOS BOOLEANOS: 
 
import java.util.Random; 
 
public class TestIsPrime { 
public static void main(String[] args) { 
for (int i = 0; i < 100; i++) 
if (isPrime(i)) System.out.print(i + " "); 
System.out.println(); 
} 
 
static boolean isPrime(int n) { 
if (n < 2) return false; 
if (n == 2) return true; 
if (n%2 == 0) return false; 
for (int d = 3; d <= Math.sqrt(n); d += 2) 
if (n%d == 0) return false; 
return true; } 
} 
 
22) SOBRECARGA DE MÉTODOS: 
import java.util.Random; 
public class TestMax { 
public static void main(String[] args) { 
Random random = new Random(); 
for (int i = 0; i < 4; i++) { 
 int a = random.nextInt(100); 
 int b = random.nextInt(100); 
 int c = random.nextInt(100); 
 System.out.println("max(" + a + "," + b + "," + c + ") = " + max(a, b, c)); 
} 
 } 
static int max(int m, int n) { 
if (m > n) return m; 
 return n;} 
 
static int max(int n1, int n2, int n3) { 
 return max( max(n1, n2), n3); 
} 
} 
 
23) CLASSES E OBJETOS: 
 
Java é uma linguagem de programação orientada a objetos (POO). Seus programas são 
organizados por meio de classes, as quais especificam o comportamento de objetos que 
controlam as ações do programa. Cada objeto é uma instância de alguma classe, que atua como 
um descritor para as instâncias. A classe possui três espécies de membros: 
 
• Campos/Atributos que especificam a espécie de dados armazenados. 
• Métodos que especificam as operações que os objetos podem executar. 
• Construtores que especificam como os objetos devem ser criados. 
 
public class Point { 
private int x, y; 
 
 public Point(int x, int y) { 
 this.x = x; 
 this.y = y; 
 } 
 
 public boolean equals(Point p) { 
 return (x == p.x && y == p.y); 
 } 
 
 
 public int getX() { 
 return x; } 
 
 public int getY() { 
 return y; } 
 
 public String toString() { 
 return new String("(" + (float)x + ", " + (float)y + ")"); } } 
 
24) ARRAYS INTEIROS: 
 
Um array é um objeto que consiste de uma sequência de elementos números que 
possuem o mesmo tipo geral. Os elementos são numerados a partir da posição de 0 e podem ser 
referenciados pelo seu número, usando operador de subscrito[ ]. Arrays são largamente usados 
devido à sua eficiência. 
 
 // Declaração de Array A: 
 int[] vetorA = new int[10]; 
 
 // Declaração de Array B: 
 int vetorB[] = {1,2,3,4,5}; 
 
 // Função length: 
 int tamanho1 = vetorA.length; 
 int tamanho2 = vetorB.length; 
 
 System.out.println("Tamanho do VetorA: " + tamanho1); 
 System.out.println("Tamanho do VetorB: " + tamanho2); 
 
25) ARRAYS BIDIMENSIONAL: 
 
 // Declaração de Array 
 int matriz[][] = new int[2][2]; 
 
 // Atribuição de Valores no Array 
 int matriz2[][] = {{10, 20}, {30, 40}}; 
 
 // Acessando Array 
 for (int linha = 0; linha < 2; linha++) { 
 for (int coluna = 0; coluna < 2; coluna++) { 
 matriz[linha][coluna] = (1 * coluna); 
 System.out.printf("\t %d \t", matriz[linha][coluna]); 
 } 
 System.out.println(); 
 } 
 
 // Acessando Array 
 for (int linha = 0; linha < 2; linha++) { 
 for (int coluna = 0; coluna < 2; coluna++) { 
 System.out.printf("\t %d \t", matriz2[linha][coluna]); 
 } 
 System.out.println(); 
26) ARRAYS DE STRINGS E OUTROS OBJETOS: 
 
• double[ ] vetor = { 2.33, 4.123, 1.1441 }; 
• char[ ] string = { ‘A’, ‘c’, ‘X’, ‘F’, ‘v’ }; 
• Object[ ] objetos = { x, y, z} 
 
 Object[] x = new Object[5]; 
 
 x[0] = new java.util.Date(); 
 x[1] = "CRISTIANO"; 
 x[2] = new java.util.Random(); 
 x[3] = new int[] {22,33,44}; 
 print(x); 
 
 private static void print(Object[] x) { 
 for(int i = 0; i<x.length; i++) 
 { 
 System.out.println(i+". "+ x[i]); 
 System.out.println( ); 
 } 
 
 
27) ARRAYS DE REFERÊNCIA: 
 
public class Cliente { 
 
 int codigo; 
 String nome; 
 String sobrenome; 
 
} 
 
public class Programa { 
 
 public static void main(String[] args){ 
 
 // Criação Objeto do Tipo Array: 
 Cliente[] vetorCliente; 
 
 // Instanciação da Classe Cliente: 
 vetorCliente = new Cliente[10]; 
 
 // Instanciação da Classe Scanner: 
 Scanner dadoEntrada = new Scanner(System.in); 
 
 // Variáveis Primitivas: 
 int opcao; 
 int indiceVetor = 0; 
 
 // Menu principal: 
 do{ 
 System.out.println("--------------------"); 
 System.out.println("Cadastro de Cliente"); 
 System.out.println("--------------------"); 
 System.out.println("[1] - Inserir"); 
 System.out.println("[2] - Listar"); 
 System.out.println("[3] - Localizar"); 
 System.out.println("[4] - Exportar Arquivo"); 
 System.out.println("[5] - Sair"); 
 System.out.println("--------------------"); 
 System.out.print("Informe Opcao: "); 
 opcao = dadoEntrada.nextInt(); 
 System.out.println("--------------------"); 
 
 // Estrutura Switch: 
 switch(opcao){ 
 case 1: { 
 vetorCliente[indiceVetor] = new Cliente(); 
 
 System.out.print("Informe o Código: "); 
 vetorCliente[indiceVetor].codigo = dadoEntrada.nextInt(); 
 
 System.out.print("Informe o Primeiro Nome: "); 
 vetorCliente[indiceVetor].nome = dadoEntrada.next(); 
 
 System.out.print("Informe o Sobrenome Nome: "); 
 vetorCliente[indiceVetor].sobrenome = dadoEntrada.next(); 
 
 indiceVetor++; 
 break; } 
 } 
 } while(opcao != 5); 
 } 
} 
 
 
28) CLASSE RANDOM: 
 
Random numeroRandom = new Random(); 
 int n = numeroRandom.nextInt(); 
 
 System.out.println("numeroRandom:" + n); 
 
 if (n < 0) 
 System.out.println("(-) Número Negativo."); 
 else 
 System.out.println("(+) Número Positivo."); 
 
 
 
 
 
29) ESCRITA DE ARQUIVO: 
 
import java.io.FileWriter; // Saída baseada em caracteres para um arquivo. 
import java.io.IOException; // Tratamento de exceções. 
import java.io.PrintWriter; // Saída/Gravação de dados. 
import java.util.Scanner; // Entrada de dados. 
 
 public static void main(String[] args) throws IOException{ 
 
 // Objeto Scanner: 
 Scanner entradaDado = new Scanner(System.in); 
 
 // Variáveis primitivas: 
 int indice, valor; 
 
 // Entrada de dados: 
 System.out.print("Informe um Número: "); 
 valor = entradaDado.nextInt(); 
 
 // Objeto FileWriter: 
 FileWriter arqExp = new FileWriter("c:/arqExp.txt"); 
 
 // Objeto FileWriter 
 PrintWriter escreveArq = new PrintWriter(arqExp); 
 
 // Método: 
 escreveArq.println("-> Abertura do Arquivo <- "); 
 
 // Populando arquivo txt: 
 for(indice = 0; indice <= valor; indice++) { 
 escreveArq.println( "Valor: "+ indice); 
 } 
 
 // Método: 
 escreveArq.println("<- Fechamento do Arquivo -> "); 
 
 // Fechando o arquivo: 
 arqExp.close(); 
 System.out.println("-> Arquivo Exportado c/Sucesso!!! Local: c:/arqExp.txt"); 
 } 
} 
 
30) LEITURA DE ARQUIVO: 
 
 
import java.io.BufferedReader; // Fluxo de entrada de dados baseado em carecteres. 
import java.io.FileReader; // Para entrada de dados baseada em caracteres. 
import java.io.IOException; // Tratamento de exceções. 
import java.util.Scanner; // Entrada de dados. 
 
 
 // Objeto Scanner: 
 Scanner entradaDado = new Scanner(System.in); 
 
 // Entrada de dados: 
 System.out.print("-> Informe Caminho e o Nome do Arquivo: "); 
 String nomeArq = entradaDado.nextLine(); 
 
 // Saída de dados: 
 System.out.println("-> Conteúdo do arquivo texto: " ); 
 
 // Tratamento de exceções: 
 try { 
 // Objeto FileReader: 
 FileReader arqImp = new FileReader(nomeArq); 
 BufferedReader leituraArq = new BufferedReader(arqImp); 
 String linha = leituraArq.readLine(); 
 
 // Lendo linha a linha: 
 while(linha != null) { 
 System.out.printf("%s\n", linha); 
 linha = leituraArq.readLine();} 
 arqImp.close(); 
 
 }catch (IOException msgErro) { 
 System.err.print("Erro na abertura do arquivo: " + msgErro.getMessage()+"\n\n"); 
 }