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)

terça-feira, 26 de novembro de 2013

Usando a classe de entrada BufferedReader - JAVA

Utilizando a classe BufferedReader para a entrada dos dados, elabore um programa que calcule a área de um triângulo retângulo. Utilize o try catch para evitar erros de processamento ocasionados por entradas inválidas. O usuário deverá fornecer o valores da base e da altura do triângulo retângulo.

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


public class Exercio1Pg46BufferedReader {
    public static void main(String args[]) {
        //Declaração de variaveis
        String s = "";
        float base = 0;
        float altura = 0;
        float area = 0;
       
        BufferedReader dado; //declarando objeto dado
       
        //Entrada de dados
        try { //mecanismo de validação das entradas
            System.out.println("Entre com o valor da base do triângulo:");
            dado = new BufferedReader(new InputStreamReader(System.in));
            s = dado.readLine();
            base = Float.parseFloat(s);
           
            System.out.println("Entre com o valor da altura do triângulo:");
            dado = new BufferedReader(new InputStreamReader(System.in));
            s = dado.readLine();
            altura = Float.parseFloat(s);
           
            //Calculo
            area = base * altura/2;
           
            //Saida caso as entradas estejam corretas
            System.out.println("A área do triângulo retângulo é " + area);
        } //fim do try
        catch(IOException erro){
            System.out.println("Houve erro na entrada dos dados " + erro.toString());
        } //fim do catch
        catch(NumberFormatException erro){
            System.out.println("Houve erro de conversão, digite apenas caracteres numéricos" + erro.toString());
        } //fim do catch      
    } //fim do main

} //fim da classe


Usando a classe de entrada DataInputStream - JAVA

Utilizando a classe DataInputStream para a entrada dos dados, elabore um programa que calcule a média de duas notas de um aluno. Utilize também o "try... catch..." para evitar erros de processamento devido a entrada de dados inválidos.

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

import java.io.DataInputStream;
import java.io.IOException;

public class EntradaComDadosInputStream {
    public static void main(String args[]){
        //Declarando variaveis
        String s="";
        float nota1=0;
        float nota2=0;
        float media=0;
       
        DataInputStream dado; //Declaração do objeto
       
        //Entrada de dados
        try {
            System.out.println("Entre com a nota 1:");
            dado = new DataInputStream(System.in); //recebe a entrada
            s = dado.readLine(); //recebe o conteudo texto do objeto dado
            nota1 = Float.parseFloat(s); //converte a variavel s no tipo float
           
            System.out.println("Entre com a nota 2:");
            dado = new DataInputStream(System.in);
            s = dado.readLine();
            nota2 = Float.parseFloat(s);
           
            //Processamento
            media = (nota1 + nota2)/2;
           
            //Saida dos dados
            System.out.println("Media " + media);
           
        } //fim do try
       
        catch (IOException erro){
            //Saida dos dados
            System.out.println("Houve erro na entrada dos dados" + erro.toString());
        } //fim do catch ERRO
       
        catch (NumberFormatException erro) {
            //Saida dos dados
            System.out.println("Houve erro de conversão, digite apenas caracteres numericos" + erro.toString());
        } //fim do catch ERRO
              
    } //fim da main
   

} //fim da classe

segunda-feira, 25 de novembro de 2013

Uso simples do uso do "if": Exemplo

Mostra um exemplo simples do uso do "if" sem a presença do else. Neste exemplo, o usuário de uma classe fornece uma letra (S ou N) e o programa deverá apresentar uma tela informando "Letra Fornecida!" caso contrario " X É invalida".

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

import javax.swing.JOptionPane;

