AGRADECIMENTO...

Pessoal, Gostaria de pedir desculpas aqueles que deixam perguntas/comentários/elogios/críticas e ainda não foram respondidos.

Aproveito a oportunidade para informar a todos que devido a correria do dia a dia não conclui o curso de BSI, por isso meus conhecimentos são limitados rsrsrs...

Ainda não retirei o blog do ar porque tem ajudado a diversos estudantes, principalmente os iniciantes.

As vezes, quando o trabalho me permite, ainda arrisco tentar resolver algumas questões rs... mas para não deixar esse blog parar no tempo, o ESTUDANTE que quiser enviar a resolução de alguma questão (código próprio) para o meu e-mail, terei o prazer de posta-la neste blog e será mantido a autoria.

Desde já agradeço a todos pelas visitas e desejo bons estudos.

Thiago Campos
(srthiago@hotmail.com)

sexta-feira, 28 de setembro de 2012

Questão 4: Conta Bancárial


Programe o dominio especificado no diagrama de classes abaixo e em seguida  crie uma classe para instanciar uma conta bancária e simule a realização de um deposito e um saque. Em seguida apresente o saldo para o usuário final.

    ____________________________
                      ContaBancaria
    -------------------------------------
      - agencia: String
      - conta: String
      - saldo: double
    -------------------------------------
      + exibirSaldo(): void
      + realizarSaque(valor: double): void
      + depositar(valor: double): void
    _____________________________


Código Java

//Autor; Thiago Campos
//Data: 25.09.2012

package thiago.prova.questoes;

import javax.swing.JOptionPane;
import thiago.prova.questoes.classe.Q4Conta;

/**
 *
 * @author Thiago
 */
public class Questao4 {

    public static void main(String[] args) {
        //variaveis
        Q4Conta brasil = new Q4Conta();

        String ag = "2035-4";
        String co = "20.202";
        double sa = 1000;
        int menu;
        double valor;

        //setando os valors
        brasil.setAgencia(ag);
        brasil.setConta(co);
        brasil.setSaldo(sa);

        //escolha do metodo
        menu = Integer.parseInt(JOptionPane.showInputDialog("Escolha a operação desejada:"
                + "\n1-Exibir Saldo"
                + "\n2-Saca"
                + "\n3-Depositar"));

        switch (menu) {
            case 1:
                brasil.exibirSaldo();
                break;
            case 2:
                valor = Integer.parseInt(JOptionPane.showInputDialog("Informe o valor do saque:"));
                brasil.realizarSaque(valor);
                brasil.exibirSaldo();
                break;
            case 3:
                valor = Integer.parseInt(JOptionPane.showInputDialog("Informe o valor para deposito:"));
                brasil.depositar(valor);
                brasil.exibirSaldo();
                break;

            default:
                JOptionPane.showMessageDialog(null, "Opção invalida!");
        } //fim do switch

    } //fim do main
} //fim da classe
/*-------------------------------------------------------------------------------------------------------
*INICIO DA CLASSE Q4CONTA
-------------------------------------------------------------------------------------------------------*/

package thiago.prova.questoes.classe;

import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class Q4Conta {
    //variaveis
    private String agencia;
    private String conta;
    private double saldo;
   
    //get e set
    public String getAgencia() {
        return agencia;
    }

    public void setAgencia(String agencia) {
        this.agencia = agencia;
    }

    public String getConta() {
        return conta;
    }

    public void setConta(String conta) {
        this.conta = conta;
    }

    public double getSaldo() {
        return saldo;
    }

    public void setSaldo(double saldo) {
        this.saldo = saldo;
    }
   
    //metodo 
    public void exibirSaldo(){
        JOptionPane.showMessageDialog(null, "O saldo é: :" + saldo);
    } //fim do metodo 
   
    public void realizarSaque(double valor){
        saldo = saldo - valor;
    } //fim do metodo 
   
    public void depositar(double valor){
        saldo = saldo + valor;
    } //fim do metodo 
   
} //fim da classe


Questão 3 Pilha

Programe uma pilha com as operações push(int valor) e pop(). Após a criação da classe Pilha, instancie uma pilha com cinco posições preencha a mesma com dados informados pelo usuário. Em seguida remova dois elementos da mesma e apresente os dados na pilha para o usuário.

Observação: a pilha não pode conter elementos repetidos.

Código Java

//Autor; Thiago Campos
//Data: 25.09.2012
package thiago.prova.questoes;

import javax.swing.JOptionPane;
import thiago.prova.questoes.classe.Q3Pilha;

/**
 *
 * @author Thiago
 */
public class Questao3 {

    public static void main(String[] args) {
        //variaveis
        int n;
        int v; //recebe o retorno do metodo verificaConteudo
        int k = 5; //qtd de vezes do laço

        //criação da pilha
        Q3Pilha pilha = new Q3Pilha();

        for (int j = 0; j < k; j++) {

            n = Integer.parseInt(JOptionPane.showInputDialog("Informe a pilha: "));
            v = pilha.verificaConteudo(n);

            //caso a pilha ja tenha o elemento
            if (v == 1) {
                JOptionPane.showMessageDialog(null, "Elemento ja está contido na pilha.");
                k += 1; //incrementa o tamanho do laço pq o elemento está repetido
                continue; //volta para o inicio do for
            } else {
                pilha.push(n); //chama o metodo push
            }

        }//fim do for

        //exibindo a pilha
        pilha.exibirPilha();

        //retirando 2 elementos da pilha
        pilha.pop();
        pilha.pop();
        pilha.exibirPilha();

    } //fim do main
} //fim da classe
/*---------------------------------------------------------------------------------------------------------
* INICIO DA CLASSE Q3_PILHA
---------------------------------------------------------------------------------------------------------*/


