Programação Orientada a Objetos (POO)

Linguagem Java
 Programação Orientada a Objetos
Conteúdo
• IDE - NetBeans
• Aspectos básicos da linguagem Java:
i. Tipos primitivos e operadores
ii. Arrays e Strings
iii. Estruturas de controle
 IDE

• IDE: Integrated Development Environment:

✔ Ambiente de Desenvolvimento Integrado;
✔ Une diversas funções inerentes ao desenvolvimento de
software em um único ambiente;
✔ Simplificar o desenvolvimento e aumentar a
produtividade
Apresentação

NETBEANS
 NetBeans
• Feito para programação em Linguagem Java:
✔ Aceita: C, C++, PHP, HTML e outras;
• Gratuito e de Código Aberto;
• Multiplataforma:
✔ Diponível para Windows, Linux, Solaris, MacOS
• Distribuído em diversos idiomas (Português BR
inclusive)
• Outros ambientes de programação:
✔ Eclipse, Visual Studio, Delphi XE, ...
• Download: http://www.netbeans.org
 Desenvolvimento Java
Código Java
NetBeans
(.java)

Compilador
JAVAC
Programado Bytecode
r (.class)

JVM JVM JVM

Windows Mac Linux

 Apresentação
• Acessando o NetBeans:
✔ Iniciar
▪ Todos os Programas
• NetBeans
o NetBeans IDE
NetBeans

ESTRUTURA E
ELEMENTOS BÁSICOS
NetBeans – Interface
 NetBeans – Interface

Aba Projetos
• Pacotes e bibliotecas
necessários para o
desenvolvimento do
projeto
 NetBeans – Interface

Janela Saída: Aparece quando a aplicação é executada

NetBeans – Código Fonte
 Estrutura do Código Fonte

Criar Pacote:
Importar:

Comentários:

Algoritmo:

Função MAIN:
Código:
Código Fonte -
Comentários
Código Fonte – Blocos de
Código
Código Fonte – Blocos de
Código
Código Fonte – Blocos de
Código
Código Fonte – Declaração de
Strings
Código Fonte – Fim de Linha e
Inicio/Fim de Bloco
Identificando Elementos

JAVA
 Linguagem Java

• Tipos de dados e Operadores

• Variáveis e Constantes
• Comentários e Escape
• Parâmetros
• Strings
• Entrada, Saída e Conversão de Dados
• Operadores Lógicos
• Estruturas de Decisão e de Repetição
• Arrays
Aspectos Básicos da Linguagem
Linguagem de POO
 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)
 Criando Variáveis
• Variáveis são criadas em qualquer parte de um
método, digitando primeiro o tipo de dado e depois
o nome. Exemplos:

✔ int x, y;
✔ double valor;
✔ String nome;
✔ boolean verdade;
 Criando Variáveis
• Não existe um local específico para criar uma
variável.
• Variáveis podem ser criadas em qualquer lugar
antes de sua utilização, ou até mesmo no momento
em que for necessária:
▪ int x; //Cria a variável
▪ x = 10; //Atribuí valor
✔ ou:
▪ int x = 10; //Cria e ao mesmo tempo atribuí valor
 Declaração de Constantes
• Uma constante é um tipo de variável que não
permite a alteração de seu conteúdo depois de ter
sido inicializada

final double PI = 3.14;

final int MILISEGUNDOSPORSEGUNDO = 1000;
 Comentários
• Os comentários são linhas adicionadas ao programa que
visam facilitar o entendimento do programa
• Essas linhas não afetam o programa em si, pois não são
consideradas parte do código
• Comentários de uma linha
// comentário de linha única

/*
comentário
de
várias
linhas
*/
 Sequências de Escape
• A linguagem Java possui algumas sequências de
escape (atalhos utilizados para representar um
caractere especial)
 Passagem de parâmetros
• Uma aplicação Java pode receber valores a partir do
prompt, isto é, no momento em que ela é
executada.
• Quando um parâmetro é recebido por uma classe
ele pode ser manipulado internamente.

public class PassagemDeParametros {

public static void main(String args[]) {
System.out.println(args[0] + " " + args[1]);
}
}
 Strings