public class UsodoIf {
    public static void main (String[] args) {
        //Declaranção das variaveis
        String resposta;
        String mensagem;
       
        //Entrada dos dados
        resposta = JOptionPane.showInputDialog("Forneça a resposta: "
                + "\n S para sim"
                + "\n N para não");
       
        mensagem = "Letra fornecida: " + resposta;
       
        //Processamento dos dados
        if (!resposta.equalsIgnoreCase("S") && !resposta.equalsIgnoreCase("N")) {
            mensagem = mensagem + " é invalida!";
        } //Fim do if
       
        //Saida dos dados
        JOptionPane.showMessageDialog(null, mensagem);
       
        //Finaliza programa
        System.exit(0);
    } //fim do main

} //fim da classe

domingo, 17 de março de 2013

Métodos inserir, remover, tamanho e imprimir numa lista duplamente encadeada.

Pessoal, continuando... disponibilizo os meus métodos tamanho, imprimir, remover e inserir numa lista duplamente encadeada.

    public int tamanho(){ //esse metodo vai retornar a qtd de elementos da lista
        Usuario temp = primeiro;        
        int totalElementos = 0;
        //vai percorrer e incrementar a variavel totalElementos
        while(temp != null){
            temp = temp.getProx();
            totalElementos++;
        }       
        return totalElementos;
    } //fim do metodo total


 public void imprimir() { //esse metodo vai imprimir os elementos da lista
        //variavel
        Usuario temp = primeiro; //crio a variavel
        //percorro a lista
        while (temp != null) { //Enqto a temp for != null           
            temp.imprimir(); //imprima
            temp = temp.getProx(); //temp receba o prox da fila
        }//fim do while               
    } //fim do metodo


 public void remove(int matricula) { //este metodo vai remover um elemento numa lista duplamente encadeada
        if (primeiro != null) { //se a lista não estiver vazia
            //se for remover o primeiro
            if (primeiro.getMatricula() == matricula) {
                this.primeiro = this.primeiro.getProx();
            } else {
                Usuario temp = primeiro.getProx();
                temp.setAnt(primeiro);
                //percorre a lista
                while (temp != null && temp.getMatricula() != matricula) {
                    temp = temp.getProx();
                }
                //se temp for diferente de null é pq encontrou mat =
                if (temp != null) {
                    temp.getAnt().setProx(temp.getProx());
                    temp.getProx().setAnt(temp.getAnt());
                } //fim do if
            } //fim do else
        } //fim do if
    } //fim do metodo remova


public void inserir(int pos, Usuario novo){
        Usuario temp = primeiro;
        int posicao = 0;
        int tamanho = tamanho(); // metodo que retorna o tamanho da lista
       
        if(temp == null){
            novo.setAnt(null);
            novo.setProx(null);
            primeiro = novo;
        } else if (pos > -1 && pos <= tamanho) {
            while (temp.getProx() != null && pos != posicao) { //temp.getProx() != null pq temp nao pode ser null
                posicao++; //incrementa a posição
                temp = temp.getProx();
            } //fim do while
            if (pos == 0) { //inserir na primeira posição
                novo.setProx(temp);
                novo.setAnt(null);
                temp.setAnt(novo);
                primeiro = novo;
            } else if (pos < tamanho) { //inseri em qualquer posição
                novo.setProx(temp);
                novo.setAnt(temp.getAnt());
                temp.getAnt().setProx(novo);
                temp.setAnt(novo);
            } else { //inseri na ultima posição
                novo.setAnt(temp);
                novo.setProx(null);
                temp.setProx(novo);
            }
        } else {
            System.out.println("Posição invalida!");
        }
    } //final do metodo inserir

quinta-feira, 7 de março de 2013

Método inserir(int pos, objeto novo) numa lista encadeada

Durante a criação desse método, muitas dúvidas sugiram e mesmo pesquisando na internet, não encontrei nenhuma solução simples que me ajudasse efetivamente, alguns amigos me tiraram dúvidas, e até me sugeriram novas rotas para chegar ao resultado. Deu certo, valeu João e Flávio.
 
Ah! Antes que digam que os meus métodos são simples, lembro a todos que sou estudante e ele é voltado para outros estudantes que buscaram justamente soluções simples na internet e só encontraram complexas. Daqui para frente fica mais dificil postar o código inteiro, disponibilizarei métodos e quando for possível, todos o código.
 