package thiago.prova.questoes.classe;

import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class Q3Pilha {
    //variaveis
    private int topo = -1;
    private Integer[] v = new Integer[5];

    //metodo push
    public void push(int valor) {
        if (topo < v.length) {
            topo++;
            v[topo] = valor;
           
        } else {
            JOptionPane.showMessageDialog(null, " A pilha está cheia.");
        }
    }

    //metodo pop
    public void pop() {
        if (topo >= 0) {
            v[topo] = null;
            topo--;
        } else {
            JOptionPane.showMessageDialog(null, "Pilha Vazia.");
        }
    }

    //exibir pilha
    public void exibirPilha() {
        String pilha = "";
        for (int i = 0; i < v.length; i++) {
            pilha += v[i] + " ";
        }
        JOptionPane.showMessageDialog(null, "Elementos da pilha:\n" + pilha);
    } //fim do metodo exibirPilha
   
   //metodo verifica se ha elemento igual na pilha
    public int verificaConteudo(int n) {
        for (int i = 0; i <= topo; i++) {
            if (topo >= 0 && v[i] == n) {return 1;}
        } //fim do for
        return 0;
    } //fim do metodo
} //fim da classe

quarta-feira, 26 de setembro de 2012

Questão 2: Função Recursiva - Fatorial


Crie uma classe que programe uma função recursiva que realize o calculo fatorial(int valor). Em seguida, crie uma classe que receba um valor digitado pelo usuário e apresente o fatorial do valor informado.
Observação: regras para o fatorial recursivo:
 a) n! = 1 se n=0;
 b) n! = n *(n-1)! para n>0


Código Java

//Autor; Thiago Campos
//Data: 25.09.2012

/*
 *
 */

package thiago.prova.questoes;

import javax.swing.JOptionPane;
import thiago.prova.questoes.classe.Q2Fatorial;

/**
 *
 * @author Thiago
 */
public class Questao2 {
    public static void main(String[] args) {
        //variaveis
        Q2Fatorial fat = new Q2Fatorial();
        int n;

        //entrada
        n = Integer.parseInt(JOptionPane.showInputDialog("Informe o valor para calcular o fatorial:"));

        JOptionPane.showMessageDialog(null, "O fatorial de " + n + " é: " + fat.fatorial(n));
    } //fim do main  
} //fim da classe

/*---------------------------------------------------------------------------------------------
 * Inicio da classe dominio
 ---------------------------------------------------------------------------------------------*/

package thiago.prova.questoes.classe;

public class Q2Fatorial {
    public static int fatorial(int num) {
        //inicio
        if (num == 1 || num == 0) {
            return (1);
        } else {
            return (num * fatorial(num - 1));
        }
    } //fim da função fatorial
} //fim da classe


Questão 1: Vetores e Matriz

Programar uma classe que crie dois vetores inteiros v1 e v2 de cinco posições de dados informados pelo usuário e transforme esses dois vetores em uma matriz VM de duas linhas e 5 colunas. Em seguida exiba a matriz numa janela JOptionPane para o usuário.

Código Java
//Autor; Thiago Campos
//Data: 25.09.2012

package thiago.prova.questoes;

import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class Questao1 {

    public static void main(String[] args) {
        //variaveis
        int[] v1 = new int[5];
        int[] v2 = new int[5];
        int[][] vm = new int[2][5];
        String matriz = "";

        //entrada dos dados - vetor 1
        for (int i = 0; i < 5; i++) {
            v1[i] = Integer.parseInt(JOptionPane.showInputDialog("Informe o "
                    + (i + 1) + " elemento do vetor 1:"));
        }

        //entrada dos dados - vetor 2
        for (int i = 0; i < 5; i++) {
            v2[i] = Integer.parseInt(JOptionPane.showInputDialog("Informe o "
                    + (i + 1) + " elemento do vetor 2:"));
        }
        for (int i = 0; i < 5; i++) {
            vm[0][i] = v1[i];
        }
        for (int i = 0; i < 5; i++) {
            vm[1][i] = v2[i];
        }

        //preparando a saida
        matriz += "|";
        for (int i = 0; i < 5; i++) {
            matriz += vm[0][i];
        }
        matriz += "|\n|";
        for (int i = 0; i < 5; i++) {
            matriz += vm[1][i];
        }
        matriz += "|";
        JOptionPane.showMessageDialog(null, "A matriz VM é: "
                + "\n" + matriz);
    } //fim do main 
} //fim da classe

terça-feira, 25 de setembro de 2012

Código que mostra a tabuada de multiplicação de 5.

Elabore um programa que mostre a tabuada de multiplicação de 5.

Código Java

//Autor: Thiago Campos
//Data: 25.09.2012

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane;

public class Tabelade5 {
    public static void main(String[] args){
        //variaveis
        String tab5 = "                     "; //dei 10 espaços para centralizar o resultado
     
        //processamento
        for (int i = 1; i < 11; i++) {
            tab5 += (5 * i) + "\n                    "; //dei 10 espaços para centralizar o resultado
        } //fim do for
     
        //saida
        JOptionPane.showMessageDialog(null, "Tabulada de Multiplicação de 5:\n" + tab5);
 
    } //fim do main
} //fim da classe