• Strings são “vetores” de caracteres: gerenciam
cadeias de caracteres
• Ao utilizar aspas duplas delimitando um texto um
novo objeto do tipo string será criado.
String nomeAluno = "Steve Jobs";

• É possível realizar a concatenação de Strings através

do operador “+”
String primeironomeAluno = "Steve";
String sobrenomeAluno = "Jobs";
String nomeAluno = primeironomeAluno + " " +
sobrenomeAluno;
// "Steve Jobs"
 Strings
• Comparação de Strings (diferenciando maiúsculas
de minúsculas)
String str1 = "texto";
String str2 = "texto";
str1.equals(str2); //verdadeiro
str2.equals(str1); //verdadeiro

• Comparação de Strings (não diferenciando)

String str1 = "texto";
String str2 = “Texto";
str1.equalsIgnoreCase(str2); //verdadeiro
str2. equalsIgnoreCase(str1); //verdadeiro
str1.equals(str2); //false
 Strings
• Comparação de Strings (comparação parcial)
String str1 = “Texto";
String str2 = “Te";
str1.startsWith(str2); //verdadeiro
str2.startsWith(str1); //falso

• Comparação de Strings (ordem alfabética)

String str1 = "bbb";
String str2 = "aaa";
String str3 = "bbb"
str1.compareTo(str2); //int positivo
str2.compareTo(str3); //int negativo
str1.compareTo(str3); //neutro (zero)
 Strings
• Outros métodos (existem muitos outros):
✔ length(): int
✔ charAt(int i): char
✔ isEmpty(): boolean
✔ toLowerCase(): String
✔ toUpperCase(): String
NetBeans

CRIANDO UM NOVO PROJETO

 Criando um Novo Projeto

• Para criar um novo projeto:

✔ Arquivo;
✔ Novo Projeto;
▪ Categoria = Java;
▪ Projetos = Aplicativo Java;
✔ Próximo;
▪ Nome do Projeto = PrimeiroProj
✔ Finalizar.
 Informações Importantes
• Sensível maiúsculas ou minúsculas;
• Opções de Código: CTRL + Barra de Espaço;
• Orientado a Objetos e Pacotes (Conjuntos/Pacotes
de Objetos);
✔ Funções principais estão dentro de classes ou pacotes;
✔ Para acessar membros usar o ponto (.);
✔ pacotes mais usados:
▪ java.lang – Funcionalidades básicas;
▪ java.util – Estrutura de dados;
▪ java.lang.math – Operações matemáticas;
• Conversão de Dados é muito importante!!
 Entrada de Dados
• Modo texto (console)

Scanner entrada = new Scanner(System.in);

String texto;
texto = entrada. nextLine();
int x;
x = Integer.parseInt(entrada.nextLine());

• Modo Gráfico (GUI)

