Você está na página 1de 90

Linguagem de POO

Vilson Heck Junior


vilson.junior@ifsc.edu.br
Conteúdo
1. Ambiente de desenvolvimento;
2. Construção de classes:
a. Construtores;
b. Definição de atributos e métodos;
c. Objetos - Instâncias;
3. Aspectos básicos da linguagem:
a. Tipos primitivos e operadores;
b. Arrays e Strings;
c. Estruturas de controle;
d. Recursividade;
e. Organizando o código: API, projeto e pacotes de
classes;
Ambiente de
Desenvolvimento
Linguagem de POO
Ambiente de Desenvolvimento
JDK:
● Pré-requisito para o desenvolvimento Java:
● http://www.oracle.com/technetwork/pt/java/javase/downloads/i
ndex.html

BlueJ:
● Ambiente de aprendizagem dos conceitos de OO utilizando a
linguagem Java:
● http://www.bluej.org/

NetBeans:
● Ambiente de Desenvolvimento Integrado (IDE) Java:
● https://netbeans.org/
BlueJ
NetBeans
Construção de Classes
Linguagem de POO
Conteúdo
1. Ambiente de desenvolvimento;
2. Construção de classes:
a. Construtores;
b. Definição de atributos e métodos;
c. Objetos - Instâncias;
3. Aspectos básicos da linguagem:
a. Tipos primitivos e operadores;
b. Arrays e Strings;
c. Estruturas de controle;
d. Recursividade;
e. Organizando o código: API, projeto e pacotes de
classes;
Construção de Classes
Retomando a Classe Dado definida
anteriormente:
Construção de Classes
● Abra o BlueJ;
● Crie um novo Projeto:
○ Clique no menu: “Projeto”;
○ “Novo Projeto”;
○ Escolha uma pasta nova e vazia para gravar o
seu projeto;
● Crie uma “Nova Classe…”
○ Nome da Classe: Dado
○ Tipo da Classe: Classe
● Clique em “Compilar”.
Construção de Classes
Construção de Classes
Construção de Classes
Construtores
● Compilar!
● Botão direito na classe Dado:
○ new Dado();
○ Nome da instância: meuDado;
○ Duplo clique em “meuDado”;
○ Observe o numeroAtual:

○ Botão direto meuDado


■ Clique em: void rolar()
Construtores
● Construtores são conjuntos de ações que devem
ser executadas durante o processo de construção
de um novo Objeto daquela determinada Classe;
● Construtores são escritos dentro da classe:
○ Devem possuir um modificador de acesso;
○ Nunca terão um tipo de dado de retorno
definido:
■ Sempre retornam um novo objeto da Classe
específicada!
○ Terão exatamente o mesmo nome que a Classe;
○ Assim como os métodos, podem ou não ter vários
argumentos.
Definindo a Classe
public class Dado {

}
Definindo um atributo
public class Dado {
public int numeroAtual;
}
Definindo o construtor
public class Dado {
public int numeroAtual;
public Dado() {
numeroAtual = 1;
}
}
Definindo um método
public class Dado {
public int numeroAtual;
public Dado() {
numeroAtual = 1;
}
public void rolar() {
numeroAtual = …;
}
}
Atividade Prática
Vamos construir o restante do jogo de
tabuleiro modelado nos slides anteriores:
Tabuleiro
Atividade Prática
Vamos construir o restante do jogo de
tabuleiro modelado nos slides anteriores:
Jogador
Atividade Prática
Vamos construir o restante do jogo de
tabuleiro modelado nos slides anteriores:
Jogo
Exercícios
1. Crie uma classe “Carro”:
a. Hodômetro: km;
b. Consumo: km/L;
c. Capacidade do tanque de combustível: L;
d. Disponibilidade de combustível: L;
e. Abastecer (L);
f. Percorrer (km);
Exercícios
2. Crie uma classe “Cartão de Crédito”:
a. Limite máximo (obtido durante a construção);
b. Saldo disponível;
c. Efetuar compra (informar valor);
d. Pagar a fatura:
i. Total;
ii. Parcial (informar valor);
Exercícios
3. Crie uma classe “Cartão de Crédito”:
a. Limite máximo (obtido durante a construção);
b. Saldo disponível;
c. Efetuar compra (informar valor);
d. Pagar a fatura:
i. Total;
ii. Parcial (informar valor);
e. Crie uma classe “Loja”:
i. Ao comprar com o cartão, informe também a loja;
ii. Realizar vendas;
iii. Caixa (montante recebido em vendas);
Exercícios
4. Crie uma classe “Caixa Eletrônico”:
a. Tem uma quantidade de cédulas de:
R$ 50,00, R$ 20,00, R$ 10,00 e R$ 5,00

