Apostila - Linguagem de Programação I

    Olá, galera!

    Estou postando aqui no blog a apostila da disciplina Linguagem de Programação I. Esta apostila sofrerá algumas alterações até o final da disciplina, a fim de comportar todo o conteúdo visto em sala de aula. Abraço!

Listas (parte 2 de 3)

    Olá, galera!

    Esta é a segunda e penúltima aula sobre listas que veremos na disciplina Estruturas de Dados. O conteúdo dela é bem interessante, pois ensina a criar uma lista encadeada genérica e também mostra o uso da interface List do pacote java.util. Abraço!




Classe NoGenerico

package br.edu.ifms.aula;

/**
 * Nó da lista genérica.
 * 
 * @author Prof.º Sidney
 * 
 */
public class NoGenerico<T> {

 /**
  * O valor do item armazenado.
  */
 private T item;

 /**
  * Ponteiro para o próximo item da lista.
  */
 private NoGenerico<T> proximoItem;

 /**
  * Construtor da classe No.
  */
 public NoGenerico() {
  proximoItem = null;
 }

 /**
  * Getter para o atributo <b>item</b>.
  * 
  * @return O valor do atributo <b>item</b>.
  */
 public T getItem() {
  return item;
 }

 /**
  * Setter para o atributo <b>item</b>.
  * 
  * @param item
  *            O novo valor para o atributo <b>item</b>.
  */
 public void setItem(T item) {
  this.item = item;
 }

 /**
  * Getter para o atributo <b>proximoItem</b>.
  * 
  * @return O valor do atributo <b>proximoItem</b>.
  */
 public NoGenerico<T> getProximoItem() {
  return proximoItem;
 }

 /**
  * Setter para o atributo <b>proximoItem</b>.
  * 
  * @param proximoItem
  *            O novo valor para o atributo <b>proximoItem</b>.
  */
 public void setProximoItem(NoGenerico<T> proximoItem) {
  this.proximoItem = proximoItem;
 }
}

Classe ListaEncadeadaGenerica

package br.edu.ifms.aula;

/**
 * Encapsula uma lista encadeada de inteiros.
 * 
 * @author Prof.º Sidney
 * 
 */
public class ListaEncadeadaGenerica<T> {

 /**
  * Tamanho da lista.
  */
 private int tamanho;

 /**
  * Primeiro item da lista.
  */
 private NoGenerico<T> primeiroItem;

 /**
  * Último item da lista.
  */
 private NoGenerico<T> ultimoItem;

 /**
  * Construtor para a classe {@link ListaEncadeada}. Inicializa os atributos
  * da classe.
  */
 public ListaEncadeadaGenerica() {
  primeiroItem = null;
  ultimoItem = null;
  tamanho = 0;
 }

 /**
  * Retorna o primeiro item da lista.
  * 
  * @return O primeiro item da lista.
  */
 public NoGenerico<T> pegaPrimeiroItem() {
  return primeiroItem;
 }

 /**
  * Retorna o último item da lista.
  * 
  * @return O último item da lista.
  */
 public NoGenerico<T> pegarUltimoItem() {
  return ultimoItem;
 }

 /**
  * Retorna o item situado na posição desejada.
  * 
  * @param posicao
  *            Posição do item a ser recuperado.
  * @return O item situado na posição desejada.
  */
 public NoGenerico<T> pegarItem(int posicao) {
  if (tamanho > 0 && posicao >= 1 && posicao <= tamanho) {
   NoGenerico<T> item = primeiroItem;
   int contador = 1;
   while (posicao < contador) {
    item = item.getProximoItem();
    contador++;
   }
   return item;
  }
  return null;
 }

 /**
  * Remove o elemento situado na posição desejada, caso esta posição exista
  * na lista.
  * 
  * @param posicao
  *            Posição do item a ser removido.
  * @return <b>true</b> caso o item existia na lista e assim foi removido com
  *         sucesso; <b>false</b> c.c.
  */
 public boolean remover(int posicao) {
  if (tamanho > 0 && posicao >= 1 && posicao <= tamanho) {
   NoGenerico<T> item = primeiroItem;
   NoGenerico<T> anterior = null;
   int contador = 1;
   while (contador < posicao) {
    anterior = item;
    item = item.getProximoItem();
    contador++;
   }
   NoGenerico<T> proximo = item.getProximoItem();
   if (anterior != null) {
    anterior.setProximoItem(proximo);
   } else {
    primeiroItem = proximo;
   }
   tamanho--;
   if (tamanho <= 1) {
    primeiroItem = proximo;
    ultimoItem = primeiroItem;
   }
   return true;
  }
  return false;
 }