Este método abaixo permite o Usuário inserir um objeto em qualquer posição da lista encadeada. O códio foi escrito em Java e espero que ajude a outros estudantes durante sua caminhada.
 
    public void inserir(int pos, Objeto novo) {
        //obj
        Objeto temp = primeiro; //vai receber a lista
        Objeto anterior = null;
        //var
        int posicao = 0;
        int tamanho = tamanho();
 
        //Verifica se a lista está vazia       
        if (temp == null) {
            primeiro = novo;
        }

        //caso a lista não esteja vazia
        if (pos <= tamanho && pos > -1) { //vai garantir as margens
           
            while (posicao != pos) { //Percorre a lista
                anterior = temp; //guarda o anterior
                temp = temp.getProx(); //vai atribuir o proximo a temp
                posicao++; //incrementa a posição
            }
            //valido apenas para a primeira posição
            if (posicao == 0) { //se for para colocar na primeira posicao
                novo.setProx(temp);
                primeiro = novo;
                System.out.println("\nPOSIÇÃO 0");
            } else {
                    //valido para qualquer outra posição               
                    novo.setProx(temp); //o obj novo aponta para o atual
                    anterior.setProx(novo); //o obj anterior aponta para novo
                   
                    System.out.println("\nPOSIÇÃO " + pos);
            } //fim do elsE
        } else {System.out.println("\nPOSIÇÃO INVÁLIDA!");} //fim do else
    } //fim do metodo inserir

quarta-feira, 20 de fevereiro de 2013

Exemplo de código Java utilizando herança e vetores

Crie o um sisteminha que realize as operações de adicionar, excluir, localizar e imprimir para o professor e aluno segundo os criterios abaixos: (Utilizando vetor e herança)
  • Professor: nome; matricula; endereco; especialidade; curso;
  • Aluno: nome; matricula; endereco; notas (vetor de notas);

Código Java
//Aluno; Thiago Campos
//Data: 18.02.13


/*
 * CLASSE PAI
 */

/**
 *
 * @author Thiago
 */

public class Pessoa {
    //Variaveis
    private String nome;
    private String endereco;
    private int matricula;
   
    //Construtor
    public Pessoa(int matricula, String nome, String endereco){
        this.nome = nome;
        this.endereco = endereco;
        this.matricula = matricula;
    }
   
    //Geteres e seteres
    public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }
    public String getEndereco() {
        return endereco;
    }
    public void setEndereco(String endereco) {
        this.endereco = endereco;
    }
   
    public int getMatricula(){
        return matricula;
    }
    public void setMatricula(int matricula){
        this.matricula = matricula;
    }
   
    //equals
    public boolean equals(Object obj){
        return this.matricula == ((Pessoa)obj).getMatricula();
    }  
} //Fim da classe

/*
 * CLASSE FILHA
 */

/**
 *
 * @author Thiago
 */

public class Professor extends Pessoa{
    //variaveis
    private String especialidade;
    private String curso;
   
    //Construtor
    public Professor(int matricula, String nome, String endereco, String especialidade, String curso){
        super(matricula, nome, endereco); //informo que esses paramentros vão para o pai
        this.especialidade = especialidade;
        this.curso = curso;
    }
   
    //geteres e seteres
    public String getEspecialidade() {
        return especialidade;
    }
    public void setEspecialidade(String especialidade) {
        this.especialidade = especialidade;
    }
    public String getCurso() {
        return curso;
    }
    public void setCurso(String curso) {
        this.curso = curso;
    }
} //fim da classe Professor
/*
 * CLASSE FILHA
 */

/**
 *
 * @author Thiago
 */

public class Aluno extends Pessoa{
    //variaveis
    private float[] notas = new float[2]; //intanciar
   