segunda-feira, 24 de setembro de 2012

Usando While para escrever uma matriz em Java


Escreva um programa que gere a seguinte saída. (while):

                                                  1     2     3     4     5     6     7     8     9    10
  2     4     6     8    10   12   14  16   18   20
  3     6     9    12   15   18   21  24   27   30
  4     8   12    16   20   24   28  32   36   40
  5    10  15    20   25   30   35  40   45   50
  6    12  18    24   30   36   42  48   54   60
  7    14  21    28   35   42   49  56   63   70
  8    16  24    32   40   48   56  64   72   80
  9    18  27    36   45   54   63  72   81   90
10    20  30    40   50   60   70  80   90  100


Código Java

//Autor: Thiago Campos
//Data: 24.09.2012

 */
/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane;

public class SaidaMatriz {

    public static void main(String[] args) {
        //variaveis
        int j = 1; //coluna
        int i = 0; //linha
        String matriz = "";

        while (j <= 10) { //lope e condição de parada
            i++;

            //guarda a sequencia
            matriz += (i * j) + " ";

            if (i == 10) { //condição para a quebra da linha
                matriz += "\n";
                i = 0;
                j++;
            } //fim do if
        } //fim do while
        //saida
        JOptionPane.showMessageDialog(null, "O resultado é:\n" + matriz);

    } //fim do main
} //fim da classe

domingo, 23 de setembro de 2012

Inverter sequencia numérica com vetor


Faça um programa que receba uma sequencia numérica e mostre a sequencia na ordem invertida.


Código Java

//Autor: Thiago Campos
//Data: 23.09.2012

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane;

public class InverteVetores {

    public static void main(String[] args) {
        //variaveis
        String seqDigitada = "";
        String seqInvertida = "";
        int[] vetor = new int[10];

        //entrada dos dados
        for (int i = 0; i < 10; i++) {
            vetor[i] = Integer.parseInt(JOptionPane.showInputDialog("Insira o numero:"));
            seqDigitada += vetor[i] + " ";
        }
        //saida  
        for (int i = 9; i >= 0; i--) {
            seqInvertida += vetor[i] + " ";
        }
        JOptionPane.showMessageDialog(null, "Vetor A (sequencia digitada): " + seqDigitada
                + "\nVetor B (sequencia invertida): " + seqInvertida);
    } //fim do main
} //fim da classe
(Atendendo a pedido)

sábado, 22 de setembro de 2012

Questão 5 do livro Java 7 de Sergio Furgeri página 65


Faça uma classe que apresente numa tela a soma de todos os números impares compreendidos entre 1 e 1000.


Código Java

//Autor; Thiago Campos
//Data: 22.09.2012

package br.com.livroJava7.pag64;

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane;

public class Q5_SomaImpares {

    public static void main(String[] args) {
        //variaveis
        int soma = 0;

        //processamento
        for (int i = 1; i < 1000; i += 2) {
            soma += i;
        } //fim do for
        JOptionPane.showMessageDialog(null, "A soma dos impares de 1 a 1000 é: " + soma);
    } //fim do main
} //fim da classe
(Fonte: Questçao retirada do Livro Java 7 de Sérgio Furgeri - página 65)

Questão 4 do livro Java 7 de Sergio Furgeri - página 65


Faça uma classe que solicite uma senha, simulando um caixa eletrônico.  Considere que a senha é Java. Caso o usuario forneça a senha correta, apresentar a mensagem "Senha Válida", caso contrário, "Senha Inválida". Se o usuario fornecer a senha incorreta 3 vezes seguidas, o programa deve apresentar a mensagem "Cartão Cancelado".


Código Java

//Autor; Thiago Campos
//Data: 22.09.2012

package br.com.livroJava7.pag64;

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane;

public class E4_Senha {

    public static void main(String[] args) {
        //variaveis
        String senha;
        int cont = 0;

        //entrada de dados
        senha = JOptionPane.showInputDialog("Informe a senha:");
   
        //Processamento e validação
        for (int i = 0; i < 4; i++) {
            if (senha.equals("Java")) {
                cont = 0;
                JOptionPane.showMessageDialog(null, "Senha Válida!");
                break;
            } else {
                cont++;
                if (cont == 3) {
                    JOptionPane.showMessageDialog(null, "Cartão Cancelado!"
                            + "\n" + cont + " tentativa(s).");
                    break;
                } else {
                    JOptionPane.showMessageDialog(null, "Senha Invlaida!"
                            + "\n" + cont + " tentativa(s).");
                    senha = JOptionPane.showInputDialog("Informe a senha:");
                }
            } //fim do else
        } //fim do for
    } //fim do main
} //fim da classe
(Fonte: Questçao retirada do Livro Java 7 de Sérgio Furgeri - página 65)

sexta-feira, 21 de setembro de 2012

Questão 3 do livro Java 7 de Sergio Furgeri - página 64


Elabore uma classe em que o usuário fornece dois números e uma letra correspondente a operação desejada de acordo com a tabela:
  -------------------------
  Letra   |   Operação
  -------------------------
    A     |   Adição                         PS: Procurei    fazer  de   forma  didática e de
    B     |   Subtração                           2 maneiras: uma com funções na mesma
    C     |   Multiplicação                      classe outra em classes diferentes.
    D     |   Divisão            
  -------------------------
                                    (Questão 3 do livro Java 7 de Sergio Furgeri - página 64)