 /**
  * Adiciona um novo item no início da lista.
  * 
  * @param novoItem
  *            Novo item a ser adicionado.
  */
 public void adicionarNoInicio(T novoItem) {
  if (tamanho == 0) {
   primeiroItem = new NoGenerico<T>();
   primeiroItem.setItem(novoItem);
   ultimoItem = primeiroItem;
  } else {
   NoGenerico<T> antigoPrimeiroItem = primeiroItem;
   primeiroItem = new NoGenerico<T>();
   primeiroItem.setItem(novoItem);
   primeiroItem.setProximoItem(antigoPrimeiroItem);
  }
  tamanho++;
 }

 /**
  * Adiciona um novo item no final da lista.
  * 
  * @param novoItem
  *            Novo item a ser adicionado.
  */
 public void adicionarNoFinal(T novoItem) {
  if (tamanho == 0) {
   ultimoItem = new NoGenerico<T>();
   ultimoItem.setItem(novoItem);
   primeiroItem = ultimoItem;
  } else {
   NoGenerico<T> antigoUltimoItem = ultimoItem;
   ultimoItem = new NoGenerico<T>();
   ultimoItem.setItem(novoItem);
   antigoUltimoItem.setProximoItem(ultimoItem);
  }
  tamanho++;
 }

 /**
  * Adiciona um novo item na posição desejada na lista
  * 
  * @param novoItem
  *            Novo item a ser adicionado.
  * @param posicao
  *            Posição na qual o item deve ser adicionado. Caso o valor da
  *            posição seja menor que 1 ou maior que o valor de
  *            <b>tamanho</b> - 1, então o item não é adicionado.
  * @return <b>true</b> caso o item tenha sido adicionado com sucesso;
  *         <b>false</b> c.c.
  */
 public boolean adicionarNaPosicao(T novoItem, int posicao) {
  if (posicao >= 1 && posicao <= tamanho + 1) {
   if (posicao == 1) {
    adicionarNoInicio(novoItem);
   } else if (posicao == tamanho + 1) {
    adicionarNoFinal(novoItem);
   } else {
    NoGenerico<T> novoNo = new NoGenerico<T>();
    novoNo.setItem(novoItem);
    int contador = 1;
    NoGenerico<T> itemAnteriorAoNovo = primeiroItem;
    while (contador < posicao - 1) {
     itemAnteriorAoNovo = itemAnteriorAoNovo.getProximoItem();
     contador++;
    }
    novoNo.setProximoItem(itemAnteriorAoNovo.getProximoItem());
    itemAnteriorAoNovo.setProximoItem(novoNo);
    tamanho++;
   }
   return true;
  }
  return false;
 }
}

Classe ExemploList

package br.edu.ifms.aula;

import java.util.ArrayList;
import java.util.List;

public class ExemploList {