    //construtor
    public Aluno(int matricula, String nome, String endereco, float[] notas){
        super(matricula, nome, endereco); //chamando as qualidades do Pai
        //receber as notas
        for(int i=0; i<2; i++){
            this.notas[i]= notas[i];
        } //fim do for 
       
    } //fim do construtor
   
    //geteres e seteres
    public float[] getNotas() {
        return notas;
    }
    public void setNotas(float[] notas) {
        this.notas = notas;
    }
   
} //Fim da classe Aluno
/*
 * CLASSE DOS MÉTODOS DO PROFESSOR
 */

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

public class Aula2MP {
    private final int k = 100; //criando uma constate para ser utilizada nos Arrays
    private int posProf= 0; //posicao a ser oculpado no Array Professor
   
    //Variaveis relacionadas ao Professor
    private int[] profMat = new int[k]; //instanciando os Arrays
    private String[] profNom = new String[k];
    private String[] profEnd = new String[k];
    private String[] especialidade = new String[k];
    private String[] curso = new String[k];
   
    /**
     * Metodo que insere um novo professor no Array
     * @param matricula
     * @param nome
     * @param endereco
     * @param especialidade
     * @param curso
     */

    public void inserirProfessor(int matricula, String nome, String endereco, String especialidade, String curso){
        if(posProf < k){
            this.profMat[this.posProf] = matricula;
            this.profNom[this.posProf] = nome;
            this.profEnd[this.posProf] = endereco;
            this.especialidade[this.posProf] = especialidade;
            this.curso[this.posProf] = curso;
            this.posProf++;
        } else {
            JOptionPane.showMessageDialog(null, "As vagas ja se encerraram.");
        }
    } //fim do metodo inserir Professor
    /**
     * Metodo criado para remmover alunos do cadastro
     * @param matricula
     * @return
     */

    public String removerProf(int matricula) {
        //criação de variaveis temporarias
        int objMat = matricula;
        String objNom = null;
        String objEnd = null;
        String objEsp = null;
        String objCur = null;
       
        int pos = posicaoProf(matricula); //esta variavel guarda a posição do cadastro no vetor
       
        if (pos >= 0){ //se a posição retornada for >= a zero, ele guarda os dados que serão apagados
            objMat = this.profMat[posProf];
            objNom = this.profNom[posProf];
            objEnd = this.profEnd[posProf];
            objEsp = this.especialidade[posProf];
            objCur = this.curso[posProf];
           
            //o for vai deslocar os dados para esquerda, preenchendo os espaçõs vazios
            for (int i=pos; i<this.posProf-1;i++){
                this.profMat[i] = this.profMat[i+1];
                this.profNom[i] = this.profNom[i+1];
                this.profEnd[i] = this.profEnd[i+1];
                this.especialidade[i] = this.especialidade[i+1];
                this.curso[i] = this.curso[i+1];
            } //fim do for
           
            //estes comandos vão apagar os dados da ultima posição uma vez que houve deslocamento
            this.profMat[this.posProf-1] = 0;
            this.profNom[this.posProf-1] = null;
            this.profEnd[this.posProf-1] = null;
            this.especialidade[this.posProf-1] = null;
            this.curso[this.posProf-1] = null;
            this.posProf--;
           
            return objNom; //vai retornar o nome do aluno
        } else {
            System.out.println("Professor não encontrado!!!");           
            return null;
        }
    } //fim do metodo apagar
  
    /**
     * Imprimie a lista de alunos em ordem de matricul.
     */

        public void imprima() {
        this.ordenarProf();
        for (int i = 0; i < posProf; i++) {
            System.out.println("Matricula: " + profMat[i]
                    + " | Nome: " + profNom[i]
                    + " | Endereço: " + profEnd[i]
                    + " | Especialidade: " + especialidade[i]
                    + " | Curso: " + curso[i]);
        } //fim do for
    } //fim do metodo imprima
    /**
     * Metodo que vai identificar a posição da ultima entrada
     * @param matricula
     * @return
     */