x =
Integer.parseInt(JOptionPane.showInputDialog(“Cod:"));
 Saída de Dados
• Modo texto (console)
System.out.println(“Olá!”);
System.out.print(43);

• Modo Gráfico (GUI)

JOptionPane.showMessageDialog(“Texto"));
 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));
Introdução ao Java

ATIVIDADE PRÁTICA
 Atividade Prática 1
(Leitura/Conversão)
public static void main(String[] args) {
String str = JOptionPane.showInputDialog(“V1:”);
int v1 = Integer.parseInt(str);
str = JOptionPane.showInputDialog(“V2:”);
double v2 = Double.parseDouble(str);
boolean b = (v1 == v2);
System.out.println(b);
}
 Atividade Prática 2 (Soma)

package soma;
import java.util.*;

public class Soma {

public static void main(String[] args) {
int a, b, c;
Scanner entrada = new Scanner(System.in);
System.out.print("Digite o primeiro valor: ");
a = Integer.parseInt(entrada.nextLine());
System.out.print("Digite o segundo valor: ");
b = Integer.parseInt(entrada.nextLine());
c = a + b;
System.out.println("Resultado: " + c);
}
}
 Atividade Prática 3 (++ , --)
1. public static void main(String[] args) {
2. int x;
3. x = 4;
4. System.out.println("x: " + x);
5. System.out.println("x++: " + x++);
6. System.out.println("x: " + x);
7. System.out.println("++x: " + ++x);
8. System.out.println("x: " + x);
9. System.out.println("x--: " + x--);
10. System.out.println("x: " + x);
11. System.out.println("--x: " + --x);
12. System.out.println("x: " + x);
13. }
Introdução ao Java

EXERCÍCIOS
 Exercícios
1. Calcular quanto um fumante gasta ao longo da vida
com cigarro:
✔ Perguntar a quantidade de anos como fumante;
✔ Perguntar a quantidade de cigarros por dia;
✔ Perguntar o valor da carteira de cigarro;
✔ Considerar 20 cigarros por carteira;
✔ Informar o total de dinheiro gasto.
 Exercícios
2. Sabendo que latão é constituído de 70% cobre e
30% zinco:
✔ Solicitar o peso de latão que o usuário deseja;
✔ Informar o peso de cobre necessário;
✔ Informar o peso de zinco necessário.

3. Implemente um código para calcular a média de

três números informados pelo usuário;
 Exercícios
4. Matemática e Tipo de Dado:
✔ Declarar uma variável x do tipo short;
✔ Pesquisar nas referências do Java:
▪ Procurar e abrir a classe Math;
▪ Pesquisar por um método Java para realizar o cálculo de
potência (ex. VisuALG: 3^2);
✔ Dizer que x recebe (-2)15 com o método encontrado;
✔ Escrever o valor intermediário de x;
✔ Decrementar o valor de x (x--; ou x = x – 1;);
✔ Escrever o valor final de x.
 Java

OPERADORES LÓGICOS
 Operadores Lógicos

Operadores Lógicos Java

Não (inversão) !
E && ATENÇÃO
OU ||
OU Exclusivo ^
OU Inclusivo |
 Variáveis Lógicas

Java Visualg
var
boolean teste; teste: logico

inicio
teste = false; teste <- falso

System.out.println(“teste = “ + teste); escreva(“teste = “, teste)

 Exemplo

• Um aluno do Curso Técnico de Informática do IFSC

deseja ir ao FISL 2014. Crie um algoritmo que leia
duas informações: 1) o aluno tem dinheiro para a
viagem(verdadeiro ou falso) e 2) os pais deixam
participar do evento(verdadeiro ou falso). Exiba
como resposta se o aluno irá ao FISL ou não.
 Variáveis e Operadores Lógicos