Código Java

//Autor: Thiago Campos
//Data: 20.09.2012

package br.com.livroJava7.pag64; //pertence a este pacote

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane; //importa a biblioteca

public class Operacoes {
     
    public static void main(String[] args){
        //variaveis locais
        double num1;
        double num2;
        double result = 0; //resultado da operacao
        char opcao='x';
        String opcaoStr;  //guada a operação
        String numeros = ""; //valores digitados
        String operacao = ""; //operação escolhida
     
        //entrada de dados
        num1 = Integer.parseInt(JOptionPane.showInputDialog("Informe o primeiro numero:"));
        num2 = Integer.parseInt(JOptionPane.showInputDialog("Informe o segundo numero:"));
     
        opcaoStr = JOptionPane.showInputDialog("Informe a operação desejada:");
        opcao = opcaoStr.charAt(0);
     
        //processo decisório
        switch (opcao) {
            case 'A':
                result = adicao(num1, num2);
                opcaoStr = "Adição";
                break;
            case 'B':
                result = subtrair(num1, num2);
                opcaoStr = "Subtração";
                break;
            case 'C':
                result = multiplicar(num1, num2);
                opcaoStr = "Multiplicação";
                break;
            case 'D':
                opcaoStr = "Divisão";
                if (num2 == 0){
                    JOptionPane.showMessageDialog(null, "Opção invalida, o divisor não pode ser 0!");
                }else{
                    result = dividir(num1, num2);
                }
                break;
            default:
                JOptionPane.showMessageDialog(null, "Opção invalida!");
                opcaoStr = "Invalida";
        } //fim do switch
     
        //saida dos dados
        JOptionPane.showMessageDialog(null, "RESULTADO DA OPERAÇÃO"
                + "\nOs valores digitados foram: " + num1 + " e " + num2
                + "\nOperação escolhida: " + opcaoStr
                + "\nResultado da operação é: " + result);
     
    } //fim do main
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *  Inicio da função adição
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    public static double adicao(double n1, double n2){
        //variavel
        double s = 0; //resultado da soma
        s = n1 + n2;
        return s;
    } //fim da função Adicao
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *  Inicio da função subtração
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    public static double subtrair(double n1, double n2){
        //variavel
        double sub = 0; //resultado da subt
        sub = n1 - n2;
        return sub;
    } //fim da função Adicao
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *  Inicio da função multiplicar
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    public static double multiplicar(double n1, double n2){
        //variavel
        double m = 0; //resultado da multiplicação
        m = n1 * n2;
        return m;
    } //fim da função Adicao
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *  Inicio da função dividir
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
    public static double dividir(double n1, double n2){
        //variavel
        double d = 0; //resultado da divisão
        d = n1 / n2;
        return d;
    } //fim da função Adicao
 
} //fim da classe operações
_______________________________________________________________
2ª OPÇÃO :  CLASSES  DISTINTAS PARA O MESMO PROBLEMA
_______________________________________________________________

Código Java

//Autor: Thiago Campos
//Data: 20.09.2012

package br.com.livroJava7.pag64; //pertence a este pacote

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane; //importa a biblioteca

public class Operacao2 {
     
    public static void main(String[] args){
        //variaveis locais
        OperacaoClasse valor = new OperacaoClasse(); //instanciando objeto
     
        double num1;
        double num2;
        double result = 0; //resultado da operacao
        char opcao='x';
        String opcaoStr;  //guada a operação
        String numeros = ""; //valores digitados
        String operacao = ""; //operação escolhida
     
        //entrada de dados
        num1 = Integer.parseInt(JOptionPane.showInputDialog("Informe o primeiro numero:"));
        num2 = Integer.parseInt(JOptionPane.showInputDialog("Informe o segundo numero:"));
     
        opcaoStr = JOptionPane.showInputDialog("Informe a operação desejada:");
        opcao = opcaoStr.charAt(0);

        //processo decisório    
        switch (opcao) {
            case 'A':
                valor.setAdicao(num1, num2); //envio des variaveis
                result = valor.getAdicao(); //retorno do resultado
                opcaoStr = "Adição";
                break;
            case 'B':
                valor.setSubtrair(num1, num2); //envio des variaveis
                result = valor.getSubtrair(); //retorno do resultado
                opcaoStr = "Subtração";
                break;
            case 'C':
                valor.setMultiplicar(num1, num2); //envio des variaveis
                result = valor.getMultiplicar(); //retorno do resultado
                opcaoStr = "Multiplicação";
                break;
            case 'D':
                valor.setDividir(num1, num2); //envio des variaveis
                opcaoStr = "Divisão";
                if (num2 == 0){
                    JOptionPane.showMessageDialog(null, "Opção invalida, o divisor não pode ser 0!");
                }else{
                    result = valor.getDividir(); //retorno do resultado
                }
                break;
            default:
                JOptionPane.showMessageDialog(null, "Opção invalida!");
                opcaoStr = "Invalida";
        } //fim do switch
     
        //saida dos dados
        JOptionPane.showMessageDialog(null, "RESULTADO DA OPERAÇÃO"
                + "\nOs valores digitados foram: " + num1 + " e " + num2
                + "\nOperação escolhida: " + opcaoStr
                + "\nResultado da operação é: " + result);
     
    } //fim do main

} //fim da classe operaçao2

_______________________________________________________________
CLASSE DOS METODOS
_______________________________________________________________




package br.com.livroJava7.pag64; //pertence a este pacote