 public static void main(String[] args) {
  List<Integer> lista = new ArrayList<Integer>();
  // Se quiser, troque a linha acima pela linha abaixo
  // List<Integer> lista = new LinkedList<Integer>();
  // Lembre-se de importar a classe LinkedList:
  // import java.util.LinkedList;

  // Inserindo ítens no final da lista
  lista.add(12);
  lista.add(-38);
  lista.add(827);

  // Inserindo ítens no início da lista
  lista.add(0, 125);
  lista.add(0, -387);
  lista.add(0, 82735);

  List<Integer> listaExtra = new ArrayList<Integer>();
  listaExtra.add(11);
  listaExtra.add(22);
  listaExtra.add(33);
  // Adiciona todos os ítens da lista extra no final da primeira lista
  lista.addAll(listaExtra);

  listaExtra.add(44);
  listaExtra.add(55);
  listaExtra.add(66);
  /**
   * Adiciona todos os ítens da lista extra na posição desejada da
   * primeira lista
   */
  lista.addAll(3, listaExtra);

  /**
   * Removendo ítens da lista pelo índice. Na interface List, os elementos
   * são indexados na forma [0..tamanho da lista - 1]
   */
  lista.remove(0);
  lista.remove(4);

  /**
   * Removendo um item da lista caso ele exista. O cast para Object é
   * necessário para que o compilador diferencie a chamada ao método de
   * remoção por ocorrência do método de remoção por índice. Retorna true
   * caso o item exista; false c.c.
   */
  lista.remove((Object) 77); // Retorna false

  // Verifica se um item está contido na lista
  if (lista.contains(12)) {
   System.out.println("A lista contém o item 12.");
  }

  // Imprime o índice da primeira ocorrência do item de valor 125
  System.out.println(lista.indexOf((Object) 125));

  // Verifica se a lista contém uma sublista
  if (lista.containsAll(listaExtra)) {
   System.out.println("A primeira lista contém a lista extra!");
  }

  // Substituindo o elemento da terceira posição da lista
  lista.set(3, 42);

  // Verifica se a lista está vazia
  if (lista.isEmpty()) {
   System.out.println("A lista está vazia.");
  } else {
   System.out.println("A lista contém " + lista.size()
     + " elemento(s).");
  }

  // Verifica a última ocorrência de um determinado valor na lista
  System.out.println("A última ocorrência de 55 se dá na posição "
    + lista.lastIndexOf(55));

  // Imprime o tamanho da lista
  System.out.println("Tamanho atual da lista: " + lista.size());

  /**
   * Pega uma parte da lista. O primeiro índice é inclusivo; o segundo é
   * exclusivo.
   */
  List<Integer> outraLista = lista.subList(2, 4);

  // Converte a lista de inteiros em um vetor de objetos
  Object[] vetor = lista.toArray();
  // Converte a lista de inteiros em um vetor de inteiros
  Integer[] vetorInteiros = new Integer[lista.size()];
  lista.toArray(vetorInteiros);
  for (Integer elemento : vetorInteiros) {
   System.out.println("Elemento: " + elemento);
  }

  /**
   * Listas do tipo List podem ser iteradas em laços for each.
   * 
   */
  for (Integer item : lista) {
   System.out.print(item + " ");
  }

  System.out.println();

  // Percorrendo a lista com um laço for comum
  for (int i = 0; i < lista.size(); i++) {
   System.out.print(lista.get(i) + " ");
  }

  System.out.println();

  // Remove todos os ítens da lista
  lista.clear();

  System.out.println("Tamanho atual da lista: " + lista.size());
 }
}

Introdução à Linguagem Python (aula 2)

    Olá, galera!

    Esta é a segunda parte do "mini-curso" sobre Python que estou publicando aqui no blog. Nesta aula, eu falo sobre comentários, strings, listas e dicionários. Abraço!

Listas (parte 1)

    Olá, galera!

    Nesta aula eu falo sobre listas simples e encadeadas, suas operações e o seu uso. Esta é a primeira de três aulas que exploram este assunto. Abraço!




Classe ListaSimples

package br.edu.ifms.aula;

/**
 * Encapsula uma lista simples de inteiros.
 * 
 * @author Prof.º Sidney
 * 
 */
public class ListaSimples {

	private int tamanho = 0;

	private Integer[] lista;

	/**
	 * Construtor da classe ListaSimples. Instancia a lista com o tamanho
	 * definido.
	 */
	public ListaSimples(int tamanho) {
		this.tamanho = tamanho;
		lista = new Integer[this.tamanho];
	}

	/**
	 * Adiciona um novo item na lista no índice desejado. Se já houver um item
	 * neste índice, ele será sobreposto.
	 * 
	 * @param novoItem
	 *            Item a ser adicionado.
	 * @param indiceDoItem
	 *            Índice do novo item.
	 * @return <b>true</b> caso o item tenha sido adicionado com sucesso;
	 *         <b>false</b> c.c.
	 */
	public boolean adicionarItem(Integer novoItem, int indiceDoItem) {
		if (indiceDoItem >= 0 && indiceDoItem < tamanho) {
			lista[indiceDoItem] = novoItem;
			return true;
		}
		return false;
	}