    private int posicaoProf(int matricula){
        for (int i = 0; i < this.posProf; i++){
            if (matricula == this.profMat[i]){
                return i;
            }
        } //fim do for
       
        System.out.println("Professor não encontrado!!!");
        return -1; //retornando -1
    } //fim do metodo posicao
   
    private void ordenarProf(){
        quick_sort(profMat, profNom, profEnd, especialidade,curso, 0, posProf-1);
    } //fim do metodo ordenar professor
   
   
    /**
     * Variaveis do metodo quick_sort
     * @param m - matricula do prof
     * @param n - nome do prof
     * @param e - endereço do prof
     * @param s - especialidade do prof
     * @param c - curso do prof
     * @param ini - inicio do vetor
     * @param fim - fim do vetor
     */

    private void quick_sort(int[] m, String[] n, String[] e, String[] s, String[] c, int ini, int fim){
        int meio;
       
        if(ini <fim){
            meio = partition(m, n, e, s, c, ini, fim);
            quick_sort(m, n, e, s, c, ini, meio);
            quick_sort(m, n, e, s, c, meio +1, ini);
        }
    } //fim do metodo quick_sort
   
    /**
     * Variaveis do metodo quick_sort
     * @param m - matricula do prof
     * @param n - nome do prof
     * @param e - endereço do prof
     * @param s - especialidade do prof
     * @param c - curso do prof
     * @param ini - inicio do vetor
     * @param fim - fim do vetor
     * @return
     */

    private int partition(int[] m, String[] n, String[] e, String[] s, String[] c, int ini, int fim) {
        int topo, i, pivoM;
        String pivoN, pivoE, pivoS, pivoC;
        pivoM = m[ini];
        pivoN = n[ini];
        pivoE = e[ini];
        pivoS = s[ini];
        pivoC = c[ini];
        topo = ini;
        for (i = ini + 1; i <= fim; i++) {
            if (m[i] < pivoM) {
                m[topo] = m[i];
                n[topo] = n[i];
                e[topo] = e[i];
                s[topo] = s[i];
                c[topo] = c[i];
                m[i] = m[topo + 1];
                n[i] = n[topo + 1];
                e[i] = e[topo + 1];
                s[i] = s[topo + 1];
                c[i] = c[topo + 1];
                topo++;
            } //fim do if        
        } //fim do for
        m[topo] = pivoM;
        n[topo] = pivoN;
        e[topo] = pivoE;
        s[topo] = pivoS;
        c[topo] = pivoC;
        return topo;
    } //fim do metodo
   
} //fim da classe

/*
 * CLASSE DOS MÉTODOS DO ALUNO
 */

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

public class Aula2MA {
    private final int k = 100; //criando uma constate para ser utilizada nos Arrays
    private int posAlu= 0; //posicao a ser oculpado no Array Aluno
   
    //Variaveis relacionadas ao aluno
    private int[] alunoMat = new int[k]; //instanciando os Arrays
    private String[] alunoNom = new String[k];
    private String[] alunoEnd = new String[k];
    private float[] nota1 = new float[k];
    private float[] nota2 = new float[k];
   
    /**
     * Metodo que insere um novo aluno no Array
     * @param matricula
     * @param nome
     * @param endereco
     * @param nota1
     * @param nota2
     */

    public void inserirAluno(int matricula, String nome, String endereco, float nota1, float nota2){
        if(posAlu < k){
            this.alunoMat[this.posAlu] = matricula;
            this.alunoNom[this.posAlu] = nome;
            this.alunoEnd[this.posAlu] = endereco;
            this.nota1[this.posAlu] = nota1;
            this.nota2[this.posAlu] = nota2;
            this.posAlu++; //informo que a posição foi oculpada e passo para a seguinte
           
        } else {
            JOptionPane.showMessageDialog(null, "As vagas ja se encerraram.");
        }
    } //fim do metodo inserirAluno
  
    /**
     * Metodo criado para remmover alunos do cadastro
     * @param matricula
     * @return
     */