/**
 *
 * @author Thiago
 */

public class OperacaoClasse {
    //variaveis
    private double res = 0;
 
    //set e get
    public void setAdicao(double n1, double n2){
        res = n1 + n2;
    }
    public double getAdicao(){
        return res;
    }
    public void setSubtrair(double n1, double n2){
        res = n1 - n2;
    }
    public double getSubtrair(){
        return res;
    }
    public void setMultiplicar(double n1, double n2){
        res = n1 * n2;
    }
    public double getMultiplicar(){
        return res;
    }
    public void setDividir(double n1, double n2){
        res = n1 / n2;
    }
    public double getDividir(){
        return res;
    }
 
} //fim da classe OperacaoClasse



Questão 2 do livro Java 7 de Sergio Furgeri - página 64


Faça uma classe que receba 4 idades diferentes e mostre a menor e a maior idade numa janela JOptionPane
(Questão retirada do livro Java 7 de Sergio Furgeri - página 64)

Código Java

//Autor: Thiago Campos
//Data: 20.09.2012

package br.com.livroJava7.pag64; //pertence a este pacote

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane; //importa a biblioteca

public class E2_MaiorMenor {
    public static void main(String[] args){
        //variaveis
        int[] idade = new int[4];
        int maior = 0; //guarda a maior idade
        int menor = 0; //guarda a menor idade
        String todasIdades = ""; //vai guardar as idades informadas
       
        //entrada de dados no vetor
        for (int i = 0; i < 4; i++) {
            idade[i] = Integer.parseInt(JOptionPane.showInputDialog("Informe a idade:"));
            todasIdades += idade[i] + " ";
        }
        //inicializando as variaveis com o 1º valor para comparação
        maior = idade[0];
        menor = idade[0];
       
        for (int i = 0; i < 4; i++) {
            if (maior < idade[i]){
                maior = idade[i];
            }
            if (menor > idade[i]){
                menor = idade[i];
            }
        } //fim do for
       
        //saida dos dados
        JOptionPane.showMessageDialog(null, "As idades informadas foram:"
                + "\n" + todasIdades
                + "\nA maior idade é: " + maior
                + "\nA menor idade é: " + menor);
    } //fim do main
   
} //fim da classe

quarta-feira, 19 de setembro de 2012

Exemplo simples de um código Java feito durante a aula

Atividade proposta pelo professor para exercitar o desenvolvimento de programas com classes separadas : Desenvolva um programa segundo a tabela abaixo:
-----------------------
|    Processo        |
-----------------------
- id: int
-numero: int                         PS: Existem várias maneiras de fazer esta atividade
- ano: int                                    busquei a forma mais didáyica. Lembro aos in-
- assunto: String                          ternautas que é possivel enxugar bastante
- observacao: String                     este código.
- status: int
-----------------------
+ exibirDados
==============

Construa dois objetos que recebam os dados:(forneciddos pelo teclado e automatico)
Cada classe, um arquivo.

Código Java
/ *-------------------------------------------------------------------------------------------------------------------
 *        Ckasse do pacote br.com.unirn.main
 -------------------------------------------------------------------------------------------------------------------*/

//Auto: Thiago Campos
//Data: 19.09.2012

package br.com.unirn.main;

import br.com.unirn.dominio.Processo;
import javax.swing.JOptionPane;
/**
 *
 * @author Thiago
 */
public class MProcesso {
    public static void main(String[] args){
        //variaveis
        int id;
        int numero;
        int ano;
        int status;
        String assunto;
        String observacao;
       
        //instanciando objetos
        Processo p1 = new Processo();
        Processo p2 = new Processo();
       
        //entrada automatica 
        id = 01;
        numero = 1234;
        ano = 2010;
        assunto = "Prova";
        observacao = "Aprovado";
        status = 10;
       
        //setando os atributos do objeto p1
        p1.setId(id);
        p1.setNumero(numero);
        p1.setAno(ano);
        p1.setAssunto(assunto);
        p1.setObservacao(observacao);
        p1.setStatus(status);
       
        //zerando as variaveis
        id = 0;
        numero = 0;
        ano = 0;
        assunto = "";
        observacao = "";
        status = 0;
       
        //entrada de valores pelo teclado
        id = Integer.parseInt(JOptionPane.showInputDialog("Id:" + id));
        numero = Integer.parseInt(JOptionPane.showInputDialog("Numero: :" + numero));
        ano = Integer.parseInt(JOptionPane.showInputDialog("Ano:" + ano));
        assunto = JOptionPane.showInputDialog("Assunto:" + assunto);
        observacao = JOptionPane.showInputDialog("Observação:" + observacao);
        status = Integer.parseInt(JOptionPane.showInputDialog("Status:" + status));
       
        //setando os atributos do objeto p2
        p2.setId(id);
        p2.setNumero(numero);
        p2.setAno(ano);
        p2.setAssunto(assunto);
        p2.setObservacao(observacao);
        p2.setStatus(status);
       
        p1.exibirDados();
        p2.exibirDados();
    } //fim do mais
   
} //fim da classe MProcesso

/ *-------------------------------------------------------------------------------------------------------------------
 *        Ckasse do pacote br.com.unirn.main
 -------------------------------------------------------------------------------------------------------------------*/

package br.com.unirn.dominio;