	/**
	 * Remove um item da lista.
	 * 
	 * @param indiceDoItem
	 *            Índice do item a ser removido.
	 * @return O valor do item. Retorna <b>null</b> caso a posição indicada
	 *         esteja vazia ou se o índice informado sejá inválido.
	 */
	public Integer removerItem(Integer indiceDoItem) {
		if (indiceDoItem >= 0 && indiceDoItem < tamanho
				&& lista[indiceDoItem] != null) {
			Integer itemRemovido = lista[indiceDoItem];
			lista[indiceDoItem] = null;
			return itemRemovido;
		}
		return null;
	}

	/**
	 * Retorna o item da lista situado no índice desejado.
	 * 
	 * @param indiceDoItem
	 *            Índice do item desejado.
	 * @return O item desejado. Retorna <b>null</b> caso a posição indicada
	 *         esteja vazia ou se o índice informado sejá inválido.
	 */
	public Integer pegarItem(Integer indiceDoItem) {
		if (indiceDoItem >= 0 && indiceDoItem < tamanho) {
			return lista[indiceDoItem];
		}
		return null;
	}

	public int tamanhoDaLista() {
		return tamanho;
	}

}

Classe No

package br.edu.ifms.aula;

/**
 * Nó da lista que armazena um valor inteiro.
 * 
 * @author Prof.º Sidney
 * 
 */
public class No {

	/**
	 * O valor do item armazenado.
	 */
	private Integer item;

	/**
	 * Ponteiro para o próximo item da lista.
	 */
	private No proximoItem;

	/**
	 * Construtor da classe No.
	 */
	public No() {
		proximoItem = null;
	}

	/**
	 * Getter para o atributo <b>item</b>.
	 * 
	 * @return O valor do atributo <b>item</b>.
	 */
	public Integer getItem() {
		return item;
	}

	/**
	 * Setter para o atributo <b>item</b>.
	 * 
	 * @param item
	 *            O novo valor para o atributo <b>item</b>.
	 */
	public void setItem(Integer item) {
		this.item = item;
	}

	/**
	 * Getter para o atributo <b>proximoItem</b>.
	 * 
	 * @return O valor do atributo <b>proximoItem</b>.
	 */
	public No getProximoItem() {
		return proximoItem;
	}

	/**
	 * Setter para o atributo <b>proximoItem</b>.
	 * 
	 * @param proximoItem
	 *            O novo valor para o atributo <b>proximoItem</b>.
	 */
	public void setProximoItem(No proximoItem) {
		this.proximoItem = proximoItem;
	}
}

Classe ListaEncadeada

package br.edu.ifms.aula;

/**
 * Encapsula uma lista encadeada de inteiros.
 * 
 * @author Prof.º Sidney
 * 
 */
public class ListaEncadeada {

	/**
	 * Tamanho da lista.
	 */
	private int tamanho;

	/**
	 * Primeiro item da lista.
	 */
	private No primeiroItem;

	/**
	 * Último item da lista.
	 */
	private No ultimoItem;

	/**
	 * Construtor para a classe {@link ListaEncadeada}. Inicializa os atributos
	 * da classe.
	 */
	public ListaEncadeada() {
		primeiroItem = null;
		ultimoItem = null;
		tamanho = 0;
	}

	/**
	 * Retorna o primeiro item da lista.
	 * 
	 * @return O primeiro item da lista.
	 */
	public No pegaPrimeiroItem() {
		return primeiroItem;
	}

	/**
	 * Retorna o último item da lista.
	 * 
	 * @return O último item da lista.
	 */
	public No pegarUltimoItem() {
		return ultimoItem;
	}

	/**
	 * Retorna o item situado na posição desejada.
	 * 
	 * @param posicao
	 *            Posição do item a ser recuperado.
	 * @return O item situado na posição desejada.
	 */
	public No pegarItem(int posicao) {
		if (tamanho > 0 && posicao >= 1 && posicao <= tamanho) {
			No item = primeiroItem;
			int contador = 1;
			while (posicao < contador) {
				item = item.getProximoItem();
				contador++;
			}
			return item;
		}
		return null;
	}