    public String removerAluno(int matricula){
        //criação de variaveis temporarias
        int objMat = matricula;
        String objNom = null;
        String objEnd = null;
        float objN1 = 0;
        float objN2 = 0;
       
        int pos = posicaoAlu(matricula); //esta variavel guarda a posição do cadastro no vetor
       
        if (pos >= 0){ //se a posição retornada for >= a zero, ele guarda os dados que serão apagados
            objMat = this.alunoMat[posAlu];
            objNom = this.alunoNom[posAlu];
            objEnd = this.alunoEnd[posAlu];
            objN1 = this.nota1[posAlu];
            objN2 = this.nota2[posAlu];
           
            //o for vai deslocar os dados para esquerda, preenchendo os espaçõs vazios
            for (int i=pos; i<this.posAlu-1;i++){
                this.alunoMat[i] = this.alunoMat[i+1];
                this.alunoNom[i] = this.alunoNom[i+1];
                this.alunoEnd[i] = this.alunoEnd[i+1];
                this.nota1[i] = this.nota1[i+1];
                this.nota2[i] = this.nota2[i+1];
            } //fim do for
           
            //estes comandos vão apagar os dados da ultima posição uma vez que houve deslocamento

            this.alunoMat[this.posAlu-1] = 0;
            this.alunoNom[this.posAlu-1] = null;
            this.alunoEnd[this.posAlu-1] = null;
            this.nota1[this.posAlu-1] = 0;
            this.nota2[this.posAlu-1] = 0;
            this.posAlu--;
           
            return objNom; //vai retornar o nome do aluno
        } else {
            System.out.println("Aluno não encontrado!!!");           
            return null;
        }
    } //fim do metodo apagar
   
    /**
     * Imprimie a lista de alunos em ordem de matricul.
     */

        public void imprima() {
        this.ordenarAlu();
        for (int i = 0; i < posAlu; i++) {
            System.out.println("Matricula: " + alunoMat[i]
                    + " | Nome: " + alunoNom[i]
                    + " | Endereço: " + alunoEnd[i]
                    + " | Especialidade: " + nota1[i]
                    + " | Curso: " + nota2[i]);
        } //fim do for
    } //fim do metodo imprima
       
    /**
     * Metodo que retorna a posição de oculpada
     * @param matricula
     * @return
     */

    private int posicaoAlu(int matricula){
        for (int i = 0; i < this.posAlu; i++){
            if (matricula == this.alunoMat[i]){
                return i;
            }
        } //fim do for
       
        JOptionPane.showMessageDialog(null, "Aluno não encontrado!!!");
        return -1; //retornando -1
    } //fim do metodo posicao    
   
    private void ordenarAlu(){
        quick_sort(alunoMat, alunoNom, alunoEnd, nota1, nota2, 0, posAlu-1);
    } //fim do metodo ordenar alunos
   
    /**
     * Variaveis do metodo quick_sort
     * @param m - matricula do aluno
     * @param n - nome do aluno
     * @param e - endereço do aluno
     * @param s - especialidade do aluno
     * @param c - curso do aluno
     * @param ini - inicio do vetor
     * @param fim - fim do vetor
     */      
  