b. Tem duas operações:


i. Abastecer cédulas: receberá uma determinada
quantidade adicional de cada uma das quatro
diferentes cédulas disponíveis;
ii. Realizar saque: receberá apenas o valor
solicitado e irá debitar o valor conforme
combinações possíveis com as cédulas
disponíveis;
Exercícios
5. Crie uma classe “Produto”:
a. Valor normal de venda;
b. Percentual de desconto atual;
c. Saldo (quantidade) disponível em estoque;
d. Calcular o valor atual: deve ser retornado o valor atual
de venda do produto;
e. Alterar o percentual de desconto: deve aceitar e
retornar true para valores de 0 até menores que 100;
false caso contrário;
f. Efetuar venda (quantidade): deve debitar a quantidade
do produto vendido e retornar true se a quantidade for
compatível com o saldo existente;
Aspectos Básicos da
Linguagem
Linguagem de POO
Conteúdo
1. Ambiente de desenvolvimento;
2. Construção de classes:
a. Construtores;
b. Definição de atributos e métodos;
c. Objetos - Instâncias;
3. Aspectos básicos da linguagem:
a. Tipos primitivos e operadores;
b. Arrays e Strings;
c. Estruturas de controle;
d. Recursividade;
e. Organizando o código: API, projeto e pacotes de
classes;
Java
● Linguagem de programação;
● Lançada em 1995;
○ Sun Microsystems;
■ Comprada pela Oracle em 2009;
● Orientada a Objetos - moderna;
○ Contempla tipos de dados primitivos;
● Possui uma ampla API (Interface de
Programação de Aplicativos):
○ Organizada em pacotes e classes;
○ Versão atual: JDK 8 API
Tipos primitivos

Tipo Memória Exemplo


byte 8 bits byte b = 10;
short 16 bits short s = 10000;
int 32 bits int i = 1000000;
long 64 bits long l = 100000000000;
float 32 bits IEEE 754 float f = 1.34f;
double 64 bits IEEE 754 double d = 1.34;
boolean 8 bits boolean o = true; //ou false
char 16 bits Unicode char c = ‘A’;
Operadores básicos

Operador Descrição Exemplo


= Atribuição int a = 10;
+ Soma / Concatenação int soma = x + y;
- Subtração int diferenca = x - y;
* Multiplicação int produto = x * y;
/ Divisão double div = x / y;
% Resto de divisão int resto = x % y;
Operadores relacionais

Operador Descrição Exemplo


> Maior que a>b
< Menor que a<b
>= Maior ou igual a a >= b
<= Menor ou igual a a <= b
== Igual a a == b
!= Diferente de a != b
Operadores lógicos

Operador Descrição Exemplo


&& e (a > b) && (a > c)
|| ou (a > b) || (a > c)
! não !(a > b)
Atividade 01 - NetBeans

● Abra o NetBeans;

● Clique em Novo Projeto: Java - Aplicação Java;

● Nome: Atividade01 (e escolha uma pasta);


Atividade 01 - Operadores
public static void main(String[] args) {
int x = 10;
int y = 20 / 2;
boolean b = (x == y);
System.out.println(b);
}
Strings
● Strings são “vetores” de caracteres:
○ Em Java, strings são objetos que realizam o
gerenciamento das cadeias de caracteres:
String instituicao = "Instituto Federal";

● Ao utilizar as aspas duplas envolvendo um


texto, um novo objeto da classe String
será automaticamente criado!
Strings
● É possível realizar a concatenação de
Strings através do operador +:
String str1 = "Instituto";
String str2 = "Federal";
String res = str1 + " " + str2;
//Instituto Federal
● Para realizar a comparação de strings, não
serão utilizados os operadores relacionais
vistos antes.
Strings
● Comparando strings:
String str1 = "texto";
String str2 = "texto";
str1.equals(str2) //verdadeiro
str2.equals(str1) //verdadeiro

Diferenciando maiúsculas de minúsculas.


Strings
● Comparando strings:
String str1 = "texto";
String str2 = "Texto";
str1.equalsIgnoreCase(str2)
//verdadeiro
str2.equalsIgnoreCase(str1)
//verdadeiro
str1.equals(str2)
//falso
Não diferenciando maiúsculas de minúsculas.
Strings
● Comparando strings:
String str1 = "Texto";
String str2 = "Te";
str1.startsWith(str2) //verdadeiro
str2.startsWith(str1) //falso