import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class Processo {
    //variaveis
    private int id;
    private int numero;
    private int ano;
    private String assunto;
    private String observacao;
    private int status;
   
    //metodos set
    public void setId(int id){
        this.id = id;
    }
    public void setNumero(int numero){
        this.numero = numero;
    }
    public void setAno(int ano){
        this.ano = ano;
    }
    public void setAssunto(String assunto){
        this.assunto = assunto;
    }
    public void setObservacao(String observacao){
        this.observacao = observacao;
    }
    public void setStatus(int status){
        this.status = status;
    }

    //metodos get
    public int getId(){
        return id;
    }
    public int getNumero(){
        return numero;
    }
    public int getAno(){
        return ano;
    }
    public String getAssunto(){
        return assunto;
    }
    public String getObservacao(){
        return observacao;
    }
    public int getStatus(){
        return status;
    }
   
    //metodo exibir
    public void exibirDados(){
        JOptionPane.showMessageDialog(null, "Exibir os dados:"
                + "\nid:" + id
                + "\nnumero: " + numero
                + "\nano: " + ano
                + "\nassunto: " + assunto
                + "\nobservacao: " + observacao
                + "\nstatus: " + status);
    } //fim do metodo      
   
} //fim da classe Processo




Java, Classes diferentes e JOptionPane

Brincando com classes diferentes, simulando uma conta de banco.

Código Java

/*--------------------------------------------------------------------------------------------------------
 * Código do pacote br.com.thiago.main - Classe MConta
 --------------------------------------------------------------------------------------------------------*/
//Auto: Thiago Campos
//Data: 19.09.2012

package br.com.thiago.main;

import br.com.thiago.dominio.Conta;
import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class MConta {

    public static void main(String[] args) {
        //variaveis
        String nome;
        String cpf;
        String senha = "";
        String conta = "";
        int opcao = -1;

        //criando objeto
        Conta c1 = new Conta();
        Conta c2 = new Conta();


        //preenchendo automaticamente
        c1.setCpf("001.021.031-41");
        c1.setNConta("987");
        c1.setSaldo(200);

        //cliente 2
        c2.setCliente("Taynar Neri");
        c2.setCpf("041.051.061-71");
        c2.setSenha("rafa");
        c2.setNConta("123");
        c2.setSaldo(1000);


        //entrada
        nome = JOptionPane.showInputDialog("Informe o nome do cliente:");


        //setando o obj c1
        c1.setCliente(nome);

        //escolha
        do {
            opcao = Integer.parseInt(JOptionPane.showInputDialog("Escolha a opção:"
                    + "\n1-" + c1.getCliente()
                    + "\n2-" + c2.getCliente()
                    + "\n3-Sair"));
            switch (opcao) {
                case 1: //cliente c1
                    senha = JOptionPane.showInputDialog("Cadastre a senha do cliente:");
                    c1.setSenha(senha);

                    conta = JOptionPane.showInputDialog("Conta::");

                    if (conta.equals(c1.getNConta())) {
                        senha = JOptionPane.showInputDialog("Senha:");
                        if (senha.equals(c1.getSenha())) {
                            //Saida
                            JOptionPane.showMessageDialog(null, "Cliente 1: " + c1.getCliente() + "\nSaldo: " + c1.getSaldo());
                        } else {
                            JOptionPane.showMessageDialog(null, "Senha Invalida!");
                        }
                    } else {
                        JOptionPane.showMessageDialog(null, "Conta Invalida!");
                    }
                    break;
                case 2: //cliente c2
                    conta = JOptionPane.showInputDialog("Conta::");
                    if (conta.equals(c2.getNConta())) {
                        senha = JOptionPane.showInputDialog("Senha:");
                        if (senha.equals(c2.getSenha())) {
                            //Saida
                            JOptionPane.showMessageDialog(null, "Cliente 1: " + c2.getCliente() + "\nSaldo: " + c2.getSaldo());
                        } else {
                            JOptionPane.showMessageDialog(null, "Senha Invalida!");
                        }
                    } else {
                        JOptionPane.showMessageDialog(null, "Conta Invalida!");
                    }
                    break;
                case 3: //sair
                    //Saida
                    JOptionPane.showMessageDialog(null, "fechando o programa...");
                    break;
                default:
                    //Saida
                    JOptionPane.showMessageDialog(null, "Opcao invalida!");
            } //fim do switch
        } while (opcao != 3);

    } //fim do main
} //fim da classe MConta

/*--------------------------------------------------------------------------------------------------------
 * Código do pacote br.com.thiago.dominio - Classe Conta
 --------------------------------------------------------------------------------------------------------*/


package br.com.thiago.dominio;

/**
 *
 * @author Thiago
 */
public class Conta {
    //variaveis
    private String cliente;
    private String cpf;
    private String senha;
    private String nConta;
    private double saldo;
   
    //set e get da variavel cliente
    public void setCliente(String c){
        cliente = c;
    }
    public String getCliente(){
        return cliente;
    }
    //set e get da variavel cpf
    public void setCpf(String cpf){
        this.cpf = cpf;
    }
    public String getCpf(){
        return cpf;
    }
    //set e get da variavel senha
    public void setSenha(String senha){
        this.senha = senha;
    }
    public String getSenha(){
        return senha;
    }
    //set e get da variavel conta
    public void setNConta(String nConta){
        this.nConta = nConta;
    }
    public String getNConta(){
        return nConta;
    }
    //set e get da variavel saldo
    public void setSaldo(double saldo){
        this.saldo = saldo;
    }
    public double getSaldo(){
        return saldo;
    }
} //fim da classe Conta


