Você está na página 1de 16

Java

Programação de Computadores II

Prof. Rafael Antonio Dangui


IFPR – Campus Palmas
Conteúdo
Aplicação em Java ............................................................................................................. 3
Tipos de dados .................................................................................................................. 4
Conversão de tipos ........................................................................................................... 6
String ................................................................................................................................. 6
Funções matemáticas ....................................................................................................... 8
Estruturas condicionais .................................................................................................... 9
Estruturas de repetição .................................................................................................. 11
Break e continue ............................................................................................................. 12
Vetores............................................................................................................................ 13
Vetores multidimensionais ............................................................................................. 15
Criando vetores vazios.................................................................................................... 16
Aplicação em Java
Toda aplicação em Java começa com o nome da classe, este nome deve ser o
mesmo que o nome do arquivo. Exemplo: HelloWorld.java

public class HelloWorld {

Toda aplicação Java deve ter um método principal que irá ser chamado quando
a aplicação for executada. Esse método tem uma sintaxe própria:

public static void main(String[] args) {

Tudo que estiver dentro desse método será executado. Exemplo de uma
aplicação em Java:

public class HelloWorld {


public static void main(String[] args) {

}
}

Para imprimir valor no console utilizamos os métodos do objeto System. O


objeto System possui alguns métodos que nos ajudam a imprimir valores, tipos de
dados, outros objetos no console.

System.out.print("Olá Mundo!");

Nesse exemplo estamos imprimindo uma frase no console. Também temos a


possibilidade de imprimir algo no console e mudar o cursor de escrita para linha
seguinte:

System.out.println("Olá Mundo!");
Exemplo completo:

public class HelloWorld {


public static void main(String[] args) {
System.out.println("Olá Mundo!");
}
}

Tipos de dados
Os tipos de dados são usados para declaração de variáveis, atributos,
paramentos de métodos ou retorno dos mesmos. Os tipos de dados em Java são
divididos em dois grupos, os primitivos e não primitivos.
Dentro dos tipos primitivos temos oito tipos de dados, que são usados para
especificar o tamanho e o tipo de valor que eles podem armazenar.

Tipo Tamanho Descrição


byte 1 byte Armazena números inteiros de -128 a 127
short 2 bytes Armazena números inteiros de -32,768 a 32,767
int 4 bytes Armazena números inteiros de -2,147,483,648 a
2,147,483,647
long 8 bytes Armazena números inteiros de -
9,223,372,036,854,775,808 a
9,223,372,036,854,775,807
float 4 bytes Armazena decimais suficientes para 6 ou 7 dígitos
decimais
double 8 bytes Armazena decimais suficientes para 15 dígitos
decimais
boolean 1 bit Armazena valores verdadeiros ou falsos.
char 2 bytes Armazena um caractere/letra ou valor ASCII

Exemplo:

byte nByte = 100;


short nShort = 5000;
int nInt = 100000;
long nLong = 15000000000L;

float nFloat = 5.75f;


double nDouble = 19.99d;

boolean vBoolean = true;


char vChar = 'A';

System.out.println(nByte);
System.out.println(nShort);
System.out.println(nInt);
System.out.println(nLong);

System.out.println(nFloat);
System.out.println(nDouble);

System.out.println(vBoolean);

System.out.println(vChar);

Os dados não primitivos são chamados também de tipos de referencia, pois


fazem referencia a um objeto.
Principais diferenças entre os dados primitivos e os tipos não primitivos:

 Os dados primitivos são predefinidos em Java, já os tipos não primitivos são


criados pelo programador e não são definidos pelo Java, exceto os tipos String;
 Dados não primitivos podem ser usados para chamar métodos para ações em
certos objetos, já os primitivos não podem;
 Dados primitivos sempre tem um valor, já os tipos não primitivos são sempre
null;
 Os dados primitivos iniciam sua escrita com letra minúscula, já os tipos não
primitivos com maiúscula.
 O tamanho dos dados primitivos depende do seu tipo, já os tipos não primitivos
tem sempre o mesmo tamanho.

Exemplo:

String vString = "Programação de Computadores II";

Observação:

Dados definidos como char devem estar dentro de aspas simples ‘ ‘, já os dados
definidos como String devem estar dentro de aspas duplas “ ”.
Conversão de tipos
A conversão de tipos de dados em outro tipo é feita de duas formas no Java,
automática ou manual.
A forma automática é utilizada quando dados de menor tamanho são
convertidos em dados de maior tamanho:

byte -> short -> char -> int -> long -> float -> Double

Exemplo:

int nInt = 9;
double nDouble = nInt;

System.out.println(nDouble);

A forma manual é utilizada quando temos a conversão de dados de maior


tamanho para os de menor tamanho:

double -> float -> long -> int -> char -> short -> byte

Exemplo:

double nDouble = 9.78d;


int nInt = (int) nDouble;

System.out.println(nInt);

String
Em Java Strings são usadas para armazenamento de texto, podemos defini-las
como variáveis que armazenam uma coleção de caracteres envolvidos por aspas
duplas.
Uma String em Java é um objeto, que contem métodos que podem estender
certas operações, por exemplo, recuperar o tamanho (quantidade de caracteres),
concatenação, conversão de maiúscula para minúscula, etc.
Tamanho da String

String texto = "Lorem Ipsum é simplesmente uma simulação de text


o da indústria tipográfica e de impressos.";

System.out.println(texto.length());

Conversão de escrita

String texto = "Lorem Ipsum é simplesmente uma simulação de text


o da indústria tipográfica e de impressos.";

System.out.println(texto.toLowerCase());
System.out.println(texto.toUpperCase());

Ocorrência de uma String um caractere

String texto = "Lorem Ipsum é simplesmente uma simulação de text


o da indústria tipográfica e de impressos.";

System.out.println(texto.indexOf("texto"));

Substituir um caractere ou String

String texto = "Lorem Ipsum é simplesmente uma simulação de text


o da indústria tipográfica e de impressos.";

System.out.println(texto.replace('a', '@'));
System.out.println(texto.replace("texto", "@"));

Concatenação de Strings

String texto1 = "Programação";


String texto2 = "Computadores";

System.out.println(texto1.concat(texto2));
System.out.println(texto1 + texto2);
Funções matemáticas
O Java possui a classe Math, o qual possui muitos métodos que possibilitam a
realização de funções matemáticas, como gerar números randômicos, achar o maior
ou menos valor entre dois números, extrair a raiz quadrada, etc.

Retornar o maior valor entre dois números

System.out.println(Math.max(10, 20));

Retornar o menor valor entre dois números

System.out.println(Math.min(10, 20));

Retornar a raiz quadrada de um número.

System.out.println(Math.sqrt(16));

Gerar números randômicos, 0.0 até 1.0

System.out.println(Math.random());

Gerar números randômicos de 0 até 100

int rNumero = (int)(Math.random() * 101);

System.out.println(rNumero);
Estruturas condicionais
Java suporta as condições lógicas usuais da matemática, como:

Símbolo Descrição
< Menor que
> Maior que
<= Menor ou igual que
>= Maior ou igual que
== Igual que
!= Diferente de

O Java possui as seguintes estruturas condicionais:

 if - executa o bloco de código se a condição especificada for verdadeira


 else - executa o bloco de código se a condição anterior for falsa
 else if - executa o bloco de código com uma nova condição se a primeira
condição for falsa
 switch - utilizado quando temos várias condições para serem testadas

Exemplos:

if

int num1 = 2, num2 = 4;

if (num1 > num2) {


System.out.println("O num1 é maior que o num2");
}

if - else

int num1 = 2, num2 = 4;

if (num1 > num2) {


System.out.println("O num1 é maior que o num2");
} else {
System.out.println("O num1 é menor ou igual ao num2");
}
Forma contraída do if – else – Condição ? verdadeiro : falso

int num1 = 2, num2 = 4;

System.out.println(num1 > num2 ? "O num1 é maior que o num2" : "


O num1 é menor ou igual ao num2");

if - else if - else

int num1 = 2, num2 = 4;

if (num1 > num2) {


System.out.println("O num1 é maior que o num2");
} else if (num1 == num2) {
System.out.println("O num1 é igual ao num2");
} else {
System.out.println("O num1 é menor que o num2");
}

switch

int diaSemana = 2;

switch (diaSemana) {
case 1:
System.out.println("Hoje é domingo!");
break;
case 2:
System.out.println("Hoje é segunda-feira!");
break;
case 3:
System.out.println("Hoje é terça-feira!");
break;
case 4:
System.out.println("Hoje é quarta-feira!");
break;
case 5:
System.out.println("Hoje é quinta-feira!");
break;
case 6:
System.out.println("Hoje é sexta-feira!");
break;
case 7:
System.out.println("Hoje é sábado!");
break;
default:
System.out.println("Dia não é um dia da semana.");
break;
}

Estruturas de repetição
Estruturas de repetição ou loops podem executar um bloco de código várias
vezes enquanto uma condição for alcançada. Estruturas de repetição podem salvar
tempo, reduzir erros e tornar os códigos com uma leitura mais simples.

While

Permite executar uma ação repetida vezes enquanto uma condição


permanecer verdadeira.

while (i < 5) {
System.out.println(i);

i++; // Mesmo que i = i +1;


}

Do/while

Semelhante a estrutura while com o diferencial que o teste lógico é feito depois
da primeira execução.

do {
System.out.println(i);

i++; // Mesmo que i = i +1;

} while (i < 1);


For

Estrutura de repetição controlada por contador. Essa estrutura é utilizada


quando o número de repetições é conhecido.

for (int cont = 0; cont < i; cont++) {


System.out.println(cont);
}

Break e continue
As instruções break e continue alteram o fluxo de controle. A instrução break,
quando executada nas estruturas while, do/while, for e switch, causa a saída imediata
dessa estrutura. A instrução continue quando executada em uma estrutura while,
do/while o programa avalia o teste imediatamente depois da instrução. Em estruturas
for, a expressão de incremento é executada e logo após o programa avalia o teste de
continuação do laço.

Exemplos:

Break

for (int i = 0; i < 10; i++) {


if (i == 5) {
break;
}
System.out.println(i);
}

Continue

for (int i = 0; i < 10; i++) {


if ((i%2) == 0) {
continue;
}
System.out.println(i);
}
Vetores
Vetores são usados para armazenar múltiplos valores, do mesmo tipo, em uma
única variável ao invés de utilizarmos uma variável para cada valor.
Em Java utilizarmos os colchetes para indicar que uma variável será um vetor,
essa indicação fica no tipo de dado.

Exemplo

int[] variavel;

Nesse exemplo indicamos que nossa variável será um vetor que irá armazenar
valores do tipo inteiro.
Podemos também inicializar um vetor ao fazermos a sua declaração, para isso
colocamos os valores de inicialização dentro de chaves.

Exemplo

int[] variavel = {0, 1, 2, 3, 4};

Todos os vetores possuem um índice, que determina a posição onde um valor


será inserido. Em Java esse índice sempre inicia na posição zero.

0 1 2 3 4 5 6 7 8 9
10 15 52 84 45 60 48 90 1 73

Na imagem acima temos um vetor de tamanho 10 onde o índice se inicia em 0


e indo até o 9.
Para acessarmos um valor que está armazenado em uma posição do vetor nós
utilizamos o nome da variável e colocamos a posição que desejamos acessar dentro
dos colchetes.

Exemplo

variavel[3] //Estamos acessando o valor armazenado na posição 3

Para acessarmos todos os elementos de um vetor devemos utilizar alguma


estrutura de repetição, sendo a mais indiciada para isso é o for.
Exemplo

for (int i = 0; i < variavel.length; i++) {


//podemos capturar o tamanho do vetor utilizando a propriedade l
ength
System.out.println(variavel[i]);
}

Também podemos usar uma forma contraída de acesso ao vetor, chamada de


for-each. Essa maneira transforma cada elemento do vetor em uma variável a parte.
Essa maneira também é utilizada para acessar vetores de objetos.

Exemplo

for (int elemento : variavel) {


System.out.println(elemento);
}

Para realizarmos a inserção de dados em alguma posição do vetor, devemos


indicar em qual posição queremos inserir o valor desejado.

Exemplo

String[] paises = {"Brasil", "Alemanha", "Japão", "Canadá"};

paises[1] = "Uruguai";

for (String pais : paises) {


System.out.println(pais);
}
Vetores multidimensionais
Os vetores multidimensionais ou matrizes são vetores que possuem mais de um
eixo, normalmente são bi ou tridimensionais. Sendo os bidimensionais os mais
comuns, se assemelhando a planilhas.

1 2 4
1 10 20 30
2 40 50 60
3 70 80 90

Exemplo

int[][] matriz = {{1,2,3}, {4,5,6}, {7,8,9}};

Para acessarmos os elementos de uma matriz devemos usar dois laços de


repetição aninhados, ou seja, um laço dentro do outro. O primeiro aço será
responsável por acessar as linhas e o segundo laço responsável por acesso as colunas.

Exemplo

int[][] matriz = {{1,2,3}, {4,5,6}, {7,8,9}};

for (int i = 0; i < matriz.length; i++) {


for (int j = 0; j < matriz[i].length; j++) {
System.out.println(matriz[i][j]);
}
System.out.println("\n");
}

for (int[] linha : matriz) {


for (int coluna : linha) {
System.out.println(coluna);
}
System.out.println("\n");
}
Criando vetores vazios
Para criamos vetores vazios, que possam receber valores posteriormente,
devemos instanciar a variável do vetor com o tipo de dados o qual ele irá receber e
também informar o tamanho que o vetor terá. Essa instancia é um objeto do tipo de
dados.

Exemplo

int[] vetor = new int[10];

String[] paises = new String[4];

double[] salarios = new double[4];

Você também pode gostar