Comparação parcial.
Strings
● Comparando strings:
String str1 = "Fulano";
String str2 = "Beutrano";
String str3 = "Fulano";
str1.compareTo(str2) //int positivo
str2.compareTo(str3) //int negativo
str1.compareTo(str3) //neutro
Comparação de ordem alfabética.
Strings
Outros métodos notáveis:
● length(): int
● charAt(int i): char
● isEmpty(): boolean
● toLowerCase(): String
● toUpperCase(): String

Entre outros métodos para processamento de


caracteres.
Atividade 01 - Strings
public static void main(String[] args) {
String s1 = "Texto";
String s2 = "texto";
boolean b = s1.equals(s2);
System.out.println(b);
}
Saída de Dados
● Console (modo texto):
System.out.println(String);
System.out.print(String);

● Mensagem gráfica:
JOptionPane.showMessageDialog(null,
String);

Obs.: para utilizar a classe JOptionPane é necessário


importa-lá: import javax.swing.JOptionPane;
Entrada de Dados
● Console (modo texto):
Scanner teclado = new Scanner(System.in);
String texto = teclado.nextLine();

● Diálogo gráfico:
String texto =
JOptionPane.showInputDialog(String);

Obs.: para utilizar a classe JOptionPane é necessário


importa-lá: import javax.swing.JOptionPane;
Conversão de Dados
String para números:
String str;
int x = Integer.parseInt(str);
long y = Long.parseLong(str);
double z = Double.parseDouble(str);
Números para String:
int x;
String s = "" + x;
String t = String.valueOf(x);
String v = Integer.toString(x);
casting

double y;
int x = (int)(y);
---------------------------------------------------
System.out.println("a="+ 12/7 );
System.out.println("b="+ 12.0/7 );
System.out.println("c="+ 12/7.0 );
System.out.println("d="+ 12.0/7.0 );
System.out.println("e="+ (double)(12)/7 );
System.out.println("f="+ 12/(double)(7) );
System.out.println("g="+ (double)(12)/(double)(7) );
Atividade 01 - Leitura/Conversão
public static void main(String[] args) {
String str = JOptionPane.showInputDialog("Valor 1:");
int v1 = Integer.parseInt(str);
str = JOptionPane.showInputDialog("Valor 2:");
double v2 = Double.parseDouble(str);
boolean b = (v1 == v2);
System.out.println(b);
}
Estruturas de Controle
Estruturas de Decisão/Seleção:
● if()
● switch/case
● ternário;
Estruturas de Repetição:
● for()
● while()
● do while()
Estrutura de Decisão - if
Atal
hos:
if (cláusula) { iff
+ ta
ifel b
se +
//Primeiro if é true tab

} else if (cláusula) {
//Apenas o segundo if é true
} else {
//Quando nenhum if for true
}
Obs.: Os else são opcionais!
Estrutura de Repetição - for
for (inicialização; condição; incremento) {
//Repete
}
Ex. inicialização: int x = 0
Atal
Ex. condição: x < 10 ho:
fori
+ ta
Ex. incremento: x++ b

Exemplo completo:
for (int x = 0; x < 10; x++) {
//Repete 10 vezes com x de 0 até 9
}
Exercício de revisão em
NetBeans
Construa um programa em Java que:
1. Solicite um número N de produtos:
a. Para cada um dos N produtos: 1) leia o valor; e
2) leia um percentual de desconto;
b. Informe o novo valor de cada produto;
c. Ao final do programa, forneça as seguintes
informações:
i. A soma dos valores originais dos produtos;
ii. A soma dos novos valores dos produtos;
iii. O maior novo valor de um produto;
iv. O menor novo valor de um produto;
Estruturas de Controle
Estruturas de Decisão/Seleção:
● if()
● switch/case
● ternário;
Estruturas de Repetição:
● for()
● while()
● do while()
Estrutura de Decisão - switch
switch(chave) {
case valor1:
//Caso chave == valor1
break; Atal
ho:
... sw +
tab

default:
//Quando nenhum case
break;
}
Obs.: Utilize qualquer número de case
Estrutura de Decisão - ternário
O operador ternário realiza uma decisão
sobre o valor que deve ser atribuído à
uma variável:
variável = (clásula) ? valorT : valorF;

Exemplo:
int v1=20, v2=10;
int valorMenor = (v1 < v2) ? v1 : v2;
//valorMenor será 10
Obs.: Os parenteses são opcionais.
Estrutura de Repetição - dowhile

Atal
ho:
do +
tab
do {
//Executa ao menos uma vez
//Repete enquanto a cláusula resultar true
} while (cláusula);
Estrutura de Repetição - while