terça-feira, 18 de setembro de 2012

Código Java escrito em Classes distintas.

Exemplo simples de um programa em Java que recebe informações sobre um time e os exibe posteriormente. Código escrito em Classes diferente. (Get e Set)

Código Java
//Autor: Thiago Campos
//Data: 19.09.2012


/*---------------------------------------------------------------------------------------------------------
 *  Inicio da Classe ExemploTimeFutebol  que possui o main
---------------------------------------------------------------------------------------------------------*/
package br.com.unirn.main;

import javax.swing.JOptionPane;
import br.com.unirn.dominio.TimeFutebol;

/**
 *
 * @author Thiago
 */
public class ExemploTimeFutebol {

    public static void main(String[] args) {
        //variaveis 
        String nome;
        String cidade;
        String simbolo;
        String serie;
       
        //instanciando os objetos
        TimeFutebol time = new TimeFutebol();
        TimeFutebol time2 = new TimeFutebol();

        //entrada dos dados
        nome = JOptionPane.showInputDialog("Nome:");
        cidade = JOptionPane.showInputDialog("Cidade:");
        simbolo = JOptionPane.showInputDialog("Simbolo:");
        serie = JOptionPane.showInputDialog("Serie:");

        //setando os valores
        time.setNome(nome);
        time.setCidade(cidade);
        time.setSimbolo(simbolo);
        time.setSerie(serie);
       
        //retorno exibir
        time.exibirTime(); //Chamando o metodo
       
        //set automatico
        time2.setNome("ABC");
        time2.setCidade("Brasil");
        time2.setSimbolo("Escudo");
        time2.setSerie("A");
       
        //exemplo de saida
        JOptionPane.showMessageDialog(null, "Time: " + time.getNome() + " Serie: " + time.getSerie()  + "\nTime2: "+ time2.getNome() + " Serie2: " + time2.getSerie());
       
    } //fim do main
} //fim da classe ExemploTimeFutebol


/*---------------------------------------------------------------------------------------------------------
 * Inicio da Classe TimeFutebol  onde estão os get e set
--------------------------------------------------------------------------------------------------------- */
package br.com.unirn.dominio;