	/**
	 * Remove o elemento situado na posição desejada, caso esta posição exista
	 * na lista.
	 * 
	 * @param posicao
	 *            Posição do item a ser removido.
	 * @return <b>true</b> caso o item existia na lista e assim foi removido com
	 *         sucesso; <b>false</b> c.c.
	 */
	public boolean remover(int posicao) {
		if (tamanho > 0 && posicao >= 1 && posicao <= tamanho) {
			No item = primeiroItem;
			No anterior = null;
			int contador = 1;
			while (contador < posicao) {
				anterior = item;
				item = item.getProximoItem();
				contador++;
			}
			No proximo = item.getProximoItem();
			if (anterior != null) {
				anterior.setProximoItem(proximo);
			} else {
				primeiroItem = proximo;
			}
			tamanho--;
			if (tamanho <= 1) {
				primeiroItem = proximo;
				ultimoItem = primeiroItem;
			}
			return true;
		}
		return false;
	}

	/**
	 * Adiciona um novo item no início da lista.
	 * 
	 * @param novoItem
	 *            Novo item a ser adicionado.
	 */
	public void adicionarNoInicio(Integer novoItem) {
		if (tamanho == 0) {
			primeiroItem = new No();
			primeiroItem.setItem(novoItem);
			ultimoItem = primeiroItem;
		} else {
			No antigoPrimeiroItem = primeiroItem;
			primeiroItem = new No();
			primeiroItem.setItem(novoItem);
			primeiroItem.setProximoItem(antigoPrimeiroItem);
		}
		tamanho++;
	}

	/**
	 * Adiciona um novo item no final da lista.
	 * 
	 * @param novoItem
	 *            Novo item a ser adicionado.
	 */
	public void adicionarNoFinal(Integer novoItem) {
		if (tamanho == 0) {
			ultimoItem = new No();
			ultimoItem.setItem(novoItem);
			primeiroItem = ultimoItem;
		} else {
			No antigoUltimoItem = ultimoItem;
			ultimoItem = new No();
			ultimoItem.setItem(novoItem);
			antigoUltimoItem.setProximoItem(ultimoItem);
		}
		tamanho++;
	}

	/**
	 * Adiciona um novo item na posição desejada na lista
	 * 
	 * @param novoItem
	 *            Novo item a ser adicionado.
	 * @param posicao
	 *            Posição na qual o item deve ser adicionado. Caso o valor da
	 *            posição seja menor que 1 ou maior que o valor de
	 *            <b>tamanho</b> - 1, então o item não é adicionado.
	 * @return <b>true</b> caso o item tenha sido adicionado com sucesso;
	 *         <b>false</b> c.c.
	 */
	public boolean adicionarNaPosicao(Integer novoItem, int posicao) {
		if (posicao >= 1 && posicao <= tamanho + 1) {
			if (posicao == 1) {
				adicionarNoInicio(novoItem);
			} else if (posicao == tamanho + 1) {
				adicionarNoFinal(novoItem);
			} else {
				No novoNo = new No();
				novoNo.setItem(novoItem);
				int contador = 1;
				No itemAnteriorAoNovo = primeiroItem;
				while (contador < posicao - 1) {
					itemAnteriorAoNovo = itemAnteriorAoNovo.getProximoItem();
					contador++;
				}
				novoNo.setProximoItem(itemAnteriorAoNovo.getProximoItem());
				itemAnteriorAoNovo.setProximoItem(novoNo);
				tamanho++;
			}
			return true;
		}
		return false;
	}
}

Introdução à Linguagem Python (aula 1)

    Olá, galera!

    Esta é primeira aula de uma série de aulas sobre assuntos distintos aos apresentados em sala de aula. A ideia por trás destas aulas é apresentar a vocês assuntos interessantes extra-aula, a fim de despertar em vocês o interesse pelo out-of-box thinking (pensando "fora da caixa"). Ou seja, perceber a necessidade em não se prender ao conteúdo apresentado em sala de aula e despertar o interesse à pesquisa por tecnologias diferentes e interessantes.
    Nesta primeira aula eu apresento uma introdução à linguagem de programação Python, falando do que ela se trata e porquê vale a pena aprender a programar nesta linguagem. Esta é a primeira de algumas aulas sobre Python que publicarei aqui no blog. Boa leitura e let's code!

Fatores Humanos

    Olá, galera!

    Nesta aula eu falo brevemente a respeito dos fatores humanos na criação de interfaces. A aula explora os mecanismos do cérebro humano, abordando como processamos informações e percebemos o nosso ambiente. Abraço!

