INTRODUÇÃO A OBJETOS COM JAVA
TOMADA DE DECISÃO, TIPO BOOLEAN, OPERADORES
RELACIONAIS E LÓGICOS
-
/****************************************************
** Programa de revisão para os seguintes conceitos:
** 1. tomada de decisão
** 2. tipo boolean
** 3. operadores relacionais
** 4. operadores lógicos
** 5. layout físico do programa
** 6. tratamento de erros
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/
// cuidado! Pegar corejava da segunda edicao do livro
import corejava.*;
/*
* Este programa usa a classe Day de corejava
* que pode ser usada como segue:
* 1. construtor para qualquer dia: Day(ano, mês, dia)
* 2. construtor para hoje: Day()
* 3. constantes disponíveis: Day.SUNDAY, ..., Day.SATURDAY
* (para o professor: cuidado! Tive que colocar
* "final" no original para serem constantes)
* 4. método weekday() que retorna uma das constantes acima
* 5. métodos para pegar o dia, mes, ano:
* getDay(), getMonth(), getYear()
*/
public class NomeDoDia {
public static void main(String[] args) {
// forca inicializacao para compilador nao reclamar
Day dia = null;
String nomeDoDia;
// observe que a entrada não vem do teclado mas dos argumentos
if(args.length == 0) {
dia = new Day(); // observe indentação
} else if(args.length == 3) {
dia = new Day(Integer.parseInt(args[2]),
Integer.parseInt(args[1]),
Integer.parseInt(args[0]));
} else {
System.err.println("Sintaxe: NomeDoDia [dia mes ano]");
System.exit(1);
}
switch(dia.weekday()) {
case Day.SUNDAY:
nomeDoDia = "domingo";
break;
case Day.MONDAY:
nomeDoDia = "segunda-feira";
break;
case Day.TUESDAY:
nomeDoDia = "terca-feira";
break;
case Day.WEDNESDAY:
nomeDoDia = "quarta-feira";
break;
case Day.THURSDAY:
nomeDoDia = "quinta-feira";
break;
case Day.FRIDAY:
nomeDoDia = "sexta-feira";
break;
case Day.SATURDAY:
default:
nomeDoDia = "sabado";
break;
}
// aqui, a variável "conjunção" é definida
// perto de onde é usada pela primeira vez
String conjunção = "numa";
if(dia.weekday() == Day.SATURDAY ||
dia.weekday() == Day.SUNDAY) {
conjunção = "num"; // só funciona em português
}
System.out.println("O dia " + dia.getDay() + "/" +
dia.getMonth() + "/" + dia.getYear() +
" cai " + conjunção + " " + nomeDoDia);
}
}
LAÇOS, AGREGADOS (COLEÇÕES) E ITERADORES
-
/****************************************************
** Programa de revisão para os seguintes conceitos:
** 1. laços
** 2. agregados (arrays)
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/
import corejava.*;
/*
* O seguinte programa usa um Semaforo.
* O que precisamos saber sobre o semaforo é o seguinte:
* 1. primeira forma de construir com cor default:
* new Semaforo()
* 2. segunda forma de construir:
* new Semaforo(Semaforo.VERMELHO)
* (o parametro pode tambem ser Semaforo.VERDE,
* Semaforo.AMARELO)
* 3. terceira forma de construir:
* new Semaforo("um nome")
* 4. quarta forma de construir:
* new Semaforo(Semaforo.AMARELO, "um nome")
* 5. Método de mudança no sinal: muda()
* 6. Método para saber a cor do semaforo:
* getNomeCorAtual()
* 7. Método para saber o nome do sinal:
* getNome()
*/
public class Cruzamento2 {
public static void main(String[] args) {
// referencia a um array (ainda vazio, sem tamanho)
Semaforo[] semaforos;
String lixo; // para ler <ENTER> do teclado
// criação de um array de 4 referências (ainda nulas!)
semaforos = new Semaforo[4];
// agora, cria os semafóros
// norte == 0, sul == 1, leste == 2, oeste == 3
// (depois daremos melhor!)
semaforos[0] = new Semaforo(Semaforo.VERMELHO, "Norte");
semaforos[1] = new Semaforo(Semaforo.VERMELHO, "Sul");
semaforos[2] = new Semaforo(Semaforo.VERDE, "Leste");
semaforos[3] = new Semaforo(Semaforo.VERDE, "Oeste");
// agora, os 4 objetos existem
// (referencias "apontam" para objetos)
for(int i = 0; i < 4; i++) {
System.out.println("Semaforo " + semaforos[i].getNome()
+ " esta " + semaforos[i].getNomeCorAtual());
}
// efetuando mudanças no estado dos objetos do cruzamento
lixo = Console.readLine(
"Digite <ENTER> para ver a mudanca de semaforo");
semaforos[2].muda(); // leste
semaforos[3].muda(); // oeste
for(int i = 0; i < 4; i++) {
System.out.println("Semaforo " + semaforos[i].getNome()
+ " esta " + semaforos[i].getNomeCorAtual());
}
// efetuando outra mudança no estado dos objetos do cruzamento
lixo = Console.readLine(
"Digite <ENTER> para ver a mudanca de semaforo");
for(int i = 0; i < 4; i++) {
semaforos[i].muda();
System.out.println("Semaforo " + semaforos[i].getNome()
+ " esta " + semaforos[i].getNomeCorAtual());
}
}
}
/****************************************************
** Programa de revisão para os seguintes conceitos:
** 1. laços (while)
** 2. agregados ou coleções (ArrayList)
** 3. iteradores
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/
import corejava.*;
import java.util.*;
/*
* O seguinte programa usa um Semaforo.
* O que precisamos saber sobre o semaforo é o seguinte:
* 1. primeira forma de construir com cor default:
* new Semaforo()
* 2. segunda forma de construir:
* new Semaforo(Semaforo.VERMELHO)
* (o parametro pode tambem ser Semaforo.VERDE,
* Semaforo.AMARELO)
* 3. terceira forma de construir:
* new Semaforo("um nome")
* 4. quarta forma de construir:
* new Semaforo(Semaforo.AMARELO, "um nome")
* 5. Método de mudança no sinal:
* muda()
* 6. Método para saber a cor do semaforo:
* getNomeCorAtual()
* 8. Método para saber o nome do sinal:
* getNome()
*/
public class Cruzamento3 {
public static void main(String[] args) {
ArrayList semaforos;
String resposta;
// criação de um agregado para conter semáforos
semaforos = new ArrayList();
while( !(resposta = Console.readLine(
"Digite a cor do semaforo a criar (0, 1 ou 2)" +
"ou q para terminar:")).equals("q")) {
switch(Integer.parseInt(resposta)) {
case Semaforo.VERMELHO:
semaforos.add(new Semaforo(Semaforo.VERMELHO));
break;
case Semaforo.AMARELO:
semaforos.add(new Semaforo(Semaforo.AMARELO));
break;
case Semaforo.VERDE:
semaforos.add(new Semaforo(Semaforo.VERDE));
break;
default:
System.out.println("Cor invalida. Tente de novo.");
}
}
// Agora, imprima a informacao
// de todos os semaforos usando um iterador
Iterator it = semaforos.iterator();
while(it.hasNext()) {
Semaforo sem = (Semaforo)it.next();
System.out.println("Semaforo " + sem.getNome() +
" esta " + sem.getNomeCorAtual());
}
}
}
CRIAÇÃO DE NOVAS CLASSES, CONSTRUTORES, SOBRECARGA,
ENCAPSULAMENTO, CONCEITO DE INTERFACE, PRIVATE E PUBLIC,
CONSTANTES DE CLASSE
-
/****************************************************
** Programa de revisão para os seguintes conceitos:
** 1. criação de novas classes
** 2. construtores
** 3. sobrecarga
** 4. constantes
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/
public class SemSimples {
// constantes "vistas" fora do objeto
public static final int VERMELHO = 1;
public static final int AMARELO = 2;
public static final int VERDE = 3;
// atributo escondido do mundo externo
private int corAtual;
public SemSimples() { // primeiro construtor
corAtual = VERMELHO;
}
public SemSimples(int cor) { // segundo construtor
corAtual = cor;
}
// o que deve ser mudado para muda() retornar a nova cor?
public void muda() { // acao de mudanca de estado do objeto
switch(corAtual) {
case VERMELHO:
corAtual = VERDE;
break;
case AMARELO:
corAtual = VERMELHO;
break;
case VERDE:
corAtual = AMARELO;
break;
}
}
public int getCorAtual() { // "accessor method"
return corAtual;
}
// como getCorAtual mas retornando String, nao int
public String getNomeCorAtual() {
switch(corAtual) {
case AMARELO:
return "amarelo";
case VERDE:
return "verde";
case VERMELHO:
default:
return "vermelho";
}
}
}
/****************************************************
** Programa de revisão para os seguintes conceitos:
** 1. criação de novas classes
** 2. construtores
** 3. sobrecarga
** 4. constantes
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/
public class Semaforo {
// constantes (simbólicas) para o semaforo
public static final int VERMELHO = 0;
public static final int AMARELO = 1;
public static final int VERDE = 2;
private int corAtual; // os atributos de um semaforo
private String nome;
public Semaforo() { // construtor
this(VERMELHO);
}
public Semaforo(int cor) {
this(cor, "semaforo");
}
public Semaforo(String nome) {
this(VERMELHO, nome);
}
public Semaforo(int cor, String nome) {
corAtual = cor;
this.nome = nome;
}
public int muda() { // um método do semaforo
switch(corAtual) {
case VERMELHO:
corAtual = VERDE;
break;
case AMARELO:
corAtual = VERMELHO;
break;
case VERDE:
corAtual = AMARELO;
break;
}
return corAtual;
}
public int getCorAtual() {
return corAtual;
}
public String getNome() {
return nome;
}
public String getNomeCorAtual() {
switch(corAtual) {
case AMARELO:
return "amarelo";
case VERDE:
return "verde";
case VERMELHO:
default:
return "vermelho";
}
}
public String toString() {
return nome + " esta " + getNomeCorAtual();
}
}
OBJETOS QUE REFERENCIAM OUTROS, ESCOPO, RETORNO DE
VALORES
-
/****************************************************
** Programa de revisão para os seguintes conceitos:
** 1. Objetos que referenciam outros
** 2. escopo
** 3. métodos que retornam e que não retornam valor
** 4. aninhamento de chamadas de métodos
** @author Jacques P. Sauvé
** @since 08/04/1999
****************************************************/
import corejava.*;
public class Cruzamento {
private static final int NUM_FASES = 4;
private static final int LO_VERDE = 0;
private static final int LO_AMARELO = 1;
private static final int NS_VERDE = 2;
private static final int NS_AMARELO = 3;
private static final int NORTE = 0;
private static final int SUL = 1;
private static final int LESTE = 2;
private static final int OESTE = 3;
private String ruaNorteSul;
private String ruaLesteOeste;
private Semaforo[] semaforos;
private int faseDoCiclo;
public Cruzamento() {
this("Norte-Sul", "Leste-Oeste");
}
public Cruzamento(String ruaNS, String ruaLO) {
ruaNorteSul = ruaNS;
ruaLesteOeste = ruaLO;
semaforos = new Semaforo[4];
semaforos[NORTE] = new Semaforo(
Semaforo.VERMELHO, ruaNorteSul+" (Norte)");
semaforos[SUL] = new Semaforo(
Semaforo.VERMELHO, ruaNorteSul+" (Sul)");
semaforos[LESTE] = new Semaforo(
Semaforo.VERDE, ruaLesteOeste+" (Leste)");
semaforos[OESTE] = new Semaforo(
Semaforo.VERDE, ruaLesteOeste+" (Oeste)");
faseDoCiclo = LO_VERDE;
}
public void muda() { // retorna nada: "procedimento"
switch(faseDoCiclo) {
case LO_VERDE:
semaforos[LESTE].muda();
semaforos[OESTE].muda();
faseDoCiclo = LO_AMARELO;
break;
case LO_AMARELO:
semaforos[NORTE].muda();
semaforos[SUL].muda();
semaforos[LESTE].muda();
semaforos[OESTE].muda();
faseDoCiclo = NS_VERDE;
break;
case NS_VERDE:
semaforos[NORTE].muda();
semaforos[SUL].muda();
faseDoCiclo = NS_AMARELO;
break;
case NS_AMARELO:
semaforos[NORTE].muda();
semaforos[SUL].muda();
semaforos[LESTE].muda();
semaforos[OESTE].muda();
faseDoCiclo = LO_VERDE;
break;
}
}
public String toString() {
String str = "Cruzamento das ruas " +
ruaNorteSul + " e " + ruaLesteOeste + "\n";
for(int i = 0; i < semaforos.length; i++) {
str += "\t" + semaforos[i] + "\n";
}
return str; // retorna algo: "função"
}
// main para teste da classe
public static void main(String[] args) {
Cruzamento umCruzamento;
String resposta;
// escopo: str da funcao toStr nao esta disponivel aqui
umCruzamento = new Cruzamento(
"Rodrigues Alves", "Nilo Pecanha");
System.out.println(umCruzamento);
while( !(resposta = Console.readLine("Digite <ENTER>" +
"para mudar os semaforos ou q para terminar:"))
.equals("q")) {
umCruzamento.muda();
System.out.println(umCruzamento);
}
}
}
java2.htm programa próxima