public class Exemplo { var
temDinheiro: logico
autorizado:logico
public static void main(String[] args) { vaiAoFISL:logico
boolean temDinheiro;
boolean autorizado; Inicio
boolean vaiAoFISL; // Entrada
temDinheiro <- verdadeiro
// Entrada
Autorizado <- verdadeiro
temDinheiro = true; // Processamento
autorizado = true; vaiAoFISL <- (temDinheiro) e
// Processamento (autorizado)
vaiAoFISL = (temDinheiro) && (autorizado); // Saída
escreva(“Aluno irá ao FISL? “,
// Saída vaiAoFISL)
System.out.println(“Aluno irá ao FISL? “ + fimalgoritmo
vaiAoFISL);
}
}
 Java

ESTRUTURAS DE CONTROLE

“Você poderia me dizer, por favor, qual caminho devo seguir a

partir daqui?
“Isso depende em grande parte de onde você quer chegar.”
- Lewis Carroll, Alice no País das Maravilhas
 Operadores Relacionais

Operador VisuAlg Java

Maior > >
Menor < <
Maior ou Igual >= >=
Menor ou Igual <= <=
Igual = == ATENÇÃO
Diferente <> !=
 Estruturas de Decisão
VisuAlg Java
se (<clausula>) entao if (<clausula>)
{

}
senao //Opcional else //Opcional
{

fimse }
 Estrutura de Decisão - if
Atal
if (cláusula) { iff
hos:
+ ta
ifel b
//Primeiro if é true se +
tab

} else if (cláusula) {
//Apenas o segundo if é true
} else {
//Quando nenhum if for true
}
Obs.: Os else são opcionais!
 Estruturas de Decisão
Scanner entrada = new Scanner(System.in);
int x;
System.out.print("Digite um valor: ");
x = Integer.parseInt(entrada.nextLine());
if ( x > 0) {
System.out.println("O número é positivo!");
} else {
System.out.println("O número é negativo ou neutro!");
}
 Estruturas de Decisão
Scanner entrada = new Scanner(System.in);
int x;
System.out.print("Digite um valor: ");
x = Integer.parseInt(entrada.nextLine());
if ( (x >= 1) && (x <= 10))
{
System.out.println("Pertence ao intervalo 1..10!");
}
else
{
System.out.println("NÃO pertence ao intervalo 1..10!");
}
 Exercícios
1. Implemente um código que, dada a idade de uma
pessoa, informe se ela tem maioridade;

2. Ler 4 notas de um aluno. Fazer a média e informar

“Aprovado” caso seja maior ou igual a 7. Caso seja
menor que 7, deve-se solicitar a nota do exame e
fazer nova média.
 Estruturas de Decisão
• Crie um algoritmo que receba como entrada o dia
da semana em formato numérico(1 para segunda,
2 para terça, ...) e informe o dia da semana em
formato de texto (“Domingo”, “Segunda”, “Terça”,
...).
Estruturas de Decisão
 Estruturas de Decisão
VisuAlg Java
escolha (<variável>) switch (<variável>) {
caso <valor1> case 1:
... ...
break;
caso <valor2> case 2:
... ...
break;
outrocaso default:
... ...
break;
fimescolha }
 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
 Estruturas de Decisão
• switch
 SWITCH
• Crie um algoritmo que receba como entrada o dia
da semana em formato numérico(1 para segunda,
2 para terça, ...) e informe o dia da semana em
formato de texto (“Domingo”, “Segunda”, “Terça”,
...).
 SWITCH
Scanner entrada = new Scanner(System.in);
int dia;
System.out.print("Informe o dia ");
dia = Integer.parseInt(entrada.nextLine());
switch (dia) {
case 1:
System.out.println("Domingo");
break;
case 2:
System.out.println("Segunda");
break;
.
.
.
default:
System.out.println(“Dia inválido!");
}
 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.
 Java

ESTRUTURAS DE REPETIÇÃO
Estruturas de Repetição
 Estrutura de Repetição - while
Atal
ho:
wh +
tab
while (cláusula) {
//Executa e repete somente enquanto
//a cláusula resultar true
}
Estruturas de Repetição
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);
Estruturas de Repetição
 Estrutura de Repetição - for
for (inicialização; condição; incremento) {
//Repete
}
Ex. inicialização: int x = 0
Ex. condição: x < 10 Atal
ho:
fori
Ex. incremento: x++ + ta
b
Exemplo completo:
for (int x = 0; x < 10; x++) {
//Repete 10 vezes com x de 0 até 9
}
 Exercícios
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;
Interrompendo
Repetições
Forçando a Próxima
Iteração
Estrutura de Dados

Arranjos
 Arranjos (Arrays)
• Um arranjo (em inglês array) é uma estrutura de dados que
armazena uma coleção de elementos de tal forma que cada um
dos elementos possa ser identificado por, pelo menos, um índice
ou uma chave.

• Essa estrutura de dados é conhecida como vetor (para arranjos

unidimensionais) e matriz (para arranjos bidimensionais).

• Os arranjos mantêm uma série de elementos de dados,

geralmente do mesmo tamanho e tipo de dado.

• Elementos individuais são acessados por sua posição no arranjo.

• A posição é dada por um índice.