Atal
ho:
wh +
tab
while (cláusula) {
//Executa e repete somente enquanto
//a cláusula resultar true
}
Arrays e Listas
Linguagem de POO
Arrays
● Arrays na linguagem Java são objetos:
● Exemplos:
int[] numeros = new int [5];
int[][] matriz = new int [5][6];
String[] nomes = new String [10];
Pessoa[] pessoas = new Pessoa[3];
● Onde:
○ tipo [] nome = new tipo [N];
■ tipo: tipo de dado ou classe de objetos;
■ nome: identificação do array;
■ new: comando de construção de novo objeto;
■ N: número (inteiro) de elementos do array;
ArrayList
● A API do Java disponibiliza uma classe para gerenciar
listas de elementos alocados dinamicamente (com
tamanho variável):
○ Classe: java.util.ArrayList
● Exemplos:
ArrayList<Integer> numeros = new ArrayList();
ArrayList<String> nomes = new ArrayList();
ArrayList<Pessoa> pessoas = new ArrayList();
● Onde:
ArrayList<Classe> nome = new ArrayList();
○ ArrayList: classe utilizada para gerenciar listas;
○ <Classe>: Que tipo de objeto será armazenado;
○ nome: variável da instância;
○ new ArrayList(): comando de construção de novo objeto
lista;
for para conjuntos (for each)
for (Classe nome : conjunto) { Atal
ho:
fore
//Repete + ta
b
}
Ex. Classe nome: String nomeAtual
Ex. conjunto: nomes (vetor ou lista)

Exemplo completo:
ArrayList<String> nomes = new ArrayList();
for (String nomeAtual : nomes) {
//Repete com cada nome da lista
}
Variáveis: valores e
referências
Linguagem de POO
Variáveis em Java

● Em Java, variáveis podem armazenar


valores de tipos de dados primitivos; ou
referências para instâncias de objetos;

● Java não trabalha com ponteiros, por


requisitos de segurança impostos pela
própria máquina virtual Java.
Variáveis em Java - valor
● Quando declaramos uma variável de tipo de dado primitivo
em Java, o espaço necessário para armazenar aquele tipo de
dado na memória será reservado. Dentro deste espaço de
memória, será guardado o próprio valor (conteúdo) da
variável:
int x;
int y = 200;
Memória:
y

x 0

200
Variáveis em Java - referência
● Já ao declararmos uma variável associada a alguma classe,
seu valor (conteúdo) será uma referência a um objeto
existente em algum outro lugar na memória. Este conceito
pode ser considerado análogo ao funcionamento de um
ponteiro.
Pessoa p1;
Pessoa p2 = new Pessoa();
Memória:
p2

200 *ref*

p1 null
Variáveis em Java - referência
● Mas o que é esta referência?
○ É uma ligação, um apontamento para um determinado
objeto existente em outro lugar na memória.
Pessoa p2 = new Pessoa();
Memória:
p2

200 *ref*

p1 null

Objeto Pessoa #1234


Variáveis em Java - referência
● Múltiplas variáveis podem referenciar o mesmo objeto!
Pessoa p2 = new Pessoa();
Pessoa p1 = p2;
Memória:

p2

200 *ref*

p1 *ref*

Objeto Pessoa #1234


Variáveis em Java - referência
● Múltiplas variáveis podem referenciar o mesmo objeto!
Pessoa p2 = new Pessoa();
Pessoa p1 = new Pessoa();
Memória:

Objeto Pessoa #5436 p2

200 *ref*

p1 *ref*

Objeto Pessoa #1234


Criando um programa com
Classes em NetBeans
Linguagem de POO
Criando uma nova Classe
● Novo projeto no NetBeans:
○ ControleDeFrota
○ Crie uma nova classe: Carro:
■ Placa
■ Hodômetro
■ Consumo
■ Capacidade do Tanque
■ Disponibilidade de Combustível
■ Abastecer
■ Percorrer
○ Desenvolvendo o método main para gerenciar
uma frota de tamanho variável de carros.
Criando uma nova Classe
Criando uma nova Classe
Classe Carro
public class Carro {
public String placa;
public double hodometro;
public double consumo;
public double capacidadeTanque;
public double dispCombustivel;
public Carro (String placa, double consumo, double capTanque) {
this.placa = placa;
this.hodometro = 0;
this.consumo = consumo;
this.capacidadeTanque = capTanque;
this.dispCombustivel = 0;
}
public double abastecer(double litros) {
if (dispCombustivel + litros > capacidadeTanque) {
litros = capacidadeTanque - dispCombustivel;
}
dispCombustivel += litros;
return litros;
}
public double percorrer(double km) {
double litrosGastos = km / consumo;
if (litrosGastos > dispCombustivel) {
litrosGastos = dispCombustivel;
km = litrosGastos * consumo;
}
dispCombustivel -= litrosGastos;
hodometro += km;
return km;
}
}
Criando uma nova Classe
Classe Frota
import java.util.ArrayList;