  private void quick_sort(int[] m, String[] n, String[] e, float[] nota1, float[] nota2, int ini, int fim){
        int meio;
       
        if(ini < fim){
            meio = partition(m, n, e, nota1, nota2, ini, fim);
            quick_sort(m, n, e,  nota1, nota2, ini, meio);
            quick_sort(m, n, e,  nota1, nota2, meio+1, ini);
        }
    } //fim do metodo quick_sort
    private int partition(int[] m, String[] n, String[] e, float[] n1, float[] n2, int ini, int fim) {
        int topo, i, pivoM;
        String pivoN, pivoE;
        float pivoN1, pivoN2; //pivo ref as notas
        pivoM = m[ini];
        pivoN = n[ini];
        pivoE = e[ini];
        pivoN1 = n1[ini];
        pivoN2 = n2[ini];
        topo = ini;
        for (i = ini + 1; i <= fim; i++) {
            if (m[i] < pivoM) {
                m[topo] = m[i];
                n[topo] = n[i];
                e[topo] = e[i];
                n1[topo] = n1[i];
                n2[topo] = n2[i];
                m[i] = m[topo + 1];
                n[i] = n[topo + 1];
                e[i] = e[topo + 1];
                n1[i] = n1[topo + 1];
                n2[i] = n2[topo + 1];
                topo++;
            } //fim do if       
        } //fim do for
        m[topo] = pivoM;
        n[topo] = pivoN;
        e[topo] = pivoE;
        n1[topo] = pivoN1;
        n2[topo] = pivoN2;
        return topo;
    } //fim do metodo
   
} //fim da classe

/*
 * CLASSE EXECUTORA - CLASSE DO MAIN
 */


/**
 *
 * @author Thiago
 */

public class Main {
    public static void main(String[] args){
        //variaveis
        Aula2MP uniRN = new Aula2MP();
        Aula2MA uniRNA = new Aula2MA();
       
        uniRN.inserirProfessor(21, "Alexandre Luiz", "Av. Abel Cabral", "Java", "BSI");
        uniRN.inserirProfessor(1, "Luiz Damasceno", "Eng. Roberto Freire", "Algebra Linear", "Matematica");
        uniRN.inserirProfessor(41, "Joseane Sobral", "Rua do fim do canto", "Algoritimo", "BSI");
        uniRN.inserirProfessor(3, "Kaio Graco", "Rua das Pricesas", "Legislação", "Direito");
       
        uniRNA.inserirAluno(12, "Thiago Campos", "Rua Hercules", 10, 9);
        uniRNA.inserirAluno(1, "Luiz Carlos", "Rua D. Pedro II", 7, 8);
        uniRNA.inserirAluno(41, "Monica Silva", "Rua do Bosque", 6, 5);
        uniRNA.inserirAluno(3, "Rafael Soares", "Av, das Palmeiras", 8, 10);
       
        System.out.println("Uni-RN: RELAÇÃO DE ALUNOS");
        uniRNA.imprima();
        uniRNA.removerAluno(1);
        System.out.println("Uni-RN");
        uniRNA.imprima();
       
        System.out.println("===================================");
       
        System.out.println("Uni-RN: RELAÇÃO DE ALUNOS");
        uniRN.imprima();
        uniRN.removerProf(1);
        System.out.println("Uni-RN");
        uniRN.imprima();  
    } //Fim do main
} //fim da classe



sexta-feira, 15 de fevereiro de 2013

Uso do operador ternário condicional "?:".

Escreva um programa Java que permita determinar qual o valor máximo existente em um vetor do tipo float com 10 elementos. Utilize como estrutura de controle for.
 
Código Java
//Autor: Thiago Campos
//Data: 15.02.13


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

public class Vetor {
    /**
     * @param args the command line arguments
     */

    public static void main(String[] args) {
        // Declaração de variaveis
        float[] vetor = new float[10];
        float vetorMaior = 0;
       
        //inicializando o vetor
        vetor[0] = 2;
        vetor[1] = 3;
        vetor[2] = 8;
        vetor[3] = 5;
        vetor[4] = 1;
        vetor[5] = 2;
        vetor[6] = 4;
        vetor[7] = 9;
        vetor[8] = 7;
        vetor[9] = 0;
       
        //processamento
        vetorMaior = vetor[0];
        for (int i=0; i<vetor.length; i++){
            vetorMaior = vetorMaior > vetor[i] ? vetorMaior:vetor[i]; //outra forma de usar uma codição          
        } //fim do for
       
        //saida na janela
        JOptionPane.showMessageDialog(null, "O vetor máximo é: " + vetorMaior);
       
    } //fim do main
} //fim da classe