Laços de repetição

    Olá, galera!

    Nesta aula eu falo detalhadamente sobre laços de repetição. Por meio de um exemplo corrente, eu explico o motivo pelo qual utilizamos laços de repetição e como utilizar cada um dos laços. Abraço! (P.S.: ao mais apressados: eu não falei sobre o laço for each pois explicarei ele com detalhes na aula sobre vetores e matrizes. Ah! Eu já falei sobre isto nesta aula aqui.)




Classe ExemploWhile

import java.util.Scanner;

public class ExemploWhile {

 public static void main(String[] args) {
  System.out.println("Digite um numero inteiro positivo:");
  Scanner leitor = new Scanner(System.in);
  int n = leitor.nextInt();
  // Garantindo que o valor de numero seja positivo...
  if (n < 0) {
   n = n * -1;
  } else if (n == 0) {
   n = 1;
  }
  int contador = 1;
  while (contador <= n) {
   System.out.print(contador + " ");
   contador++;
  }
  leitor.close();
 }

}

Classe ExemploDoWhile

import java.util.Scanner;

public class ExemploDoWhile {

 public static void main(String[] args) {
  System.out.println("Digite um numero inteiro positivo:");
  Scanner leitor = new Scanner(System.in);
  int n = leitor.nextInt();
  // Garantindo que o valor de numero seja positivo...
  if (n < 0) {
   n = n * -1;
  } else if (n == 0) {
   n = 1;
  }
  int contador = 0;
  do {
   contador++;
   System.out.print(contador + " ");
  } while (contador < n);
  leitor.close();
 }

}

Classe ExemploFor

import java.util.Scanner;

public class ExemploFor {

 public static void main(String[] args) {
  System.out.println("Digite um numero inteiro positivo:");
  Scanner leitor = new Scanner(System.in);
  int n = leitor.nextInt();
  // Garantindo que o valor de numero seja positivo...
  if (n < 0) {
   n = n * -1;
  } else if (n == 0) {
   n = 1;
  }
  for(int contador = 1; contador <= n; contador++) {
   System.out.print(contador + " ");
  }
  leitor.close();
 }

}

Classe ExemploFor2

import java.util.Scanner;

public class ExemploFor2 {

 public static void main(String[] args) {
  System.out.println("Digite um numero inteiro positivo:");
  Scanner leitor = new Scanner(System.in);
  int n = leitor.nextInt();
  // Garantindo que o valor de numero seja positivo...
  if (n < 0) {
   n = n * -1;
  } else if (n == 0) {
   n = 1;
  }
  for(int contador = n, contador2 = n, contador3 = n; contador >= 0 && contador2 >= 0 && contador3 >= 0; contador--, contador2 -= 2, contador3 -= 3) {
   System.out.print("[" + contador + ", ");
   System.out.print(contador2 + ", ");
   System.out.print(contador3 + "] ");
  }
  leitor.close();
 }

}

Manipulação de Datas em Java

    Olá, galera!

    Nesta aula extra, eu ensino como armazenar e manipular datas em Java. Neste material você aprenderá a trabalhar as informações de data de forma mais avançada. Abraço!

Classes e Objetos em Java

Olá, galera!

Nesta aula eu explico brevemente o uso de classes e objetos para encapsular tipos complexos. Explico também o uso de matrizes de classes. Abraço!




LEMBRETE: Para compilar as classes LeituraAluno e LeituraVariosAlunos, dado que elas necessitam da classe Aluno, você deverá realizar os seguintes passos:

- Crie os diretórios conforme a figura abaixo e coloque as classes Aluno, LeituraAluno e LeituraVariosAlunos dentro da pasta aula.

- Para compilar a classe LeituraAluno, por exemplo, você deverá entrar no primeiro diretório acima do diretório br e executar os seguintes comandos:

    

    No Linux:

     

     javac br/edu/ifms/aula/LeituraAluno.java

     java br.edu.ifms.aula.LeituraAluno

    No Windows:

    javac br/edu/ifms/aula/LeituraAluno.java

    java br.edu.ifms.aula.LeituraAluno

Classe Aluno

package br.edu.ifms.aula;

import java.util.Date;

public class Aluno {

 private String matricula;

 private String nomeCompleto;

 private char sexo;