 Arranjos (Arrays)
• Arrays na linguagem Java são objetos
✔ tipo [] nome = new tipo[N];
0 1 2 3 4 5 6 7 8 9

• Onde: vetor
✔ tipo: tipo de dado
✔ nome: identificação do array
✔ new: comando de construção de novo objeto
✔ N: número de elementos do array

• Declaração de um array :
✔ int numeros[] = new int[5];
✔ int matriz[][] = new int[5][6];
✔ String nomes[] = new String[10];
 Arrays
Declaração e inicialização de um array
unidimensional (vetor):
• Array declarado mas não inicializado (null)
int[] array;

• Array de 10 inteiros:
int[] arrayInt = new int[10];

• Array de 5 doubles (valores definidos na criação)

double[] arrayDouble = {2.0, .75, 1.5, 4.2, 9.7};
• Captura do tamanho do array unidimensional
int tam = arrayInt.length;
 Arrays
Método que cria um vetor e inicializa-o.

Scanner entrada = new Scanner(System.in);

int tamanho = entrada.nextInt();

int[] vetor = new int[tamanho];

for(int i = 0; i < vetor.length; i++){
if (i % 2 == 0)
vetor[i] = 0;
else
vetor[i] = 1;
}
 Collection - ArrayList
• Java disponibiliza diversas classes que
implementam diversas funcionalidades de
diferentes estruturas de dados:
✔ Conjunto chamado de Collections;

• Para a estrutura de dados Lista, iremos utilizar a

classe disponível em:
✔ java.util.ArrayList
 Collections
• Lista:
✔ Localizada no pacote java.util
✔ Nome da classe: ArrayList
✔ Construção do objeto lista:
ArrayList<Classe> lista = new ArrayList();
✔ Nessa lista iremos armazenar objetos da “Classe”.
✔ Exemplo para lista de int:
ArrayList<Integer> lista = new ArrayList();
• Exemplos:
✔ ArrayList<Integer> numeros = new ArrayList();
✔ ArrayList<String> nomes = new ArrayList();
 Collections
• Com o objeto criado, utilizamos os seus
métodos para executar ações:
✔ Adicionar um elemento:
lista.add(99); //99 é o valor armazenado
✔ Recuperar um elemento:
int valor = lista.get(0); //0 é o índice
✔ Verificar a quantidade de elementos:
int qdade = lista.size(); //Neste caso será 1
✔ Esvaziar a lista:
lista.clear();
 Collections
• Com o objeto criado, utilizamos os seus
métodos para executar ações:
✔ Pesquisar por um elemento:
int pos = lista.indexOf(99); //retorna a posição do
elemento. Se não for encontrado, retorna -1
✔ Ordenar a Lista:
Collections.sort(lista);
✔ Remover um elemento:
lista.remove(0); //0 é o indice do elemento
 Comando for para conjuntos
• Sintaxe:
for (Classe nome: conjunto) {
// repete
}

• Exemplo:
ArrayList<String> nomes = new ArrayList();
nomes.add(“João”);
nomes.add(“José”);
nomes.add(“teste”);
for (String nomeAtual: nomes) {
if (nomeAtual.equals(“teste”) {
System.out.println(“Nome encontrado!”)
}
}
 Exemplo (for)
Scanner entrada = new Scanner(System.in);
ArrayList<Integer> lista = new ArrayList();
int numero;
//Inserir elementos na lista
do {
System.out.print("Digite um número: ");
numero = Integer.parseInt(entrada.nextLine());
if (numero != 0) {
lista.add(numero);
}
} while (numero != 0);
//Exibir todos os elementos da lista
System.out.println("=== Os números inseridos foram
===");
for (int i = 0; i < lista.size(); i++) {
System.out.println(lista.get(i));
}
 Exemplo (for-each)
Scanner entrada = new Scanner(System.in);
ArrayList<Integer> lista = new ArrayList();
int numero;
//Inserir elementos na lista
do {
System.out.print("Digite um número: ");
numero = Integer.parseInt(entrada.nextLine());
if (numero != 0) {
lista.add(numero);
}
} while (numero != 0);
//Exibir todos os elementos da lista
System.out.println("=== Os números inseridos foram
===");
for (int i:lista) {
System.out.println(i);
}
 Atividade
• Construa um programa que utiliza um ArrayList
para cadastrar objetos da classe Aluno. A classe
deve possuir os atributos:
✔ Nome
✔ Matrícula
✔ Idade
• O programa deverá apresentar um menu para o
usuário com as opções:
✔ Cadastrar
✔ Listar todos
✔ Pesquisar
✔ Remover
 Atalhos

Comando Atalho + tab

public static void main psvm
if iff
if...else ifelse
for... fori
switch sw
do...while do
while wh
for...each fore
Variáveis: valores e referências
Linguagem de POO
 Variáveis: valores e referências
• Em Java variáveis podem armazenar valores de tipos de
dados primitivos; ou referências para instâncias de objetos

• Com tipos primitivos, o comportamento segue o padrão de

outras linguagens

• Quando é declarada uma variável associada a alguma

classe, seu valor/conteúdo será uma referência a um
objeto existente em algum local da memória.

• Essa referência é uma ligação entre a variável criada e um

objeto existente em algum local da memória.
 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

0
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

0
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

0
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:

p2
Objeto Pessoa #5436
0
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)