Cria um conta com nome "Jacques Sauve", cpf 123456789-01, e número 123 Verifique que o nome da conta é Jacques Sauve Verifique que o cpf da conta é 123456789-01 Verifique que o número da conta é 123 Verifique que o saldo da conta é 0.0 Deposite R$100,00 Verifique que o saldo é R$100,00 Saque R$45,00 Verifique que o saldo é R$55,00 Tente sacar R$56,00 e verifique que não é possível Verifique que o saldo continua em R$55,00
import junit.framework.TestCase; public class TestContaSimples1 extends TestCase { public void testContaSimples1() { ContaSimples1 umaConta = new ContaSimples1("Jacques Sauve", "123456789-01", 123); assertEquals("Nome errado", "Jacques Sauve", umaConta.getNome()); assertEquals("cpf errado", "123456789-01", umaConta.getCPF()); assertEquals("Número errado", 123, umaConta.getNúmero()); assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); umaConta.depositar(100.0); assertEquals("Saldo errado", 100.0, umaConta.getSaldo(), 0.005); assertTrue("Nao consegui sacar", umaConta.sacar(45.0)); assertEquals("Saldo errado", 55.0, umaConta.getSaldo(), 0.005); assertFalse("Consegui sacar demais", umaConta.sacar(56.0)); assertEquals("Saldo errado", 55.0, umaConta.getSaldo(), 0.005); } }
/** * Classe de conta bancária simples. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ public class ContaSimples1 { // atributos private String nome; private String cpf; private int número; private double saldo; // construtor /** * Cria uma conta a partir de um nome e cpf de pessoa física, e um número de conta. * @param nome O nome do titular da conta. * @param cpf O CPF do titular da conta. * @param número O número da conta. */ public ContaSimples1(String nome, String cpf, int número) { this.nome = nome; this.cpf = cpf; this.número = número; saldo = 0.0; } // métodos /** * Recupera o número da conta. * @return O número da conta. */ public int getNúmero() { return número; } /** * Recupera o nome do titular da conta. * @return O nome do titular da conta. */ public String getNome() { return nome; } /** * Recupera o CPF do titular da conta. * @return O CPF do titular da conta. */ public String getCPF() { return cpf; } /** * Recupera o saldo da conta. * @return O saldo da conta. */ public double getSaldo() { return saldo; } /** * Efetua um depósito numa conta. * @param valor O valor a depositar. */ public void depositar(double valor) { // credita a conta saldo += valor; } /** * Efetua sacada na conta. * @param valor O valor a sacar. * @return O sucesso ou não da operação. */ public boolean sacar(double valor) { // debita a conta if(saldo - valor >= 0) { saldo -= valor; return true; } else { return false; } } /** * Transforma os dados da conta em um String. * @return O string com os dados da conta. */ public String toString() { return "numero " + número + ", nome " + nome + ", saldo " + saldo; } }
/** * Classe de conta bancária simples. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */
javadoc -d docContaSimples1 -version -author ContaSimples1.java
public class ContaSimples1 {
public class nome { corpo da classe }
// atributos private String nome; private String cpf; private int número; private double saldo;
// construtor /** * Cria uma conta a partir de um nome e cpf de pessoa física, e um número de conta. * @param nome O nome do titular da conta. * @param cpf O CPF do titular da conta. * @param número O número da conta. */ public ContaSimples1(String nome, String cpf, int número) { this.nome = nome; this.cpf = cpf; this.número = número; saldo = 0.0; }
nome = nomeTitular;
// métodos /** * Recupera o número da conta. * @return O número da conta. */ public int getNúmero() { return número; } /** * Recupera o nome do titular da conta. * @return O nome do titular da conta. */ public String getNome() { return nome; } /** * Recupera o CPF do titular da conta. * @return O CPF do titular da conta. */ public String getCPF() { return cpf; } /** * Recupera o saldo da conta. * @return O saldo da conta. */ public double getSaldo() { return saldo; }
/** * Efetua um depósito numa conta. * @param valor O valor a depositar. */ public void depositar(double valor) { // credita a conta saldo += valor; } /** * Efetua sacada na conta. * @param valor O valor a sacar. * @return O sucesso ou não da operação. */ public boolean sacar(double valor) { // debita a conta if(saldo - valor >= 0) { saldo -= valor; return true; } else { return false; } }
/** * Transforma os dados da conta em um String. * @return O string com os dados da conta. */ public String toString() { return "numero " + número + ", nome " + nome + ", saldo " + saldo; }
/* * Movimentação simples de uma conta bancária */ // Programa Exemplo1 public class Exemplo1 { // O programa sempre tem um "método" main que é onde começa a execução public static void main(String args[]) { // Abra uma conta de número 1 para João com CPF 309140605-06 // A conta será "referenciada" com a variável umaConta ContaSimples1 umaConta = new ContaSimples1("Joao", "30914060506", 1); // Nesta conta, deposite R$1000,00 umaConta.depositar(1000.0); // Imprima o saldo da conta de João double saldo = umaConta.getSaldo(); System.out.print("Saldo da conta de Joao antes do saque: "); System.out.println(saldo); // Saque R$300,00 desta conta umaConta.sacar(300.0); // Imprima o objeto umaConta System.out.println(umaConta); // Imprima o saldo da conta de João System.out.println("Saldo da conta de Joao depois do saque: " + umaConta.getSaldo()); } // fim do método main } // fim da classe Exemplo1
/** * Classe de conta bancária simples. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ public class ContaSimples1 { // atributos private String nome; private String cpf; private int número; private double saldo; // construtor /** * Cria uma conta a partir de um nome e cpf de pessoa física, e um número de conta. * @param nome O nome do titular da conta. * @param cpf O CPF do titular da conta. * @param número O número da conta. */ public ContaSimples1(String nome, String cpf, int número) { this.nome = nome; this.cpf = cpf; this.número = número; saldo = 0.0; } // métodos /** * Recupera o número da conta. * @return O número da conta. */ public int getNúmero() { return número; } /** * Recupera o nome do titular da conta. * @return O nome do titular da conta. */ public String getNome() { return nome; } /** * Recupera o CPF do titular da conta. * @return O CPF do titular da conta. */ public String getCPF() { return cpf; } /** * Recupera o saldo da conta. * @return O saldo da conta. */ public double getSaldo() { return saldo; } /** * Efetua um depósito numa conta. * @param valor O valor a depositar. */ public void depositar(double valor) { // credita a conta saldo += valor; } /** * Efetua sacada na conta. * @param valor O valor a sacar. * @return O sucesso ou não da operação. */ public boolean sacar(double valor) { // debita a conta if(saldo - valor >= 0) { saldo -= valor; return true; } else { return false; } } /** * Transforma os dados da conta em um String. * @return O string com os dados da conta. */ public String toString() { return "numero " + número + ", nome " + nome + ", saldo " + saldo; } // O programa sempre tem um "método" main que é onde começa a execução public static void main(String args[]) { // Abra uma conta de número 1 para João com CPF 309140605-06 // A conta será "referenciada" com a variável umaConta ContaSimples1 umaConta = new ContaSimples1("Joao", "30914060506", 1); // Nesta conta, deposite R$1000,00 umaConta.depositar(1000.0); // Imprima o saldo da conta de João double saldo = umaConta.getSaldo(); System.out.print("Saldo da conta de Joao antes do saque: "); System.out.println(saldo); // Saque R$300,00 desta conta umaConta.sacar(300.0); // Imprima o objeto umaConta System.out.println(umaConta); // Imprima o saldo da conta de João System.out.println("Saldo da conta de Joao depois do saque: " + umaConta.getSaldo()); } // fim do método main }
package p2.exemplos; public class TesteDeExcecoes { public static void main(String[] args) { new TesteDeExcecoes().doIt(); System.out.println("bye, bye"); } private void doIt() { try { System.out.println("doIt: chama a()"); a(false); System.out.println("doIt: a() retornou"); System.out.println("main: chama b()"); b(false); System.out.println("doIt: b() retornou"); System.out.println("doIt: nao capturou excecao"); } catch(Exception ex) { System.out.println("doIt: capturou excecao: " + ex.getMessage()); } } private void a(boolean lanca) throws Exception { System.out.println("a: chama c(" + lanca + ")"); c(lanca); System.out.println("a: c() retornou"); } private void c(boolean lanca) throws Exception { System.out.println("c: inicio"); if(lanca) { System.out.println("c: vai lancar"); throw new Exception("bomba!"); // System.out.println("c: lancou"); // causaria erro de compilação } System.out.println("c: fim"); } private void b(boolean lanca) throws Exception { try { System.out.println("b: chama c(" + lanca + ")"); c(lanca); System.out.println("b: c() retornou sem excecao"); } catch(Exception ex) { System.out.println("b: capturou excecao: " + ex.getMessage()); // tire o comentário abaixo para ver o comportamento // throw ex; // ou então // throw new Exception("granada!"); } finally { System.out.println("b: finally"); } } }
import junit.framework.TestCase; public class TestContaSimples3 extends TestCase { public void testBasico() throws Exception { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "123456789-01", 123); assertEquals("Nome errado", "Jacques Sauve", umaConta.getNome()); assertEquals("cpf errado", "123456789-01", umaConta.getCPF()); assertEquals("Número errado", 123, umaConta.getNúmero()); assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); umaConta.depositar(100.0); assertEquals("Saldo errado", 100.0, umaConta.getSaldo(), 0.005); assertTrue("Nao consegui sacar", umaConta.sacar(45.0)); assertEquals("Saldo errado", 55.0, umaConta.getSaldo(), 0.005); assertFalse("Consegui sacar demais", umaConta.sacar(56.0)); assertEquals("Saldo errado", 55.0, umaConta.getSaldo(), 0.005); } public void testDeErrosNoConstrutor() { try { ContaSimples3 umaConta = new ContaSimples3("", "123456789-01", 123); fail("Esperava excecao de nome vazio"); } catch (Exception ex) { assertEquals("Mensagem errada", "Nome nao pode ser nulo ou vazio", ex.getMessage()); } try { ContaSimples3 umaConta = new ContaSimples3(null, "123456789-01", 123); fail("Esperava excecao de nome nulo"); } catch (Exception ex) { assertEquals("Mensagem errada", "Nome nao pode ser nulo ou vazio", ex.getMessage()); } try { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "", 123); fail("Esperava excecao de CPF vazio"); } catch (Exception ex) { assertEquals("Mensagem errada", "CPF nao pode ser nulo ou vazio", ex.getMessage()); } try { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", null, 123); fail("Esperava excecao de CPF nulo"); } catch (Exception ex) { assertEquals("Mensagem errada", "CPF nao pode ser nulo ou vazio", ex.getMessage()); } try { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "123456789-01", 0); fail("Esperava excecao de numero de conta errada"); } catch (Exception ex) { assertEquals("Mensagem errada", "Número da conta deve ser positivo", ex.getMessage()); } try { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "123456789-01", -1); fail("Esperava excecao de numero de conta errada"); } catch (Exception ex) { assertEquals("Mensagem errada", "Número da conta deve ser positivo", ex.getMessage()); } } public void testDepositar() throws Exception { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "123456789-01", 123); assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); umaConta.depositar(100.0); assertEquals("Saldo errado", 100.0, umaConta.getSaldo(), 0.005); umaConta.depositar(0.0); assertEquals("Saldo errado", 100.0, umaConta.getSaldo(), 0.005); try { umaConta.depositar(-0.01); fail("Esperava excecao no deposito"); } catch (Exception ex) { assertEquals("Mensagem errada", "Deposito nao pode ser negativo", ex.getMessage()); } umaConta.depositar(0.01); assertEquals("Saldo errado", 100.01, umaConta.getSaldo(), 0.005); } public void testSacar() throws Exception { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "123456789-01", 123); assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); assertTrue("Nao consegui sacar", umaConta.sacar(0.0)); assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); umaConta.depositar(100.0); assertTrue("Nao consegui sacar", umaConta.sacar(23.10)); assertEquals("Saldo errado", 76.90, umaConta.getSaldo(), 0.005); assertFalse("Consegui sacar demais", umaConta.sacar(76.91)); assertTrue("Nao consegui sacar", umaConta.sacar(76.90)); assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); try { umaConta.sacar(-0.01); fail("Esperava excecao no saque"); } catch (Exception ex) { assertEquals("Mensagem errada", "Saque nao pode ser negativo", ex .getMessage()); } assertEquals("Saldo errado", 0.0, umaConta.getSaldo(), 0.005); } public void testToString() throws Exception { ContaSimples3 umaConta = new ContaSimples3("Jacques Sauve", "123456789-01", 123); assertEquals("toString errado", "numero 123, nome Jacques Sauve, saldo 0.0", umaConta .toString()); umaConta.depositar(1.23); assertEquals("toString errado", "numero 123, nome Jacques Sauve, saldo 1.23", umaConta .toString()); } }
/** * Classe de conta bancária simples, com tratamento de erro * * @author Jacques Philippe Sauvé, jacques@dsc.ufcg.edu.br * @version 1.0 <br> * Copyright (C) 2006 Universidade Federal de Campina Grande. */ public class ContaSimples3 { // atributos private String nome; private String cpf; private int número; private double saldo; // construtor /** * Cria uma conta a partir de um nome e cpf de pessoa física, e um numero de * conta. * * @param nome * O nome do titular da conta. * @param cpf * O CPF do titular da conta. * @param número * O numero da conta. * @throws Exception * Se o nome for nulo ou vazio, o CPF for nulo ou vazio ou a * conta não for um número positivo */ public ContaSimples3(String nome, String cpf, int número) throws Exception { if (nome == null || nome.equals("")) { throw new Exception("Nome nao pode ser nulo ou vazio"); } if (cpf == null || cpf.equals("")) { throw new Exception("CPF nao pode ser nulo ou vazio"); } if (número <= 0) { throw new Exception("Número da conta deve ser positivo"); } this.nome = nome; this.cpf = cpf; this.número = número; saldo = 0.0; } // métodos /** * Recupera o numero da conta. * * @return O numero da conta. */ public int getNúmero() { return número; } /** * Recupera o nome do titular da conta. * * @return O nome do titular da conta. */ public String getNome() { return nome; } /** * Recupera o CPF do titular da conta. * * @return O CPF do titular da conta. */ public String getCPF() { return cpf; } /** * Recupera o saldo da conta. * * @return O saldo da conta. */ public double getSaldo() { return saldo; } /** * Efetua um depósito numa conta. * * @param valor * O valor a depositar. * @throws Exception * Para um deposito negativo */ public void depositar(double valor) throws Exception { if (valor < 0.0) { throw new Exception("Deposito nao pode ser negativo"); } // credita a conta saldo += valor; } /** * Efetua sacada na conta. * * @param valor * O valor a sacar. * @return O sucesso ou não da operação. * @throws Exception * Para um saque negativo */ public boolean sacar(double valor) throws Exception { if (valor < 0.0) { throw new Exception("Saque nao pode ser negativo"); } // debita a conta if (saldo - valor >= 0) { saldo -= valor; return true; } else { return false; } } /** * Transforma os dados da conta em um String. * * @return O string com os dados da conta. */ public String toString() { return "numero " + número + ", nome " + nome + ", saldo " + saldo; } // O programa sempre tem um "método" main que é onde começa a execução public static void main(String args[]) { try { // Abra uma conta de numero 1 para João com CPF 309140605-06 // A conta será "referenciada" com a variável umaConta ContaSimples3 umaConta = new ContaSimples3("Joao", "30914060506", 1); // Nesta conta, deposite R$1000,00 umaConta.depositar(1000.0); // Imprima o saldo da conta de João double saldo = umaConta.getSaldo(); System.out.print("Saldo da conta de Joao antes do saque: "); System.out.println(saldo); // Saque R$300,00 desta conta umaConta.sacar(300.0); // Imprima o objeto umaConta System.out.println(umaConta); // Imprima o saldo da conta de João System.out.println("Saldo da conta de Joao depois do saque: " + umaConta.getSaldo()); } catch (Exception ex) { System.err.println(ex.getMessage()); System.exit(1); } } // fim do método main }
/* * Desenvolvido para a disciplina Programacao 1 * Curso de Bacharelado em Ciência da Computação * Departamento de Sistemas e Computação * Universidade Federal de Campina Grande * * Copyright (C) 1999 Universidade Federal de Campina Grande. * Não redistribuir sem permissão. */ package p1.aplic.geral; import java.io.*; /** * Classe representando uma pessoa física. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ public class Pessoa implements Serializable { private String nome; private String cpf; // Construtores /* * Constroi uma pessoa com nome e CPF dados. * @param nome O nome da pessoa. * @param cpf O CPF da pessoa. */ public Pessoa(String nome, String cpf) { this.nome = nome; this.cpf = cpf; } /* * Constroi uma pessoa com nome dado e sem CPF. * @param nome O nome da pessoa. */ public Pessoa(String nome) { this(nome, ""); } /** * Recupera o nome da pessoa. * @return O nome da pessoa. */ public String getNome() { return nome; } /** * Recupera o CPF da pessoa. * @return O CPF associado à pessoa. */ public String getCPF() { return cpf; } /** * Ajusta o nome da pessoa. * @param nome O nome da pessoa. */ public void setNome(String nome) { this.nome = nome; } /** * Ajusta o CPF da pessoa. * @param cpf O CPF associado à pessoa. */ public void setCPF(String cpf) { this.cpf = cpf; } /** * Representa a pessoa como string */ public String toString() { return "Nome " + nome + ", cpf " + cpf; } /** * Testa a igualdade de um objeto com esta pessoa. * @param objeto O objeto a comparar com esta pessoa. * @return true se o objeto for igual a esta pessoa, false caso contrário. */ public boolean equals(Object objeto) { if(! (objeto instanceof Pessoa)) { return false; } Pessoa outra = (Pessoa)objeto; return getNome().equals(outra.getNome()) && getCPF().equals(outra.getCPF()); } }
// Construtores /* * Constroi uma pessoa com nome e CPF dados. * @param nome O nome da pessoa. * @param cpf O CPF da pessoa. */ public Pessoa(String nome, String cpf) { this.nome = nome; this.cpf = cpf; } /* * Constroi uma pessoa com nome dado e sem CPF. * @param nome O nome da pessoa. */ public Pessoa(String nome) { this(nome, ""); }
Pessoa p1 = new Pessoa("joão", "12345678901"); Pessoa p2 = new Pessoa("joão");
/** * Classe de conta bancária simples. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ import p1.aplic.geral.*; public class ContaSimples2 { // atributos private int número; private Pessoa titular; private double saldo; // construtores /** * Cria uma conta a partir de uma pessoa e número de conta. * @param titular O titular da conta. * @param número O número da conta. */ public ContaSimples2(Pessoa titular, int número) { this.número = número; this.titular = titular; saldo = 0.0; } /** * Cria uma conta a partir de um nome e cpf de pessoa física, e um número de conta. * @param nome O nome do titular da conta. * @param cpf O CPF do titular da conta. * @param número O número da conta. */ // há sobrecarga do método construtor public ContaSimples2(String nome, String cpf, int número) { // aninhamento de método construtor this(new Pessoa(nome, cpf), número); } /** * Recupera o número da conta. * @return O número da conta. */ public int getNúmero() { return número; } /** * Recupera o titular da conta. * @return O titular da conta. */ public Pessoa getTitular() { return titular; } /** * Recupera o nome do titular da conta. * @return O nome do titular da conta. */ /* feito para ajudar os principiantes escondendo a classe Pessoa no inicio */ public String getNome() { // aninhamento de método return titular.getNome(); } /** * Recupera o CPF do titular da conta. * @return O CPF do titular da conta. */ /* feito para ajudar os principiantes escondendo a classe Pessoa no inicio */ public String getCPF() { return titular.getCPF(); } /** * Recupera o saldo da conta. * @return O saldo da conta. */ public double getSaldo() { return saldo; } /** * Efetua um depósito numa conta. * @param valor O valor a depositar. */ public void depositar(double valor) { // credita a conta saldo += valor; } /** * Efetua sacada na conta. * @param valor O valor a sacar. * @return O sucesso ou não da operação. */ public boolean sacar(double valor) { // debita a conta if(saldo - valor >= 0) { saldo -= valor; return true; } else { return false; } } /** * Transforma os dados da conta em um String. * @return O string com os dados da conta. */ public String toString() { return "numero " + número + ", nome " + getNome() + ", saldo " + saldo; } }
public class TestaCarta extends TestCase { private Carta asPaus; private Carta asCopas; private Carta reiPaus; private Carta menorCarta; private Carta maiorCarta; private void setUp() { asPaus = new Carta(Carta.AS, Carta.PAUS); asCopas = new Carta(Carta.AS, Carta.COPAS); reiPaus = new Carta(Carta.REI, Carta.PAUS); menorCarta = new Carta(Carta.menorValor(), Carta.PAUS); maiorCarta = new Carta(Carta.maiorValor(), Carta.PAUS); } public void testEquals() { assertTrue(!asPaus.equals(null)); assertTrue(!asPaus.equals(new Baralho())); assertEquals(asPaus, asPaus); assertEquals(new Carta(Carta.AS, Carta.PAUS), asPaus); assertTrue(!asPaus.equals(asCopas)); assertTrue(!asPaus.equals(reiPaus)); } public void testMenor() { assertEquals(asPaus, menorCarta); } public void testMaior() { assertEquals(reiPaus, maiorCarta); } public void testCompareTo() { assertEquals("1", 0, asPaus.compareTo(asPaus)); assertEquals("2", 0, asPaus.compareTo(new Carta(Carta.AS, Carta.PAUS))); assertEquals("3", 0, asPaus.compareTo(asCopas)); assertTrue("4", asPaus.compareTo(reiPaus) < 0); assertTrue("5", reiPaus.compareTo(asPaus) > 0); } public void testToString() { assertTrue(asPaus.toString().equals("AS de PAUS")); } }
/* * Desenvolvido para a disciplina Programacao 1 * Curso de Bacharelado em Ciência da Computação * Departamento de Sistemas e Computação * Universidade Federal de Campina Grande * * Copyright (C) 1999 Universidade Federal de Campina Grande. * Não redistribuir sem permissão. */ package p1.aplic.cartas; /** * Uma carta de um baralho comum. * Num baralho comum, tem 52 cartas: 13 valores (AS, 2, 3, ..., 10, valete, dama, rei) * de 4 naipes (ouros, espadas, copas, paus). * Cartas podem ser criadas, comparadas (quanto a seu valor), etc. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ public class Carta { /** * Valor da carta AS. Usado para construir uma carta: new Carta(Carta.AS, Carta.PAUS) */ public static final int AS = 1; /** * Valor da carta VALETE. Usado para construir uma carta: new Carta(Carta.VALETE, Carta.PAUS) */ public static final int VALETE = 11; /** * Valor da carta DAMA. Usado para construir uma carta: new Carta(Carta.DAMA, Carta.PAUS) */ public static final int DAMA = 12; /** * Valor da carta REI. Usado para construir uma carta: new Carta(Carta.REI, Carta.PAUS) */ public static final int REI = 13; /** * Valor do naipe de PAUS. Usado para construir uma carta: new Carta(Carta.AS, Carta.PAUS) */ public static final int PAUS = 0; /** * Valor do naipe de OUROS. Usado para construir uma carta: new Carta(Carta.AS, Carta.OUROS) */ public static final int OUROS = 1; /** * Valor do naipe de COPAS. Usado para construir uma carta: new Carta(Carta.AS, Carta.COPAS) */ public static final int COPAS = 2; /** * Valor do naipe de ESPADAS. Usado para construir uma carta: new Carta(Carta.AS, Carta.ESPADAS) */ public static final int ESPADAS = 3; private int valor; private int naipe; /** * Construtor de uma carta comum. * @param valor O valor da carta (AS, 2, 3, ..., 10, VALETE, DAMA, REI). * @param naipe O naipe da carta (PAUS, OUROS, COPAS, ESPADAS). */ public Carta(int valor, int naipe) { this.valor = valor; this.naipe = naipe; } /** * Recupera o valor da carta. * @return O valor da carta. */ public int getValor() { return valor; } /** * Recupera o naipe da carta. * @return O naipe da carta. */ public int getNaipe() { return naipe; } /** * Recupera o valor da menor carta deste tipo que pode ser criada. * É possível fazer um laço de menorValor() até maiorValor() para varrer * todos os valores possíveis de cartas. * @return O menor valor. */ public static int menorValor() { return AS; } /** * Recupera o valor da maior carta deste tipo que pode ser criada. * É possível fazer um laço de menorValor() até maiorValor() para varrer * todos os valores possíveis de cartas. * @return O maior valor. */ public static int maiorValor() { return REI; } /** * Recupera o "primeiro naipe" das cartas deste tipo. * Ser "primeiro naipe" não significa muita coisa, já que naipes não tem valor * (um naipe não é menor ou maior que o outro). * Fala-se de "primeiro naipe" e "último naipe" para poder * fazer um laço de primeiroNaipe() até últimoNaipe() para varrer * todos os naipes possíveis de cartas. * @return O primeiro naipe. */ public static int primeiroNaipe() { return PAUS; } /** * Recupera o "último naipe" das cartas deste tipo. * Ser "último naipe" não significa muita coisa, já que naipes não tem valor * (um naipe não é menor ou maior que o outro). * Fala-se de "primeiro naipe" e "último naipe" para poder * fazer um laço de primeiroNaipe() até últimoNaipe() para varrer * todos os naipes possíveis de cartas. * @return O primeiro naipe. */ public static int últimoNaipe() { return ESPADAS; } /** * Compare esta carta a outra. * @param outra A carta a comparar a esta. * @return Zero se forem iguais. Um valor < 0 se a carta for menor que a outra carta. * Um valor > 0 se a carta for maior que a outra carta. */ public int compareTo(Carta outra) { return getValor() - outra.getValor(); } /** * Testa a igualdade de um objeto com esta carta. * @param objeto O objeto a comparar com esta carta. * @return true se o objeto for igual a esta carta, false caso contrário. */ public boolean equals(Object objeto) { if(! (objeto instanceof Carta)) { return false; } Carta outra = (Carta)objeto; return getValor() == outra.getValor() && getNaipe() == outra.getNaipe(); } private static final String[] nomeDeCarta = { "", // queremos sincronizar o valor da carta e seu indice (AS == 1, etc.) "AS", "DOIS", "TRES", "QUATRO", "CINCO", "SEIS", "SETE", "OITO", "NOVE", "DEZ", "VALETE", "DAMA", "REI", }; private static final String[] nomeDeNaipe = { "PAUS", "OUROS", "COPAS", "ESPADAS", }; /** * Representa a carta como String. * @return Um string representando a carta. */ public String toString() { return nomeDeCarta[getValor()] + " de " + nomeDeNaipe[getNaipe()]; } }
if(suaCarta.compareTo(minhaCarta) > 0) { System.out.println("Voce ganha."); suasVitórias++; } else if(suaCarta.compareTo(minhaCarta) < 0) { System.out.println("Eu ganho."); minhasVitórias++; } else { System.out.println("Empate."); }
public class TestaBaralho extends TestCase { private Baralho b1; // fica intacto private void setUp() { b1 = new Baralho(); } public void testNúmeroDeCartas() { assertEquals(1, b1.menorValor()); assertEquals(13, b1.maiorValor()); assertEquals(52, b1.númeroDeCartas()); } public void testBaralhoNovo() { assertTrue(baralhoEstáCompleto(b1)); } public void testBaralhar() { Baralho b2 = new Baralho(); b2.baralhar(); assertTrue(baralhoEstáCompleto(b2)); } private boolean baralhoEstáCompleto(Baralho b) { List cartasJáVistas = new ArrayList(); Iterator it = b.iterator(); while (it.hasNext()) { Carta c = (Carta) it.next(); // vê se carta está ok int v = c.getValor(); int n = c.getNaipe(); assertTrue("Valor não ok", v >= c.menorValor() && v <= c.maiorValor()); assertTrue("Naipe não ok", n >= c.primeiroNaipe() && n <= c.últimoNaipe()); assertTrue("Carta já vista", !cartasJáVistas.contains(c)); cartasJáVistas.add(c); } return cartasJáVistas.size() == 52; } public void testPegaCarta() { List cartasJáVistas = new ArrayList(); Baralho b3 = new Baralho(); Carta c; while ((c = b3.pegaCarta()) != null) { // vê se carta está ok int v = c.getValor(); int n = c.getNaipe(); assertTrue("Valor não ok", v >= c.menorValor() && v <= c.maiorValor()); assertTrue("Naipe não ok", n >= c.primeiroNaipe() && n <= c.últimoNaipe()); assertTrue("Carta já vista", !cartasJáVistas.contains(c)); cartasJáVistas.add(c); } assertEquals("Baralho não vazio", 0, b3.númeroDeCartas()); } }
/* * Desenvolvido para a disciplina Programacao 1 * Curso de Bacharelado em Ciência da Computação * Departamento de Sistemas e Computação * Universidade Federal de Campina Grande * * Copyright (C) 1999 Universidade Federal de Campina Grande. * Não redistribuir sem permissão. */ package p1.aplic.cartas; import java.util.*; import java.lang.Math.*; /** * Um baralho comum de cartas. * Num baralho comum, tem 52 cartas: 13 valores (AS, 2, 3, ..., 10, valete, dama, rei) * de 4 naipes (ouros, espadas, copas, paus). * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ public class Baralho { /** * O baralho é armazenado aqui. */ private List baralho; /** * Construtor de um baralho comum. */ public Baralho() { // Usa uma List para ter um iterador facilmente baralho = new ArrayList(); // enche o baralho for(int valor = menorValor(); valor <= maiorValor(); valor++) { for(int naipe = primeiroNaipe(); naipe <= últimoNaipe(); naipe++) { baralho.add(new Carta(valor, naipe)); } } } /** * Recupera o valor da menor carta possível deste baralho. * É possível fazer um laço de menorValor() até maiorValor() para varrer * todos os valores possíveis de cartas. * @return O menor valor. */ public int menorValor() { return Carta.menorValor(); } /** * Recupera o valor da maior carta possível deste baralho. * É possível fazer um laço de menorValor() até maiorValor() para varrer * todos os valores possíveis de cartas. * @return O maior valor. */ public int maiorValor() { return Carta.maiorValor(); } /** * Recupera o "primeiro naipe" das cartas que podem estar no baralho. * Ser "primeiro naipe" não significa muita coisa, já que naipes não tem valor * (um naipe não é menor ou maior que o outro). * Fala-se de "primeiro naipe" e "último naipe" para poder * fazer um laço de primeiroNaipe() até últimoNaipe() para varrer * todos os naipes possíveis de cartas. * @return O primeiro naipe. */ public int primeiroNaipe() { return Carta.primeiroNaipe(); } /** * Recupera o "último naipe" das cartas que podem estar no baralho. * Ser "último naipe" não significa muita coisa, já que naipes não tem valor * (um naipe não é menor ou maior que o outro). * Fala-se de "primeiro naipe" e "último naipe" para poder * fazer um laço de primeiroNaipe() até últimoNaipe() para varrer * todos os naipes possíveis de cartas. * @return O primeiro naipe. */ public int últimoNaipe() { return Carta.últimoNaipe(); } /** * Recupera o número de cartas atualmente no baralho. * @return O número de cartas no baralho. */ public int númeroDeCartas() { return baralho.size(); } /** * Baralha (traça) o baralho. */ public void baralhar() { int posição; for(posição = 0; posição < númeroDeCartas() - 1; posição++) { // escolhe uma posição aleatória entre posição e númeroDeCartas()-1 int posAleatória = posição + (int)((númeroDeCartas() - posição) * Math.random()); // troca as cartas em posição e posAleatória Carta temp = (Carta)baralho.get(posição); baralho.set(posição, baralho.get(posAleatória)); baralho.set(posAleatória, temp); } } /** * Retira uma carta do topo do baralho e a retorna. A carta é removida do baralho. * @return A carta retirada do baralho. */ public Carta pegaCarta() { if(númeroDeCartas() == 0) return null; return (Carta)baralho.remove(númeroDeCartas()-1); } }
/* * Desenvolvido para a disciplina Programacao 1 * Curso de Bacharelado em Ciência da Computação * Departamento de Sistemas e Computação * Universidade Federal de Campina Grande * * Copyright (C) 1999 Universidade Federal de Campina Grande. * Não redistribuir sem permissão. */ package p1.aplic.cartas; import java.util.*; /** * Um jogo de cartas simples. * Cada jogador recebe uma carta do baralho. * A maior carta ganha. * Repete para cada rodada. * * @author Jacques Philippe Sauvé, jacques@dsc.ufpb.br * @version 1.0 * <br> * Copyright (C) 1999 Universidade Federal de Campina Grande. */ public class MaiorCarta { private int suasVitórias; // pontuação private int minhasVitórias; private Baralho baralho; /** * Construtor do jogo. */ public MaiorCarta() { suasVitórias = 0; minhasVitórias = 0; baralho = new Baralho(); baralho.baralhar(); } /** * Joga o jogo de Maior Carta. * @param rodadas O número de rodadas a jogar. */ public void joga(int rodadas) { for(int i = 0; i < rodadas; i++) { Carta suaCarta = baralho.pegaCarta(); System.out.print("Sua carta: " + suaCarta + " "); Carta minhaCarta = baralho.pegaCarta(); System.out.print("Minha carta: " + minhaCarta + " "); if(suaCarta.compareTo(minhaCarta) > 0) { System.out.println("Voce ganha."); suasVitórias++; } else if(suaCarta.compareTo(minhaCarta) < 0) { System.out.println("Eu ganho."); minhasVitórias++; } else { System.out.println("Empate."); } } System.out.println("Voce ganhou " + suasVitórias + " vezes, eu ganhei " + minhasVitórias + " vezes, " + (rodadas-suasVitórias-minhasVitórias) + " empates."); } }
import p1.aplic.cartas.*; public class Exemplo2 { public static void main(String args[]) { (new MaiorCarta()).joga(15); } }
Sua carta: CINCO de PAUS Minha carta: DEZ de COPAS Eu ganho. Sua carta: DEZ de OUROS Minha carta: SETE de COPAS Voce ganha. Sua carta: DAMA de PAUS Minha carta: DEZ de PAUS Voce ganha. Sua carta: DOIS de PAUS Minha carta: QUATRO de ESPADAS Eu ganho. Sua carta: TRES de ESPADAS Minha carta: OITO de ESPADAS Eu ganho. Sua carta: DAMA de COPAS Minha carta: TRES de OUROS Voce ganha. Sua carta: TRES de PAUS Minha carta: VALETE de OUROS Eu ganho. Sua carta: AS de PAUS Minha carta: DAMA de ESPADAS Eu ganho. Sua carta: REI de COPAS Minha carta: QUATRO de OUROS Voce ganha. Sua carta: CINCO de OUROS Minha carta: DEZ de ESPADAS Eu ganho. Sua carta: AS de ESPADAS Minha carta: VALETE de PAUS Eu ganho. Sua carta: SETE de OUROS Minha carta: DOIS de OUROS Voce ganha. Sua carta: SEIS de ESPADAS Minha carta: CINCO de ESPADAS Voce ganha. Sua carta: REI de PAUS Minha carta: SEIS de PAUS Voce ganha. Sua carta: REI de ESPADAS Minha carta: CINCO de COPAS Voce ganha. Voce ganhou 8 vezes, eu ganhei 7 vezes, 0 empates.
Exercício para a sala de aula: nos testes de Carta e Baralho, não faltou testar condições de erro? Quais?