 private String cpf;

 private Date dataNascimento;

 private String telefone;

 public String getMatricula() {
  return matricula;
 }

 public void setMatricula(String matricula) {
  this.matricula = matricula;
 }

 public String getNomeCompleto() {
  return nomeCompleto;
 }

 public void setNomeCompleto(String nomeCompleto) {
  this.nomeCompleto = nomeCompleto;
 }

 public char getSexo() {
  return sexo;
 }

 public void setSexo(char sexo) {
  this.sexo = sexo;
 }

 public String getCpf() {
  return cpf;
 }

 public void setCpf(String cpf) {
  this.cpf = cpf;
 }

 public Date getDataNascimento() {
  return dataNascimento;
 }

 public void setDataNascimento(Date dataNascimento) {
  this.dataNascimento = dataNascimento;
 }

 public String getTelefone() {
  return telefone;
 }

 public void setTelefone(String telefone) {
  this.telefone = telefone;
 }

}

Classe LeituraAluno

package br.edu.ifms.aula;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class LeituraAluno {

 public static void main(String[] args) {
  Aluno aluno = new Aluno();
  Scanner leitor = new Scanner(System.in);

  System.out.println("Digite a matricula:");
  String textoDigitado = leitor.nextLine();
  aluno.setMatricula(textoDigitado);

  System.out.println("Digite o nome completo:");
  textoDigitado = leitor.nextLine();
  aluno.setNomeCompleto(textoDigitado);

  System.out.println("Digite o CPF:");
  textoDigitado = leitor.nextLine();
  aluno.setCpf(textoDigitado);

  System.out.println("Digite a data de nascimento (dd/mm/aaaa):");
  textoDigitado = leitor.nextLine();
  SimpleDateFormat formatadorDeDatas = new SimpleDateFormat("dd/MM/yyyy");
  Date dataDigitada = null;
  try {
   dataDigitada = formatadorDeDatas.parse(textoDigitado);
  } catch (ParseException e) {
  }
  aluno.setDataNascimento(dataDigitada);

  System.out.println("Digite o telefone ((##)#####-####):");
  textoDigitado = leitor.nextLine();
  aluno.setTelefone(textoDigitado);

  System.out.println("Digite o sexo (M ou F):");
  textoDigitado = leitor.nextLine();
  char sexo = textoDigitado.charAt(0);
  aluno.setSexo(sexo);

  System.out.println("Dados do aluno: " + aluno.getNomeCompleto()
    + " lidos com sucesso!");

  leitor.close();
 }
}

Classe LeituraVariosAlunos

package br.edu.ifms.aula;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class LeituraVariosAlunos {

 public static void main(String[] args) {
  Aluno[] alunos = new Aluno[10];
  Scanner leitor = new Scanner(System.in);

  for (int i = 0; i < alunos.length; i++) {
   alunos[i] = new Aluno();
   System.out.println("Digite a matricula:");
   String textoDigitado = leitor.nextLine();
   alunos[i].setMatricula(textoDigitado);

   System.out.println("Digite o nome completo:");
   textoDigitado = leitor.nextLine();
   alunos[i].setNomeCompleto(textoDigitado);

   System.out.println("Digite o CPF:");
   textoDigitado = leitor.nextLine();
   alunos[i].setCpf(textoDigitado);

   System.out.println("Digite a data de nascimento (dd/mm/aaaa):");
   textoDigitado = leitor.nextLine();
   SimpleDateFormat formatadorDeDatas = new SimpleDateFormat(
     "dd/MM/yyyy");
   Date dataDigitada = null;
   try {
    dataDigitada = formatadorDeDatas.parse(textoDigitado);
   } catch (ParseException e) {
   }
   alunos[i].setDataNascimento(dataDigitada);

   System.out.println("Digite o telefone ((##)#####-####):");
   textoDigitado = leitor.nextLine();
   alunos[i].setTelefone(textoDigitado);

   System.out.println("Digite o sexo (M ou F):");
   textoDigitado = leitor.nextLine();
   char sexo = textoDigitado.charAt(0);
   alunos[i].setSexo(sexo);

   System.out.println("Dados do aluno: " + alunos[i].getNomeCompleto()
     + " lidos com sucesso!\n");
  }

  leitor.close();
 }
}