public class Frota {


public ArrayList<Carro> carros = new ArrayList();

public Frota() {

public void adicionarCarro(Carro novo) {


carros.add(novo);
}
public Carro pesquisarPlaca(String placa) {
for (Carro carro: carros) {
if (carro.placa.equalsIgnoreCase(placa)) {
return carro;
}
}
return null;
}
public boolean removerCarro(Carro carro) {
return carros.remove(carro);
}
public boolean removerCarro(String placa) { //Método sobrecarregado
Carro carro = pesquisarPlaca(placa);
return carros.remove(carro);
}
}
Método main
import javax.swing.JOptionPane;

public class ControleDeFrota {

public static void main(String[] args) {


Frota frota = new Frota();
int opcao;
String placa;
double consumo, capacidade, litros, km, kmAux, litrosAux;
Carro carroAux;
do {
opcao = Integer.parseInt(JOptionPane.showInputDialog(
"1 - Inserir carro\n"
+"2 - Consultar carro\n"
+"3 - Remover carro\n"
+"4 - Percorrer KM com carro\n"
+"5 - Abastecer carro\n"
+"0 - Sair"));
switch (opcao) {

case 1:
placa = JOptionPane.showInputDialog("Informe a placa:");
consumo = Double.parseDouble(JOptionPane.showInputDialog("Informe o consumo: "));
capacidade = Double.parseDouble(JOptionPane.showInputDialog("Informe a capac: "));
frota.adicionarCarro(new Carro(placa, consumo, capacidade));
break;

(1/4)
case 2:
placa = JOptionPane.showInputDialog("Informe a placa: ");
carroAux = frota.pesquisarPlaca(placa);
if (carroAux == null) {
JOptionPane.showMessageDialog(null, "Carro não encontrado");
} else {
JOptionPane.showMessageDialog(null, "Hodômetro: " + carroAux.hodometro
+ "\nCombustível: " + carroAux.dispCombustivel);
}
break;

case 3:
placa = JOptionPane.showInputDialog("Informe a placa: ");
carroAux = frota.pesquisarPlaca(placa);
if (carroAux == null) {
JOptionPane.showMessageDialog(null, "Carro não encontrado");
} else {
frota.removerCarro(carroAux);
}
break;

(2/4)
case 4:
placa = JOptionPane.showInputDialog("Informe a placa: ");
carroAux = frota.pesquisarPlaca(placa);
if (carroAux == null) {
JOptionPane.showMessageDialog(null, "Carro não encontrado");
} else {
km = Double.parseDouble(JOptionPane.showInputDialog("Informe a KM: "));
kmAux = carroAux.percorrer(km);
if (km > kmAux) {
JOptionPane.showMessageDialog(null, "Acabou combustível no km " + kmAux);
} else {
JOptionPane.showMessageDialog(null, "KM percorrida!");
}
}
break;

case 5:
placa = JOptionPane.showInputDialog("Informe a placa: ");
carroAux = frota.pesquisarPlaca(placa);
if (carroAux == null) {
JOptionPane.showMessageDialog(null, "Carro não encontrado");
} else {
litros = Double.parseDouble(JOptionPane.showInputDialog("Informe L: "));
litrosAux = carroAux.abastecer(litros);
JOptionPane.showMessageDialog(null, "Abastecidos " + litrosAux + " litros");
}
break;

(3/4)
case 0:
break;
default:
JOptionPane.showMessageDialog(null, "Opção inválida!");
break;

}// Fim do switch

} while (opcao != 0);

} //Fim do main
}//Fim da classe

(4/4)
010001010111100001
100101011100100110
001111000011101011
010110001101101001
0110111101110011

Exercícios
Linguagem de POO
Exercício 01
Implemente o jogo de tabuleiro para funcionar em
um aplicativo Java desenvolvido em NetBeans:

MENU
1 - Iniciar nova partida
2 - Executar jogada
3 - Informar posições
0 - Sair
Exercício 02
Construa um programa de agenda de compromissos:

● Disponibilize as opções adequadas para o usuário;


● Para verificar os compromissos, utilize como inicio do período
a data atual do sistema e considere um determinado número
de dias à frente;
● Pesquise e utilize as seguintes classes:
○ LocalDate (API 8)
○ DateTimeFormatter (API 8)
Exercício 03
Gerenciamento parcial de uma loja:

Você também pode gostar