import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class TimeFutebol {
    //variaveis
    private String nome;
    private String cidade;
    private String simbolo;
    private String serie;

    //inicio dos set e get
    public String getCidade() {
        return cidade;
    }

    public void setCidade(String cidade) {
        this.cidade = cidade;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getSerie() {
        return serie;
    }

    public void setSerie(String serie) {
        this.serie = serie;
    }

    public String getSimbolo() {
        return simbolo;
    }

    public void setSimbolo(String simbolo) {
        this.simbolo = simbolo;
    }

    public void exibirTime() {
        String info = "Nome: " + nome
                + " \nCidade: " + cidade
                + "\nSimbolo: " + simbolo
                + " \nSerie: " + serie;

        JOptionPane.showMessageDialog(null, info);
    } //fim da função exibirTime  
} //fim da classe TimeFutebol


Programa Java com códigos em Classes diferentes.

Elabore um programa que calcule o volume da esfera, do cilindro, do cone e de um quadrado usando classes diferentes (faça uso dos get e set).

Código Java
/*----------------------------------------------------------------------------------------------------------
*                       A Classe MVolumes  está dentro do pacote br.com.thiago.main
-----------------------------------------------------------------------------------------------------------*/

//Autor: Thiago Campos
//Data: 19.09.2012

package br.com.thiago.main; //nome do pacote

/**
 *
 * @author Thiago
 */
import br.com.thiago.dominio.ClasseVolume;
import javax.swing.JOptionPane;

public class MVolumes {

    public static void main(String[] args) {
        //variaveis
        double raio;
        double altura;
        int opcao;

        //instanciando objeto
        ClasseVolume volume = new ClasseVolume();

        //escola do menu
        opcao = Integer.parseInt(JOptionPane.showInputDialog("Escolha a figura geometrica para calcula  o volume:"
                + "\n1 - Esfera"
                + "\n2 - Cilindro"
                + "\n3 - Cone"
                + "\n4 - Quadrado"));

        switch (opcao) {
            case 1: //volume da esfera
                raio = Double.parseDouble(JOptionPane.showInputDialog("Informe o raio da esfera:"));

                //envio do valor - set
                volume.setRaio(raio);

                // saida
                JOptionPane.showMessageDialog(null, "Volume: " + volume.esfera(raio));
                break;
            case 2: //volume do cilindro
                raio = Double.parseDouble(JOptionPane.showInputDialog("Informe o raio do cilindro:"));
                altura = Double.parseDouble(JOptionPane.showInputDialog("Informe a altura do cilindro:"));

                //envio do valor - set
                volume.setRaio(raio);
                volume.setAltura(altura);

                // saida
                JOptionPane.showMessageDialog(null, "Volume: " + volume.cilindro());
                break;
            case 3: //volume do cone
                raio = Double.parseDouble(JOptionPane.showInputDialog("Informe o raio do cone:"));
                altura = Double.parseDouble(JOptionPane.showInputDialog("Informe a altura do cone:"));

                //envio do valor - set
                volume.setRaio(raio);
                volume.setAltura(altura);

                // saida
                JOptionPane.showMessageDialog(null, "Volume: " + volume.cone());
                break;
            case 4: //volume do quadrado
                raio = Double.parseDouble(JOptionPane.showInputDialog("Informe o lado do quadrado:"));

                //envio do valor - set
                volume.setRaio(raio);

                // saida
                JOptionPane.showMessageDialog(null, "Volume: " + volume.quadrado());
                break;

            default:
                JOptionPane.showMessageDialog(null, "Opção invalida!");
                break;
        } //fim do switch
    } //fim do main
} //fim da classeMVolume


/*----------------------------------------------------------------------------------------------------------
*            A Classe ClasseVolume está dentro do pacote br.com.thiago.dominio
-----------------------------------------------------------------------------------------------------------*/

package br.com.thiago.dominio; //nome do pacote

/**
 *
 * @author Thiago
 */
import javax.swing.JOptionPane;

public class ClasseVolume {
    //variaveis
    double volume = 0;
    double raio;
    double altura;

    //Criando os Sets
    public void setRaio(double r) {
        raio = r;
    }

    public void setAltura(double h) {
        altura = h;
    }

    //criando os Gets
    public double getRaio() {
        return raio;
    }

    public double getAltura() {
        return altura;
    }

    //processamento da classe (funçoes)
     //inicio da função que calcula o volume da esfera
    public double esfera(double r) {
        volume = (4 / 3) * Math.PI * Math.pow(raio, 3); //form do volume da esfera
        return volume;

    }

     //inicio da função que calcula o volume do cilindro
    public double cilindro() {
        volume = Math.PI * Math.pow(raio, 2) * altura;
        return volume;
    }

     //inicio da função que calcula o volume do cone
    public double cone() {
        volume = (1 / 3) * Math.PI * Math.pow(raio, 2) * altura;
        return volume;
    }
 
    //inicio da função que calcula o volume do quadrado
    public double quadrado() {
        volume = Math.pow(raio, 3);
        return volume;
    }
} //fim da classe ClasseVolume



sexta-feira, 14 de setembro de 2012

Vetores - Exercício 1


Considere um vetor de 10 números inteiros positivos maiores que zero e um único número X inteiro,também positivo e maior que zero. Faça um programa para:
  (a) ler pelo teclado o vetor;
  (b) ler pelo teclado o número X;
  (c) verificar se o vetor está em ordem crescente, decrescente ou não ordenado;
  (d) dizer quantos números no vetor são maiores que X, menores que X e iguais a X.


Código Java

//Autor: Thiago Campos
//Data: 14.09.2012

package br.campos.thiago.Lista;

import javax.swing.JOptionPane;

/**
 *
 * @author Thiago
 */
public class vetor1 {
    public static void main(String[] args){
    //variaveis
    int k=10;
    int[] vetor = new int[k];
    int x, aux=0;
    int contM = 0; //vai contar qtos valores são maiores do q o num verificador
    int contMe = 0; //vai contar qtos valores são menores do q o num verificador
    int contI = 0; //vai contar qtos valores são iguais ao num verificador
    String maior = ""; //vai guardar os valores maior que o numero verificador
    String menor = ""; //vai guardar os valores menor que o numero verificador
    String igual = ""; //vai guardar os valores igual ao numero verificador
    String ordem = ""; //vai guardar Crescente ou Decrescente
    String seqAtual = ""; //vai guardar a sequencia na ordem digitada
    String seqOrd = ""; //vai guardar a sequencia ordem crescente
   
    //entrada de dados
        for (int i = 0; i < k; i++) {
            vetor[i] = Integer.parseInt(JOptionPane.showInputDialog("Informe um numero:"));  
        }
        //numero verificador
        x = Integer.parseInt(JOptionPane.showInputDialog("Informeo numero verificador:"));
       
        //processo de verificação com relação ao numero verificador
        for (int i = 0; i < k; i++) {
            if(vetor[i] > x){
                maior += vetor[i] + " ";
                contM++;
            }
            if(vetor[i] < x){
                menor += vetor[i] + " ";
                contMe++;
            }
            if(vetor[i] == x){
                igual += vetor[i] + " ";
                contI++;
            }
        } //fim do for
       
        //processo de verificação se o vetor está em ordem cresc ou decresc
        for (int i = 0; i < k; i++) {
            for (int j = i; j < k; j++) {
                if(vetor[i] > vetor[j]){
                    ordem = "Decrescente";
                } //fim do if
                if(vetor[i] < vetor[j]){
                    ordem = "Crescente";
                } else{
                    ordem = "Não ordenado";
                    break;
                }
            } //fim do for j 
            seqAtual += vetor[i] + " ";
        } //fim do for i
       
        //processo que ordena de forma crescente
        for (int i = 0; i < k; i++) {
            for (int j = i; j < k; j++) {
                if(vetor[i] > vetor[j]){
                    aux = vetor[i];
                    vetor[i] = vetor[j];
                    vetor[j] = aux;
                } //fim do if
            } //fim do for j  
            seqOrd += vetor[i] + " ";
        } //fim do for i
       
        //saida dos dados
        JOptionPane.showMessageDialog(null, "A sequencia está em ordem " + ordem
                + "\nA sequencia digitada foi: " + seqAtual
                + "\nA sequencia Ordenada é: " + seqOrd
                + "\nExistem " + contM + " valor(es) maior(es) do que " + x
                + " ( " + maior + " )"
                + "\nExistem " + contMe + " valor(es) menor(es) do que " + x
                + " ( " + menor + " )"
                + "\nExistem " + contI + " valor(es) igual(is) a " + x
                + " ( " + igual + " )");
    } //fim do main
   
} //fim da classe