PROGRAMAÇÃO I - CCT0827

Semana Aula: 1
Unidade 1: Introdução à linguagem de programação

Tema
A Tecnologia Java

Palavras-chave
Plataforma Java, Ambiente de desenvolvimento, Ambiente de Programação

Objetivos
O aluno deverá ser capaz de:

· Conhecer como surgiu a linguagem Java.

· Identificar as principais características da linguagem Java;

· Descrever o ambiente de programação Java.

Estrutura de Conteúdo
Histórico da Linguagem Java

A tecnologia Java foi desenvolvida na década de 1990 a partir de um projeto pessoal de

um funcionário da Sun Microsystems. A ideia inicial estava ligada a criação de uma
linguagem de programação que pudesse ser utilizada em diferentes sistemas, alterando o
paradigma de que uma aplicação só pudesse ser desenvolvida para uso em um único
ambiente de hardware e sistema operacional, como era bastante comum na época.

Principais características e vantagens da tecnologia Java:

 Orientada a Objetos com uma grande diversidade de bibliotecas de classes

disponível.
 Independente de plataforma: write once, run everywhere.
 Segurança - Mecanismos para sistemas livres de vírus, pacotes para criptografia.
 Simplicidade.
 Sintaxe dos comandos básicos segue o padrão do C.
 Sintaxe da parte OO bem mais simples que o C++.
 Internacionalização.
 UNICODE: padrão que permite manipular textos de qualquer sistema de escrita.
 Robustez.
 Tratamento de exceções.
 JVM impede que uma aplicação mal comportada paralise o sistema.
 Distribuída e multitarefa.
  Os programas podem utilizar recursos da rede com a mesma facilidade que
acessam arquivos locais.
 Trabalha com diversos protocolos (TCP/IP, HTTP, FTP,...).
 Execução simultânea de múltiplas threads.
 Gerenciamento de memória.
 Memória virtual gerenciada pela JVM.
 Garbage collection.
 Desempenho.
 Mais rápida que linguagens de script, porém mais lenta que as linguagens
compiladas puras.
 Hoje, os problemas de desempenho são resolvidos com compilação just-in-time.

Plataforma Java

A plataforma Java é definida apenas em software e possui dois componentes:

 Máquina Virtual Java (JVM - Java Virtual Machine);

 Conjunto de bibliotecas que disponibilizam classes comuns.

A plataforma Java é composta por 3 plataformas:

 J2SE ou Java SE (Java Standard Edition): é a base da plataforma e inclui o

ambiente de execução e as bibliotecas comuns.
 J2EE ou Java EE (Java Enterprise Edition): versão voltada para o
desenvolvimento de aplicações corporativas e aplicações web.
 J2ME ou Java ME (Java Micro Edition): versão voltada para o desenvolvimento
de aplicações móveis ou embarcadas.

Ambiente de Desenvolvimento

 Java Development Kit (JDK): Coleção de programas para, dentre outras tarefas,
compilar e executar aplicações Java. Este é o kit necessário para o desenvolvedor,
pois contém todo suporte para a criação de aplicações em Java.

 Java Runtime Environment (JRE): Kit com todos os programas necessários para
executar aplicações Java. Faz parte do JDK, mas pode ser instalado
separadamente para em execução em máquinas clientes, uma vez que o JDK é
voltado para os desenvolvedores.

Ambiente de Programação

Existem várias ferramentas para o desenvolvimento de sistemas utilizando a linguagem

java, mas os desenvolvedores possuem uma preferência especial pelos IDEs Eclipse e
Netbeans.

Download:
Netbeans: https://netbeans.apache.org/download/index.html

Eclipse: https://www.eclipse.org/downloads/

Cuidado com as diferenças de versões no sistema operacional, se você instalar o Java

para 64 bits, você deverá usar um IDE (Netbeans ou Eclipse) de 64 bits. O mesmo caso
você instale a versão de 32 bits, tanto o java quanto o IDE deverão ser para 32 bits.

Procedimentos de Ensino
Fluxo da aula:

· O docente deverá apresentar-se ao aluno e apresentar o Plano de Ensino, com os

detalhes que forem importantes para o aluno que está começando o Curso.
· Destacar a importância do desenvolvimento dos exercícios práticos.
· Apresentar as características da linguagem Java.
· Apresentar a plataforma Java e o ambiente de programação
· Desenvolver um projeto usando o Netbeans ou Eclipse, com o objetivo de
apresentar o passo a passo da criação de um programa em Java. Destacando as
fases de um programa em linguagem Java.

Estratégias de Aprendizagem
Apresentar o ranking das Linguagens de Programação -
https://codigosimples.net/2019/03/09/confira-a-lista-das-linguagens-de-programacao-
mais-utilizadas-em-2018-2019/

Diferenciar os diferentes paradigmas de linguagem de programação.

Implementar exemplos de aplicações em Java, visando se familiarizar ao ambiente de

programação.

Indicação de Leitura Específica

Histórico da Linguagem Java

1. FURGERI, Sérgio. Java 8 ? ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 13 ? 14]

Ambiente de Desenvolvimento
2. DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 13 ? 16]

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Desenvolver uma aplicação de exemplo, destacando o passo a passo da construção de um
projeto no ambiente Netbeans.

Exemplo:

import java.util.Scanner;

public class Exemplo {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

double media, nota1, nota2;

System.out.println("Digite a nota 1:");

nota1 = Double.parseDouble(sc.nextLine());

System.out.println("Digite a nota 2:");

nota2 = Double.parseDouble(sc.nextLine());

media = (nota1 + nota2) /2.0;

System.out.println("A sua média é:" + media);

sc.close();
}

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 2
Unidade 1 - Introdução à linguagem de programação

Tema
Características da linguagem Java

Palavras-chave
Características da linguagem Java, Tipos de dados, Constantes e Variáveis, Operadores e
Expressões, Comandos de Controle de Fluxo, Estruturas de Repetição, Entrada e Saída de
Dados, Conversão de tipos.

Objetivos
O aluno deverá ser capaz de:

·Conhecer os tipos de dados, constantes e como declarar variáveis em Java

·Conhecer operadores e expressões da linguagem Java.

· Conhecer e aplicar os comandos das estruturas condicionais.

·Conhecer e aplicar os comandos das estruturas de repetição.

·Desenvolver programas simples em Java que utilizem tipos de dados

primitivos, variáveis, constantes, operadores, expressões, saída de dados e
estruturas de condicionais e de repetição.

Estrutura de Conteúdo
Características da linguagem Java

A linguagem Java tem boa parte de suas características herdadas da linguagem C, muitos
dos seus operadores, formação de identificadores, comandos de controle de fluxo e várias
outras características são compartilhados entre estas duas linguagens.

Todas as instruções da linguagem Java devem terminar por um símbolo de ponto-e-

vírgula “;”.

Os blocos de comandos em Java são delimitados por { (abrir) e } (fechar) chaves.

Em Java são permitidos identificadores que comecem com letras (maiúsculas ou
minúsculas), ou um símbolo de “$” (dólar) ou “_” (underscore /underline). Números
podem ser usados, mas não para iniciar um identificador.

Java é uma linguagem de programação sensível a caixa (alta ou baixa ou case sensitive).

Comentários

1) Comentário de linha: faz com que todo o seu conteúdo, após as duas barras,
seja desconsiderado pelo compilador

// comentário de linha

2) Comentário de bloco: podemos comentar não apenas um trecho de uma linha,

mas todo um conjunto de linhas.

/*

comentário de linha

*/

3) Comentário de documentação: existe uma ferramenta na linguagem Java que é

responsável por extrair de um projeto (com várias classes) todos os comentários
de documentação e montar um documento com todo este conteúdo.

/**

comentário de documentação

*/

Tipos de dados

 Primitivos (armazenam apenas valores):

- Tipo lógico (boolean).

- Tipo caractere (char).

- Tipos inteiros (byte, short, int e long).

- Tipos reais (float e double).

 Tipo Especial

- Tipo texto (String).

Constantes e Variáveis
Variáveis e constantes em Java devem obrigatoriamente possuir um tipo, isso ocorre
porque Java é uma linguagem de programação fortemente tipada.

Variáveis são declaradas através de um tipo e um identificador, sem que sejam

necessárias outras informações. A boa prática em programação Java determina que todas
as variáveis comecem por letras minúsculas e somente se tiver mais de uma palavra, o
inicial da segunda palavra em diante deverá começar por letras maiúsculas.

A definição de constantes precisam do modificador “final”, que indica que uma vez que
ocorreu uma atribuição a variável, seu conteúdo não poderá ser mudado.

Operadores e Expressões

1. Operadores Aritméticos: + , - , *, /, %
2. Operadores de atribuição compostos: += , -= , *= , /= , %=
3. Operadores de Incremento e decremento: ++ , --
4. Operadores Relacionais: > , < , <= , >= , == , !=
5. Operadores Lógicos: && , || , !
6. Operadores de Bits: & , ^ , |

Comandos de Controle de Fluxo

if if ... else if ... else if ... else switch ... case

if (condição) { if if (condição1) { switch (variável) { // tipo inteiro

(condição)
// instruções; { // instruções; case 1 : // instruções;

} // } break;
instruções;
else if (condição2) { case 2 : // instruções;
}
//instruções; break;
else {
} case 3 : // instruções;
//
instruções; else if (condição3) { break;

} // instruções; default: // instruções para

condições não previstas
}
// anteriormente;
else {
}
//instruções;

}
Estrutura de Repetição

1. for

for( (1)inicialização; (2)condição de controle; (3)passo) {

// instruções

Repetição controlada por uma variável:

for (int c=1; c<=limite; i++) {

instruções;

Repetição controlada por duas variável:

for (a=1, b=2; a*b<limite; a++, b+=2) {

instruções;

Repetição sem fim:

for ( ; ; ) {

instruções;

2. while

Esta estrutura realiza a repetição de um conjunto de instruções enquanto a condição

determinada for verdadeira, caso a condição seja falsa no primeiro teste, nenhuma
instrução será executada.

while (condição) {

instruções;

}
 3. do ... while

Esta estrutura de repetição é semelhante à anterior, mas com o diferencial de que a

condições ser verificada apenas no final da estrutura, obrigando que as instruções sejam
sempre executadas pelo menos uma vez.

do

instruções;

} while (condição);

Entrada e Saída de Dados

1. Entrada de Dados

· Classe Scanner

·É usada para realizar a entrada de dados.

·Pertence ao pacote java.util.

·Por não estar definido em uma biblioteca padrão, para usar a classe

·Scanner precisamos informar onde essa ela se encontra. Isso é feito através
do comando import: import java.util.Scanner;

·É necessário criar o objeto para realizar as entradas de dados:

public class EntradaDados {

public static void main(String[] args) {

Scanner entrada = new Scanner(System.in);

·Existem vários métodos na classe Scanner para fazer a entrada de dados:

Para entrada de texto (String):

String nome;

Nome = entrada.nextLine(); // não precisa de conversão, apenas da entrada

 Para entrada de valor real:

double nota1;

nota1=Double.parseDouble(entrada.nextLine());

// a entrada de dados em texto precisa de conversão para double.

Para entrada de valor inteiro:

int idade;

idade = Integer.parseInt(entrada.nextLine());

// a entrada de dados em texto precisa de conversão para int.

2. Saída de Dados

A saída de dados em modo texto pode ser realizada pela classe System, e o método
out.print (não pula linha), out.println (pula linha) ou outros métodos:

Apenas uma mensagem:

System.out.println("Entre com a Nota A1.........: ");

Mensagem e conteúdo de variáveis:

System.out.println(" Nome: " + nome + " Idade: " + idade + " Nota 1: " + nota1);

Conversão de Tipos

1. Por cast

Usado para converter valores de um tipo para outro, com cast basta indicar o tipo que
você quer que a variável ou valor seja convertido colocando o tipo desejado entre
parênteses:

int a = 10;

double b = 0;

b = (double) a;

a = (int) b;
 2. Por uso de classes para conversão de textos em valores

double nota1 = Double.parseDouble(“7.8”);

int idade = Integer.parseInt(“34”);

float valor = Float.parseFloat(“2.15”);

long valor2 = Long.parseLong(“3456789”);

A boa Prática em Programação Java

A boa prática em programação Java leva em conta um conjunto de regras que facilitam o
desenvolvimento de aplicações e melhoram bastante o trabalho em conjunto realizado por
equipes.

Regra 1. Variáveis auxiliares, atributos, métodos e objetos

Devem ser identificados iniciando por letras minúsculas. Quando houver mais de
uma palavra, deve-se começar cada nova palavra com uma letra maiúscula.

Exemplos:

int idade;

int maiorIdade;

String nome;

String nomeCompleto;

Regra 2: Constantes

Devem ser identificados por letras maiúsculas em todo o seu nome, mesmo
quando temos mais de uma palavra, todo o identificador deve ficar em
maiúsculas.

Exemplos:

final int idade;

final int maiorIdade;

final String nome;

final String nomeCompleto;

Regra 3: Classes e Interfaces (tipo especial de classe)

 Devem iniciar por letras maiúsculas. Quando houver mais de uma palavra, deve-
se começar cada nova palavra com uma letra maiúscula.

Exemplos:

public class Carro { ... }

public class Carro Hibrido { ... }

public interface Basico { ... }

public interface MetodosBasicos { ... }

Procedimentos de Ensino
Fluxo da aula:

· Destacar a importância de utilizar comentários nos programas, principalmente o

comentário de documentação.
· Apresentar os tipos de dados.
· Trabalhar com constantes e variáveis.
· Apresentar os operadores e expressões: aritméticos, relacionais, lógicos, bits,
· Trabalhar com as estruturas de controle de fluxo.
· Trabalhar com as estruturas de repetição.
· Trabalhar com entrada e saída de dados.
· Trabalhar com conversão de tipos de dados.
· Desenvolver programas em Java.

Estratégias de Aprendizagem
Implementar programas em Java, explorando expressões, estruturas de fluxo de controle
e estruturas de repetição.

Indicação de Leitura Específica

Operadores:

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 41 – 46]
Comandos de Controle de Fluxo:

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 81 – 87]

Estrutura de Repetição

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 120 – 132]

Conversão de Tipos:

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 35 – 38]

Entrada e Saída de Dados:

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 38 – 39]

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

1. Faça um programa em Java que leia uma temperatura em graus Célsius e apresentá-la
convertida em graus Fahrenheit. A fórmula de conversão é: F = (9*C+160)/5. Onde F é a
temperatura em Fahrenheit e C é a temperatura em Célsius.

2. Faça um programa em Java que leia o nome de uma pessoa, seu respectivo salário
bruto e o valor do salário mínimo, ao final calcular a quantidade de salários mínimos
recebida e exibir a mensagem:

Funcionário: xxx recebe yyy salários mínimos.

3. Um hotel cobra R$ 160.00 a diária e mais uma taxa de serviços. A taxa de serviços é
de:
 •R$ 55,00 por diária, se o número de diárias for maior que 15;

• R$ 60,00 por diária, se o número de diárias for igual a 15;

•R$ 80,00 por diária, se o número de diárias for menor que 15.

Construa um programa em Java que mostre o nome e o total da conta de um cliente.

4. Um banco concederá um crédito especial aos seus clientes, variável com o saldo médio
no último ano. Faça um programa em Java que leia o saldo médio de um cliente e calcule
o valor do crédito de acordo com a tabela abaixo. Mostre uma mensagem informando o
saldo médio e o valor do crédito.

Saldo médio Percentual

de 0 a 2000.00 nenhum crédito

de 2000.01 a 4000.00 20% do valor do saldo médio

de 4000.01 a 6000.01 30% do valor do saldo médio

acima de 6000.00 40% do valor do saldo médio

5. Faça um programa em Java que leia um número e informe se é um número Primo.

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 3
Unidade 2 - Conceitos de orientação a objetos

Tema
Classes e Objetos

Palavras-chave
Classes, Atributos, Métodos, Objetos, Métodos Setters, Métodos Getters.

Objetivos
O aluno deverá ser capaz de:

· Compreender os conceitos de classes, objetos, atributos e métodos.

· Compreender os conceitos de métodos de acessos.

· Desenvolver aplicações orientadas a objetos.

Estrutura de Conteúdo
Orientação a Objetos

A programação orientada a objetos tem como principal conceito representar em um

sistema computacional um objeto da vida real. Esta representação deve descrever o
objeto quanto às suas características e a ações que o objeto poderá realizar dentro do
sistema. Não devemos nos preocupar com todas as características presentes no objeto,
mas com aquelas que serão necessárias ao sistema (requisitos).

Classes

As classes Java são responsáveis pelo conjunto de códigos para a criação de objetos e
aplicações.

Uma classe Java deve descrever as características e ações que o objeto possuí ao ser
representado em um sistema computacional, levando em consideração as características e
ações realmente importantes para o sistema.

Atributos
Atributo é conceitualmente um descritor do objeto. Deve representar uma característica
do objeto. O conjunto de atributos do objeto devem representar todas as características
importantes do objeto para o sistema.

Exemplos:

String matricula; // atributo para armazenamento da matrícula

String nome; // atributo para armazenamento do nome

double cr; // atributo para armazenamento do cr

Métodos:

Método é uma ação, um conjunto de instruções a serem executadas por um objeto para
realizar uma determinada tarefa.

Exemplos:

public int soma(int n1, int n2){

int soma;

soma = n1 + n2;

return soma;

public void imprimeAumento(double salario, int percentual){

double aumento;

aumento = salario + salario * percentual / 100.0;

System.out.println("O salário com aumento é: " + aumento);

Objetos

A classe modela o objeto de acordo com as necessidades do sistema para a sua descrição
e suas ações. A partir de uma mesma classe, vários objetos diferentes, mas com
características semelhantes podem ser criados em um mesmo sistema ou em diferentes
sistemas.

Os objetos só existem durante a execução do sistema, pois estes só existirão como

referência na memória do computador neste momento. Dizemos também que os objetos
só existem “em tempo de execução”, uma vez que o sistema ao ser encerrado terá toda a
sua memória apagada e consequentemente todas as suas variáveis e objetos não existirão
mais.

Aplicações Java

Aplicações em Java são classes especiais que possuem um método main(). O método
main é responsável por criar os objetos e realizar a combinação de diferentes classes para
atender as necessidades de um sistema. Em cada sistema tempos apenas uma aplicação,
que será a responsável pela lógica de criação e uso das classes.

A comunicação entre os objetos ocorre através de trocas de mensagens, que são expressas
através do uso de métodos.

Métodos Setters e Getters

1. Métodos Setters

São métodos especiais que recebem o valor do atributo e por serem métodos, podem
analisar se são válidos, sendo responsáveis pela atribuição. Quando o atributo é protegido
(privado) é necessário um método para realizar a atribuição.

Características dos métodos Setters:

· São sempre do tipo void, pois métodos Setters não devem retornar nada;

· Devem ser públicos para que a aplicação tenha acesso ao método;

· Devem começar pela palavra set e o nome do atributo, como tem mais de
uma palavra, cada nova palavra no nome deve começar por letra maiúscula;

· Possui sempre um parâmetro do mesmo tipo do atributo que receberá o

valor, pois ambos (parâmetro e atributo) devem ser do mesmo tipo.

2. Métodos Setters

São métodos especiais que retornam o valor armazenado no atributo, evitando acesso
direto ao atributo pela aplicação. Assim como visto no método Setter, a proteção do
atributo (private) fará com que a aplicação não tenha acesso direto ao atributo fazendo
com que seja necessário um método público para recuperar o valor atribuído ao mesmo.

Características dos métodos Getters:

· São sempre do mesmo tipo do atributo que será retornado, nunca do tipo
void;

· Devem ser públicos para que a aplicação tenha acesso ao método;

· Devem começar pela palavra get e o nome do atributo, como tem mais de
uma palavra, cada nova palavra no nome deve começar por letra maiúscula;
 · Não possui parâmetro, esses métodos nunca receberão parâmetros uma vez
que não farão atribuições ou ações com parâmetros, realizando apenas o
retorno do valor armazenado no atributo.

Procedimentos de Ensino
Fluxo da aula:

· Destacar os conceitos de classes, atributos, métodos e objetos.

· Trabalhar com os métodos Setters e Getters
· Desenvolver programas, aplicando os conceitos de orientação a objetos, em
Java.

Estratégias de Aprendizagem
Implementar programas em Java, explorando os conceitos de orientação a objetos:
classes, atributos, métodos, objetos, métodos setters e métodos getters.

Exemplo:

Arquivo do projeto: Aluno.java

public class Aluno {

// Atributos devem ser identificados começando por letras minúsculas

String matricula, nome;

double cr;

// Métodos devem ser identificados começando por letras minúsculas

public void setMatricula(String m){

if(!m.isEmpty()) { // se o parâmetro m NÃO (!) estiver vazio

matricula = m; // será feita a atribuição

public String getMatricula(){

return matricula; // retorna a matrícula

}

public void setNome(String n){

if(!n.isEmpty()) { // se o parâmetro n NÃO (!) estiver vazio

nome = n; // será feita a atribuição

public String getNome(){

return nome; // retorna o nome

public void setCr(double c){

if (c >=0 && c<=10){ // se o parãmetro c for válido

cr = c; // o valor de c será atribuído

public double getCr(){

return cr; // retorna o CR

public void imprimir( ){

// os métodos Getters foram usados aqui

System.out.println("Matrícula: " + getMatricula());

System.out.println("Nome : " + getNome());

System.out.println("CR : " + getCr());

Arquivo do projeto: AppAluno.java

//Aplicação para uso da Classe Aluno

public class AppAluno { // declaração e início da classe

public static void main (String[] args){// método inicial da App

Aluno aluno1 = new Aluno(); // Criação ou instanciação do objeto aluno1

Aluno aluno2 = new Aluno(); // Criação ou instanciação do objeto aluno2

Aluno aluno3 = new Aluno(); // Criação ou instanciação do objeto aluno3

//definindo valores para os atributos do aluno1

aluno1.setMatricula( "1001" );

aluno1.setNome( "André" );

aluno1.setCr( 6.7 ) ;

//definindo valores para os atributos do aluno2

aluno2.setMatricula( "1002" );

aluno2.setNome( "Maria" );

aluno2.setCr( 7.5 );

//definindo valores para os atributos do aluno3

aluno3.setMatricula( "" ); // valor vazio, não será atribuído

aluno3.setNome( "" ); // valor vazio, não será atribuído

aluno3.setCr( 12 ); // valor do CR inválido, não será atribuído

//exibindo os valores dos atributos de cada aluno:

aluno1.imprimir();

aluno2.imprimir();

aluno3.imprimir();

}
Indicação de Leitura Específica
Orientação a Objetos:

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 103 – 108]

Métodos Setters e Getters:

Get e Set - Métodos Acessores em Java - https://www.devmedia.com.br/get-e-set-

metodos-acessores-em-java/29241

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

1) Imagine que desejamos implementar um editor gráfico que irá manipular
figurasgeométricas:

Retângulo

Triângulo

Círculo

Quais as classes candidatas para esse projeto ?

2) Sabendo que todo livro possui autor, editora e preço, crie uma classe pública
comconstrutor padrão e métodos modificadores e de acesso. Depois, crie dois livros com
dados obtidos via console.

3) Utilizando como base o programa do exercício 2, altere os dados do 2º. livro da

seguinte forma: autor para Harlan Coben, editora Arqueiro e preço R$ 30,00.
4) Utilizando como base o programa do exercício 2, compare os preços dos dois livros,
imprimindo o nome da editora do livro de menor preço.

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 4
Unidade 2 - Conceitos de orientação a objetos

Tema
Métodos Construtores e Polimorfismo de Sobrecarga

Palavras-chave
Método Construtor, Polimorfismo, Polimorfismo de Sobrecarga

Objetivos
O aluno deverá ser capaz de:

·Compreender e aplicar o conceito de métodos construtores.

· Compreender e aplicar os conceitos de polimorfismo de sobrecarga.

Estrutura de Conteúdo
Métodos Construtores

A programação orientada a objetos permite que possamos controlar a criação de um

objeto, através dos chamados métodos construtores.

São métodos especiais que são executados apenas uma vez por cada objeto criado, pois
só é executado no momento da instanciação / criação do objeto e é responsável por
realizar as ações necessárias para a sua criação (controlar a criação do objeto).

Características:

•São sempre públicos (public, característica de encapsulamento – será visto mais

adiante em nosso conteúdo), não podendo ter nenhum tipo de restrição;

• Não existe definição de tipo de retorno, pois métodos construtores não podem
retornar valores com a instrução “return”, são sem tipo;

• Devem ser identificados sempre com o mesmo nome da classe;

•São executados exclusivamente durante o processo de criação / instanciação do

objeto, não podendo ser usados pelo objeto após a sua criação.

Exemplo:

Classe Pessoa
public class Pessoa {

String nome, identidade;

int idade;

public Pessoa(String nome, String identidade, int idade) {

setNome( nome );

setIdentidade( identidade );

setIdade( idade );

public String getNome() {

return nome;

public void setNome( String no ) {

if (!no.isEmpty()){

nome = no;

public String getIdentidade() {

return identidade;

public void setIdentidade( String id ) {

if (!id.isEmpty()){

identidade = id;

public int getIdade() {

return idade;

public void setIdade( int id ) {

if (id > 0){

idade = id;

public void imprimir() {

System.out.println( "Pessoa:");

System.out.println("Nome = " + nome);

System.out.println("Identidade = " + identidade);

System.out.println("Idade = " + idade);

Aplicação: AppPessoa

public class AppPessoa {

public static void main(String[] args) {

// TODO Auto-generated method stub

//Pessoa p1 = new Pessoa();

Pessoa p2 = new Pessoa("Marcela", "0123456-7", 23);

p2.imprimir();

Observação: Quando não temos um construtor em uma classe, um construtor VAZIO é

criado no processo de compilação.
Polimorfismo de Sobrecarga.

Polimorfismo: quer dizer “muitas formas”, é permite o emprego de operadores e

identificadores de várias formas, sendo então necessária uma contextualização para que
seja realizada a operação adequada. Este contexto está ligado ao emprego do operador,
dom método, etc, de acordo com uma situação.

1. Polimorfismo de Sobrecarga de Operadores

O operador + é um dos mais usados e por isso é um bom exemplo de Sobrecarga

deOperadores, ele pode ser usado de várias e diferentes formas em função do contexto:

1.Concatenação: String nome = "João" + " da " + "Silva";

2.Soma inteira: int a = 3 + 4;

3.Soma real: double b = 1.3 + 2.7;

4.Incremento: x++; ou ++x;

5.Concatenação entre textos e valores: System.out.println("Idade" +

p2.getIdade());

Exemplo:

System.out.println("Valor=" + (( 3 + 4) + (1.3 + 2.7) + (++x)));

2. Polimorfismo de Sobrecarga de Métodos

A Sobrecarga de métodos permite que possamos ter mais de um método com o mesmo
identificador em uma mesma classe. Isso só é possível em razão da avaliação do contexto
no momento da execução.

Com o uso da Sobrecarga de métodos você poderá criar quantos métodos com o mesmo
identificador (nome) você quiser em uma mesma classe, desde que eles não possuam a
mesma assinatura de método.

Exemplos de Polimorfismo de Sobrecarga válidos para uma mesma classe:

int meuMetodo( int a, double b, String c ) {

return 1;

}
 int meuMetodo ( double b, String c, int a ){

return 2;

int meuMetodo ( String c, int a, double b ) {

return 3;

int meuMetodo ( String c, double b, int a ) {

return 4;

As assinaturas são respectivamente:

meuMetodo ( int , double , String )

meuMetodo ( double , String , int )

meuMetodo ( String , int , double )

meuMetodo ( String , double , int )

Todos os métodos acima, apesar de possuírem a mesma quantidade de parâmetros, suas

assinaturas são diferentes e serão executadas em função de contexto diferentes,
respectivamente:

int g = meuMetodo( 2, 2.25, "Casa" );

int h = meuMetodo( 2.25, "Casa", 2 );

int i = meuMetodo( "Casa", 2, 2.25 );

int j = meuMetodo( "Casa", 2.25, 2 );

Os valores armazenados em g, h, i e j serão respectivamente: 1, 2, 3 e 4.

Sobrecarga de Métodos Construtores

Métodos construtores são métodos e sendo assim, também podem ser sobrecarregados.

Uma classe que possui mais de um método construtor é uma classe que oferece diferentes
formas de criação para os seus objetos.
Procedimentos de Ensino
Fluxo da aula:

·Trabalhar com métodos construtores.

·Trabalhar com o polimorfismo de sobrecarga: Operadores e Métodos.
·Desenvolver programas apresentando a aplicação do conceito de polimorfismo
de sobrecarga.

Estratégias de Aprendizagem
Implementar programas em Java, explorando os conceitos de polimorfismo de
sobrecarga.

Exemplo de Sobrecarga de métodos de construtores

Classe: Carro

import java.util.Scanner;

public class Carro {

// use as regras da boa prática em programação Java

// para os identificadores da classe, dos atributos e dos métodos

String fabricante, modelo, cor, placa;

double valor;

int numeroPortas, anoFabricacao, anoModelo;

public Carro() { }

public Carro(String placa, double valor) {

this.placa = placa;

this.valor = valor;

public Carro(String modelo, String cor, String placa, double valor) {

this.modelo = modelo;
this.cor = cor;

this.placa = placa;

this.valor = valor;

public Carro(String fabricante, String modelo, String cor,

String placa, double valor) {

this.fabricante = fabricante;

this.modelo = modelo;

this.cor = cor;

this.placa = placa;

this.valor = valor;

public Carro(String fabricante, String modelo, String cor,

String placa, double valor, int numeroPortas,

int anoFabricacao, int anoModelo) {

this.fabricante = fabricante;

this.modelo = modelo;

this.cor = cor;

this.placa = placa;

this.valor = valor;

this.numeroPortas = numeroPortas;

this.anoFabricacao = anoFabricacao;

this.anoModelo = anoModelo;

public String getFabricante () {

return fabricante;

public void setFabricante (String fab) {

if(!fab.isEmpty()) {

fabricante = fab;

public String getModelo () {

return modelo;

public void setModelo (String mod) {

if(!mod.isEmpty()) {

modelo = mod;

public String getCor () {

return cor;

public void setCor (String co) {

if(!co.isEmpty()) {

cor = co;

public String getPlaca () {

return placa;
}

public void setPlaca (String pla) {

if(!pla.isEmpty()) {

placa = pla;

public double getValor () {

return valor;

public void setValor (double val) {

if(val > 0) {

valor = val;

public int getNumeroPortas () {

return numeroPortas;

public void setNumeroPortas (int nump) {

if(nump > 0) {

numeroPortas = nump;

public int getAnoFabricacao () {

return anoFabricacao;

}
public void setAnoFabricacao (int anof) {

if(anof > 0) {

anoFabricacao = anof;

public int getAnoModelo () {

return anoModelo;

public void setAnoModelo (int anom) {

if(anom > 0) {

anoModelo = anom;

public void imprimir (){

System.out.println( "Fabricante : " + getFabricante() );

System.out.println( "Modelo : " + getModelo() );

System.out.println( "Cor : " + getCor() );

System.out.println( "Placa : " + getPlaca() );

System.out.println( "Valor : " + getValor() );

System.out.println( "Número de Portas : " + getNumeroPortas() );

System.out.println( "Ano de fabricação: " + getAnoFabricacao() );

System.out.println( "Ano do Modelo : " + getAnoModelo() );

public void entradaDados () {

Scanner entrada = new Scanner( System.in );

// O objeto Scanner deve ficar local ao método

// o objeto Scanner para entrada de dados não é um atributo do carro

// é apenas um objeto auxiliar a entrada de dados

System.out.println("Digite o Fabricante do carro :");

setFabricante( entrada.nextLine() );

System.out.println("Digite o Modelo do carro :");

setModelo( entrada.nextLine() );

System.out.println("Digite a Cor do carro :");

setCor( entrada.nextLine() );

System.out.println("Digite a Placa do carro :");

setPlaca( entrada.nextLine() );

System.out.println("Digite o Valor do carro :");

setValor( Double.parseDouble( entrada.nextLine()) );

System.out.println("Digite o Número de Portas do carro :");

setNumeroPortas( Integer.parseInt( entrada.nextLine()) );

System.out.println("Digite o Ano de fabricação do carro :");

setAnoFabricacao( Integer.parseInt( entrada.nextLine()) );

System.out.println("Digite o Ano do Modelo do carro :");

setAnoModelo( Integer.parseInt( entrada.nextLine()) );

Aplicação antiga AppCarro

public class AppCarroNovo {

public static void main(String[] args) {

// TODO Auto-generated method stub

Carro car1 = new Carro();

car1.entradaDados();

car1.imprimir();

Carro car2 = new Carro("AAA1A00", 25000);

car2.imprimir();

Carro car3 = new Carro("Logan", "Azul", "ABC1E00", 32000);

car3.imprimir();

Carro car4 = new Carro("Audi", "A5", "Prata", "AUD0I00", 123000);

car4.imprimir();

Carro car5 = new Carro("Fiat", "Argo", "Verde", "ABB1I00", 42000, 5,

2018, 2019);

car5.imprimir();

Indicação de Leitura Específica

Polimorfismo de Sobrecarga de Métodos:

Sobrecarga e sobreposição de métodos em orientação a objetos -

https://www.devmedia.com.br/sobrecarga-e-sobreposicao-de-metodos-em-orientacao-a-
objetos/33066

Métodos Construtores:

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 115 – 116]

Sobrecarga:

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 96 – 97]
Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercício:

A classe Computador possui os atributos e métodos a seguir, crie a classe Computador e a

aplicação AppComputador. A aplicação deverá criar 10 diferentes objetos Computador,
utilizando diferentes construtores para a criação de cada um.

Classe: Computador

Atributos Métodos

Fabricante : texto - Setters para todos os atributos

Modelo : texto - Getters para todos os atributos

Peso : real - Pelo menos 12 métodos construtores

Preço : real - Imprimir () // imprime todos os dados do carro

QuantidadeMemória : inteiro - entradaDados () // entrada de dados pelo teclado

Processador : texto

CapacidadeArmazenamento: inteiro

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.
Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 5
Unidade 2 - Conceitos de orientação a objetos

Tema
Herança

Palavras-chave
Herança, Superclasse, Subclasse, Tipos de Herança

Objetivos
O aluno deverá ser capaz de:

·Compreender o conceito de herança.

· Aplicar o conceito de herança na construção e análise de programas em Java.

Estrutura de Conteúdo
Herança

Mecanismo pelo qual classes compartilham atributos e comportamentos através de um

relacionamento hierárquico.

É uma forma de dizer que uma classe "é um tipo de" outra classe.

Exemplos:

Um professor é um tipo de funcionário.

Um pentágono é um tipo de polígono.

A herança é um conceito muito importante que possibilita que você ao identificar duas ou
mais classes que possuam semelhanças, estas podem ser definidas através de uma
hierarquia, onde os membros comuns as duas ou mais classes passam para uma classe
nova classe conhecida como Superclasse ou classe ?mãe?. Já as classes originais
permanecerão apenas com os membros não comuns e estas classes são denominadas
Subclasses ou classes ?filhas?.

Na herança, temos sempre uma classe definida de forma genérica que, posteriormente, é

refinada em classes mais específicas.

Exemplo :

Um carro é um tipo de veículo.

Podemos ter várias classes específicas para uma mesma classe genérica:

Exemplo :

Um carro é um tipo de veículo

Um caminhão é um tipo de veículo

Cada classe específica possui atributos e comportamentos somente seus, mas também
herda atributos e comportamentos da classe genérica.

Tipos de Herança

1. Herança Simples

Em Java temos apenas a implementação da herança simples. A herança simples se

caracteriza por cada classe herdar sempre de apenas uma outra classe por vez. Devemos
observar que mesmo que tenhamos uma sequência de classes herdando, onde uma herda
da outra, ainda assim, temos a herança simples
1.2. Herança Múltipla

A herança múltipla se caracteriza quando uma mesma classe herda de duas ou mais
classes ao mesmo tempo.
Java não permite a implementação da herança múltipla, mesmo este sendo um conceito
da programação orientada a objetos.

Algumas linguagens de programação não implementam este conceito. A linguagem C++

permite a implementação de herança múltipla, mas Java e C# por exemplo, não permitem
esta implementação.

Herança em Java

Para definir a herança entre duas classes devemos usar a palavra reservada extends na

definição da subclasse.

Exemplo:
 public class Carro extends Veiculo {

private int qtdPassageiros;

private int capacidadeBagagem;

//Note que Carro herda atributos e métodos de Veiculo.

Classe mãe ou superclasse : Veiculo

Classe filha ou subclasse : Carro

Sobrescrita de métodos

Métodos de uma SuperClasse podem ser sobrescritos em suas subclasses, isso implica
que um método descrito na Superclasse poderá ser substituído na Subclasse. Para isso é
importante observar que estes métodos devem possuir as mesmas assinaturas, caso
contrário será usado o conceito de Sobrecarga e não de Sobrescrita.

Sobrecarga X Sobrescrita

 Sobrecarga ou overload : métodos da mesma classe; métodos com assinaturas

diferentes e a chamada do método ocorre em tempo de compilação.
 Sobrescrita ou override : Métodos em classes diferentes em uma hierarquia de
classes; métodos com a mesma assinatura; ocorre em tempo de execução ou
ligação tardia.

Procedimentos de Ensino
Fluxo da aula:

·Trabalhar com o conceito de Herança. Apresentar um estudo de caso e refletir

quais as classes que devem ser implementadas.
· Desenvolver programas apresentando a aplicação do conceito de herança e
sobrescrita.

Estratégias de Aprendizagem
Implementar programas em Java, explorando os conceitos de herança e sobrescrita.
Exemplo de Aplicação de Herança.

Classe Pessoa com o uso do conceito de Herança (SuperClasse):

import java.util.Scanner;

public class Pessoa {

String identidade, nome;

public String getIdentidade() {

return identidade;

public void setIdentidade( String id ) {

if(!id.isEmpty()) {

identidade = id;

public String getNome() {

return nome;

public void setNome( String no ) {

if(!no.isEmpty()) {

nome = no;

public Pessoa() { }

public Pessoa( String id ) {

setIdentidade ( id );

}
public Pessoa( String id, String no ) {

setIdentidade ( id );

setNome ( no );

} // Só podemos criar 3 construtores para a classe Pessoa

public void cadastrar( String id, String no ) {

setIdentidade ( id );

setNome ( no );

public void entradaDados( ) {

Scanner entrada = new Scanner( System.in );

System.out.println( "Identidade :" );

setIdentidade( entrada.nextLine() );

System.out.println( "Nome :" );

setNome( entrada.nextLine() );

entrada.close();

public void imprimir( ) {

System.out.println( "Identidade :" + getIdentidade() );

System.out.println( "Nome :" + getNome() );

Classe PessoaEmpresa com o uso do conceito de Herança (SubClasse de Pessoa e

SuperClasse de Gerente e Funcionário):

import java.util.Scanner;

public class PessoaEmpresa extends Pessoa{

String matricula;
double salario;

public String getMatricula() {

return matricula;

public void setMatricula( String ma ) {

if(!ma.isEmpty()) {

matricula = ma;

public double getSalario() {

return salario;

public void setSalario( double sa ) {

if ( sa >=0) {

salario = sa;

public PessoaEmpresa() { }

public PessoaEmpresa( String id ) {

super ( id );

public PessoaEmpresa( double sa ) {

setSalario ( sa );

public PessoaEmpresa( String id, double sa ) {

super ( id );

setSalario ( sa );

public PessoaEmpresa( double sa, String id ) {

super ( id );

setSalario ( sa );

public PessoaEmpresa( String id, String no, String ma, double sa ) {

super ( id, no );

setMatricula ( ma );

setSalario ( sa );

public void cadastrar( String id, String no, String ma, double sa) {

super.cadastrar(id, no);

setMatricula ( ma );

setSalario ( sa );

public void entradaDados( ) {

Scanner entrada = new Scanner( System.in );

super.entradaDados();

System.out.println( "Matrídula :" );

setMatricula ( entrada.nextLine() );

System.out.println( "Salário :" );

setSalario ( Double.parseDouble( entrada.nextLine() ) );

entrada.close();
}

public void imprimir( ) {

super.imprimir();

System.out.println( "Matrídula :" + getMatricula() );

System.out.println( "Salário :" + getSalario() );

Indicação de Leitura Específica

Herança

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 284 ? 286]

Herança

FURGERI, Sérgio. Java 8 ? ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 119 ? 124]

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercício:

Uma loja vende 3 tipos de produto: livro, CD e software. Para todos os produtosexiste
código, descrição, preço e peso. Para o CD existe o nome da banda, para o livro existe o
nome do autor e para o software existe a categoria. Para entregar um produto, o cálculo
do frete é feito multiplicando o peso do produto por R$ 6,50. Implemente as classes que
retratam esse cenário.

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 6
Unidade 2 - Conceitos de orientação a objetos

Tema
Agregação e Particionamento

Palavras-chave
Particionamento, Agregação

Objetivos
O aluno deverá ser capaz de:

·Compreender o conceito de Agregação e Particionamento.

·Aplicar os conceitos de Agregação e Particionamento em Java.

Estrutura de Conteúdo
Particionamento

É a decomposição de classes extensas em classes menores, que podem ser melhor

reaproveitadas em outras classes, além de permitir melhor controle e manutenção.

O particionamento de classes nos permite criar objetos menores e mais simples, que
poderão ser reunidos em conjunto, capazes de criar novas classes, maiores e mais
complexas.

Exemplo:

Um computador do tipo Desktop, que é um objeto bem complexo e possui diferentes

partes. Muitas destas partes são usadas por outros objetos também, tal como Notebooks e
Servidores. Um HD (HardDisk), por exemplo pode ser usado por cada um deles, assim
como a placa de vídeo, a placa-mãe, o vídeo, a memória, além de outros dispositivos. Se
formos criar uma classe para representar um Desktop, termos uma classe com muitos
atributos, o que a faria ser grande e complexa, com muitas linhas de código e de difícil
manutenção, uma vez que qualquer mudança necessária teríamos que trabalhar em uma
classe altamente complexa. Outro ponto importante seria a criação das classes Notebook
e Servidor, que seriam igualmente complexas, sem contar que uma alteração em um
único componente que fosse, teríamos que realizar a alteração em todas as três classes
(Desktop, Notebook e Servidor).

Incialmente nossa classe Desktop ficaria com os seguintes atributos:

public class Desktop {

 public String marcaPlacaMae, modeloPlacaMae;

public double precoPlacaMae;

public String tipoProcessador, marcaHD, modeloHD;

public double precoHD;

public String tipoHD;

public int capacidadeHD;

public String marcaPlacaVideo, modeloPlacaVideo;

public double precoPlacaVideo;

public String padrao, marcaMemoria, modeloMemoria;

public double precoMemoria;

public String tipoMemoria;

public int capacidadeMemoria;

Trabalhando com o particionamento, podemos então dividir a classe Desktop, grande e

complexa, em classes menores e mais simples.

·Placa-mãe (PlacaMae)
· Disco Rígido (HD)
· Placa de vídeo (PlacaVideo)
· Memória (Memoria)

A classe Desktop decomposta ficará da seguinte forma, com seus atributos:

Assim, vamos criar as classes separadamente, dividindo a classe Desktop conforme
proposto:

public class PlacaMae {

public String marca, modelo, tipoProcessador;

public double preco;

public class HD {

public String marca, modelo, tipo;

public double preco;

public int capacidade;

public class PlacaVideo {

public String marca, modelo;

 public double preco;

public int capacidade;

public class Memoria {

public String marca, modelo, tipo;

public double preco;

public int capacidade;

Agregação

A reunião de uma ou mais classes para formar novas classes é chamado de agregação.
Uma nova classe pode ser formada por um conjunto de diferentes objetos.

Seguindo o exemplo anterior, poderíamos reaproveitar as classes PlacaMae, HD,

PlacaVideo, e Memoria para criar novas classe como Desktop, Notebook e Servidor,
como nos exemplos a seguir:

public class Desktop {

public String tipoCooler;

public PlacaMae pm = new PlacaMae();

public PlacaVideo pv = new PlacaVideo();

public HD hd = new HD();

public Memoria me = new Memoria();

public class Notebook {

public double peso;

public PlacaMae pm = new PlacaMae();

 public PlacaVideo pv = new PlacaVideo();

public HD hd = new HD();

public Memoria me = new Memoria();

public class Servidor {

public int numeroPlacasRede;

public PlacaMae pm = new PlacaMae();

public PlacaVideo pv = new PlacaVideo();

public HD hd = new HD();

public Memoria me = new Memoria();

Visando melhorar as classes podemos aplicar o conceito de herança.

Procedimentos de Ensino
Fluxo da aula:

· Trabalhar com o conceito de Particionamento e Agregação

· Desenvolver programas apresentando a aplicação do conceito de
Particionamento e Agregação.

Estratégias de Aprendizagem
Implementar programas em Java, explorando os conceitos de herança e sobrescrita.

Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados em aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 7
Unidade 2 - Conceitos de orientação a objetos

Tema
Encapsulamento

Palavras-chave
Encapsulamento, Modificadores de acesso, Public, Protected, Private, Package

Objetivos
O aluno deverá ser capaz de:

· Enumerar as vantagens da utilização da técnica de encapsulamento.

· Demonstrar a aplicação do conceito de encapsulamento.

Estrutura de Conteúdo
Encapsulamento

Uma classe encapsula atributos e métodos, ocultando os detalhes de implementação dos

objetos.

Princípio do desenvolvimento orientado a objetos: o encapsulamento determina que a

implementação de um objeto somente deve ser acessada através de uma interface visível
e bem definida.

Os atributos não podem ser manipulados diretamente. Os atributos podem ser alterados
ou consultados somente através dos métodos do objeto.

O objeto deve se comportar como uma caixa preta, que realiza determinadas operações
mas que o usuário da classe não sabe e não precisa saber exatamente como ocorre.

O encapsulamento separa os chamados membros visíveis (com acesso) de um objeto dos

membros invisíveis (sem acesso) da classe.

Tipos de visibilidade de membros de uma classe:

· public - A classe, método ou atributo, é sempre acessível a todos os métodos

de quaisquer outras classes.

· private - A classe é definida como classe de suporte, já seus métodos e

atributos, são acessíveis somente por membros da própria classe. É o nível
mais rígido do encapsulamento.
 · protected - Os métodos e atributos, são acessíveis pelos membros da própria
classe e também pelas suas subclasses (herança).

· omissão (pakage) - A classe, método ou atributo, é acessível somente por

métodos das classes que pertencem ao mesmo pacote (pakage).

Procedimentos de Ensino
Fluxo da aula:

·Trabalhar com o conceito de encapsulamento.

· Desenvolver programas apresentando os modificadores de acesso.

Estratégias de Aprendizagem
Implementar programas em Java, explorando os conceitos de modificadores de acesso.

Indicação de Leitura Específica

Encapsulamento:

Encapsulamento em Java: Primeiros passos -

https://www.devmedia.com.br/encapsulamento-em-java-primeiros-passos/31177

Encapsulamento:

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 110 – 114]

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados em aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 8
Unidade 2 - Conceitos de orientação a objetos

Tema
Classes Abstratas e Interfaces

Palavras-chave
Classes Abstratas, Interfaces, Implements

Objetivos
O aluno deverá ser capaz de:

· Compreender o conceito de classe abstrata.

· Aplicar o conceito de classe abstrata na construção de programas em Java.

· Compreender e aplicar o conceito de interface.

Estrutura de Conteúdo
Classe Abstrata

São classes que representam abstrações e não objetos concretos do mundo que
estamosrepresentando.

São usadas como moldes para a criação de outras classes e podem encapsular atributos
ecomportamentos comuns.

No exemplo da concessionária temos:

Carro é um tipo de Veículo

Caminhão é um tipo de Veículo

Veículo possui modelo e ano de fabricação

Perguntas:

1. Se algum cliente entrar na concessionária e pedir para comprar um Veículo, o

vendedor saberá o que deve vender?
2. Se a concessionária anunciar que está vendendo um Veículo, o cliente tem
condições de saber exatamente o que está comprando ?

Isso ocorre porque Veículo é uma abstração para Carro e Caminhão nessaconcessionária.
Classes abstratas são definidas em Java com o uso da palavra abstract na sua definição.

Por não representarem objetos concretos, classes abstratas não podem ser criadas com o
operador new.

Exemplo :

public abstract class Veiculo {

protected String modelo;

protected int anoFabricacao;

public Veiculo(String modelo, int anoFabricacao) {

this.modelo = modelo;

this.anoFabricação = anoFabricacao;
}

Veiculo v = new Veiculo(“gol", 2011); //ERRO de compilação

 Métodos definidos nas classes abstratas, mas não implementados são chamados
métodos abstratos.
 As classes concretas derivadas da classe abstrata devem, obrigatoriamente, definir
esses métodos e de preferência implementá-los, caso contrário, nada ocorrerá ao
chamá-los.
 Para verificarmos a instância referenciada por uma variável, em tempo de
execução, usamos o operador instanceof.
 Para evitar que sejam criadas sub-classes a partir de uma classe podemos defini-la
com o modificador final.
 Podemos usar o modificador final para evitar que um método seja sobrescrito
pelas sub-classes.

Interface

Interface é um recurso muito utilizado em Java. Assim, boa parte da API do Java
éformada por Interfaces.

Uma definição de interface inicia com a palavra interface e contém um conjunto de

métodos públicos abstratos e/ou constantes públicas estáticas.

Uma classe indica que vai implementar uma interface através da palavra implements.
Dessa forma, a classe tem que definir todos os métodos da interface. Caso a classe não
defina os métodos da interface, ocorrerá erro de compilação, indicando que a classe deve
ser abstract.
Exemplo:

public interface Autenticavel {

public boolean autenticar(String login,String senha); //Note : Sem corpo.

public class Cliente implements Autenticavel {

public boolean autenticar(String login, String senha) {

// aqui escreve o código que implementa o metodo

// para o cliente

Implementar uma interface é como assinar um contrato com o compilador que declara:

" Definirei todos os métodos especificados pela interface." Fonte : Deitel & Deitel

Uma classe pode implementar várias interfaces. É só separar o nomes das interfaces por
vírgula.

É permitido que uma mesma classe use o extends e o implements ao mesmo tempo. Ou
seja, a classe herda de uma classe mãe e implementa uma ou mais interfaces.

Não se pode criar objetos usando uma interface. No entanto, é possível ter variáveis do
tipo da interface referenciando objetos.

Exemplo:

Autenticavel a;

a = new Cliente();

a.autenticar(“joao”, “123”); //Chama o método autenticar() do Cliente

A definição de Interfaces deve seguir algumas regras:

1. Interfaces não podem ter construtores;

2. Interfaces só podem ter membros públicos (private e protected não são

permitidos);

3. Interfaces não podem implementar métodos, somente defini-los;

 4. Interfaces não podem ter atributos, somente constantes;

5. Uma Interface pode estender outra interface (com extends) para criar uma
hierarquia de interfaces.

6. Importante: as constantes definidas em uma interface são herdadas pelas

classes que implementam essa interface. Entretanto, como elas são públicas,
elas podem ser usadas em qualquer lugar.

Procedimentos de Ensino
Fluxo da aula:

· Trabalhar com o conceito classes abstratas.

· Trabalhar com o conceito de interface.
· Desenvolver programas aplicando os conceitos de classes abstratas e interface.

Estratégias de Aprendizagem
Realizar exercícios práticos que envolvam a criação e análise de programas que
implementem classe abstrata e interface.

Indicação de Leitura Específica

Classes e Métodos Abstratos:

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 316 – 317]

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 128 – 131]

Interfaces

FURGERI, Sérgio. Java 8 – ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015. [Páginas: 131 – 134]

Recursos
Quadro branco e marcadores para quadro branco coloridos.
Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercício:

Considere, conforme especificado abaixo, a superclasse abstrata Empregado e suas sub-

classes concretas Chefe, Comissionado e Horista, além da main fornecida. Depois, faça o
que se pede, sabendo ainda que qualquer empregado recebe um salário semanal acrescido
ou não de um extra, dependendo se é chefe ou comissionado. O salário do horista, no
entanto, está de acordo com o número de horas trabalhadas e o valor da hora.

Classe Abstrata: Empregado

Atributos privados: primeiroNome e ultimoNome (ambos String)

Construtor: Deverá receber o primeiro e último nomes

Métodos concretos:

1) getPrimeiroNome()
2) getUltimoNome()
3) toString() è retorna o primeiro nome seguido do último nome
Método abstrato: getSalario()

Objetivo: retornar o salário semanal (double)

Classe concreta: Chefe

Atributo privado: salarioSemanal (double)

Construtor: Deverá receber todos os dados necessários p/a construção de um chefe.

Métodos:

1) setSalarioSemanal
2) toString() è retorna ?Chefe : ? seguido do primeiro nome, que
por sua vez, deverá ser seguido do último nome
3) para retornar o valor do salário semanal do chefe.
Classe concreta: Comissionado

Atributos privados: salarioSemanal (double), comissao (double) e quantidade (int)

Construtor: Deverá receber todos os dados necessários à construção de um comissionado.

Métodos:

1) setSalarioSemanal

2) setComissao

3) setQuantidade

4) toString() - retorna “Comissionado : “ seguido do primeiro nome, que deverá

ser seguido do último nome

5) calcular o salário do comissionado e retorná-lo. Para este cálculo, usa-se o

salário semanal, acrescido do resultado de comissão x quantidade.

Classe concreta: Horista

Atributos privados:

· peso (double) - remuneração paga por hora

· horas (double) - número de horas trabalhadas por semana

Construtor: Deverá receber todos os dados necessários à construção de um

horista.

Métodos:

1) setPeso

2) setHoras

3) toString() - retorna ?Horista: ? seguido do primeiro

nome, que deverá ser seguido do último nome

4) calcular o salário do horista, conforme já especificado.

Monte uma classe teste conforme abaixo. Observe o uso do método printf que permite
formatar o número de casas decimais.

public class ExemploClasseAbstrataEmpregadoTeste {

public static void main(String[] args) {

Empregado e;

Chefe cf = new Chefe("João", "Silva",1000.0);

Comissionado c = new Comissionado ("Maria", "Silva", 400.0, 3.0, 150);

Horista h = new Horista("Pedro","Silva",15.00, 40);

e = cf ; // empregado recebe chefe - referência Empregado para um Chefe

System.out.printf("\n%s recebeu R$%.2f\n", e.toString(), e.getSalario());

System.out.printf("\n%s recebeu R$%.2f\n",cf.toString(),cf.getSalario());

e = c;

System.out.printf("\n%s recebeu R$%.2f\n", e.toString(), e.getSalario());

System.out.printf("\n%s recebeu R$%.2f\n", c.toString(), c.getSalario());

e = h;

System.out.printf("\n%s recebeu R$%.2f\n", e.toString(), e.getSalario());

System.out.printf("\n%s recebeu R$%.2f\n", h.toString(), h.getSalario());

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 9
Unidade 3. Tratamento de Exceções

Tema
Tratamento de Exceções

Palavras-chave
Exceção, try/catch, finally, throw, throws

Objetivos
O aluno deverá ser capaz de:

·Compreender o conceito de exceção.

· Compreender e aplicar o conceito de captura de exceção com try/catch.

· Compreender e aplicar o conceito de lançar exceção com throw.

· Compreender e aplicar o conceito de declarar exceção com throws.

Estrutura de Conteúdo
Introdução

Como tratar, em Java, as seguintes situações?

 Divisão por zero.

 Erro na conversão de tipos (por exemplo, converter uma string que só contém
letras em número).
 Erro na abertura de um arquivo, entre outros.

Todas essas situações em Java são chamadas de exceções e existe um mecanismo

específico para tratá-las.

Exemplo:

public class DividePorZero {

public static void main(String args[]) {
System.out.println(3/0);
 System.out.println("imprime");
}
}
Observamos a seguintes mensagens:

Exception in thread "main" java.lang.ArithmeticException: / by zero at

DividePorZero.main(DividePorZero.java:3)

Note:

java.lang.ArithmeticException: nome da exceção

/ by zero: descrição da exceção
Ocorreu na main, no arquivo DividePorZero.java linha 3.

As exceções em Java estão organizadas em uma hierarquia de classes : No topo da

hierarquia temos a classe Throwable. Suas classes filhas são Error e Exception. Veja a
hierarquia completa em aula com seu professor.

O que acontece quando ocorre uma exceção?

1) O método cria um objeto do tipo Exception e o envia para a JVM:

·Esse processo é chamado de "disparar uma exceção" (throw an exception)
·O objeto Exception criado contém todas as informações sobre o erro: seu
tipo, o local onde ocorreu, uma mensagem de descrição, a pilha de
chamadas, etc.
2) A JVM procura na pilha de chamadas dos métodos quem trata aquela exceção e
não encontra.
O tratamento de exceções é um mecanismo que permite que o programa defina como as
situações inesperadas serão tratadas.

Com relação ao tratamento de exceções temos:

1. Blocos try...catch...finally
2. Comando throws
3. Comando throw
Bloco try...catch

try {
// Código a ser tratado
} catch(Exception e) {
// Código que será executado quando ocorrer a exceção
 }
Nota:

1. Se ocorrer uma exceção no bloco do try, então a execução é automaticamente

desviada para o bloco catch.
2. No catch devemos definir a exceção a ser tratada. Quando definimos uma exceção
estamos tratando também todas as suas subclasses.
3. O e, mostrado na linha do catch, referência a exceção que ocorreu. Com ela é
possível acessar informações sobre essa exceção.

Exemplo: Trecho de programa em Java

int a, b, c;
Scanner t = new Scanner(System.in);
try {
a = t.nextInt();
b = t.nextInt();
c = a / b;
System.out.println(a + " / " + b + " = " + c);
} catch(Exception e) {
System.out.println("Erro: " + e.getMessage());
}
Que exceções podem acontecer?

 Usuário digitar um número inválido para a

 Usuário digitar um número inválido para b
 Usuário digitar ZERO para b

Ao tratar várias exceções ... Os tratadores devem estar ordenados das subclasses para a

superclasse.

Bloco try...catch..finally

try {
// Código a ser tratado
} catch(Exception e) {
System.out.println("Erro: " + e.getMessage());
} finally {
 // Esse código será sempre executado, independente
// se houve exceção ou não
}
Nota:

1. A variável e referência a exceção que ocorreu. Com ela é possível acessar

informações sobre essa exceção, como por exemplo, com o uso do método
getMessage.
2. finally não é obrigatório. Deve ser usado para instruções de "limpeza".
As exceções do Java são classificadas como checked ou unchecked.

Para as exceções checked, o Java nos obriga a:

1. Tratar a exceções no método onde ela pode ocorrer

OU

1. Avisar que estamos cientes de que aquela exceção pode ocorrer, mas não
desejamos tratá-la.

-Para a opção 1 implementamos o bloco try...catch visto

anteriormente.
-Para a opção 2 usamos o comando throws
Exemplo:

Se escrevermos um programa para ler e imprimir arquivo texto ocorrerá exceção do tipo
FileNotFoundException ou IOException. Note que, neste caso, o Java não compila esse
código ! Para conseguirmos compilar usamos throws.

public class ImprimeArquivo {

public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("arquivo.txt");
BufferedReader f = new BufferedReader(fr);
String linha;
linha = f.readLine();
while (linha != null) {
System.out.println(linha);
linha = f.readLine();
}
f.close();
 }
}
Note que usou-se throws e agora, o programa será compilado.

Como tratar situações de erro que são específicas dos nossos programas?

Exemplo:

Para construir um retângulo, que valores seriam inválidos?

public Retangulo(int x, int y, int largura, int altura)

Note: Largura e altura devem ser maiores que zero.

Como podemos tratar a situação onde Largura ou Altura é menor ou igual a zero?

Resposta: Criando e disparando exceções!

Veja como:

· Criamos uma instância da classe Exception com o operador new;

· Disparamos a exceção com o comando throw;
· Declaramos que o método irá disparar uma exceção com o comando throws.
A classe Exception é a classe mãe de todas as exceções que nos interessa. Ela possui
alguns métodos úteis e comuns a todas as exceções:

· Construtor Exception(String msg): permite criar uma exceção e armazenar a

mensagem de erro.
· getMessage(): retorna a mensagem de erro.
· printStackTrace(): imprime a pilha de chamadas no mesmo formato da JVM.
· getStackTrace(): retorna a pilha de chamadas. Nesse caso você pode
implementar a sua própria impressão ou salvar essa informação em outro local
ou formato (por exemplo, para montar um log de erros).
Exemplo:

Se depararmos com uma situação na qual o objeto não pode ser criado, disparamos uma
exceção:

public class Retangulo {

private int x, y, largura, altura;

public Retangulo(int x, int y, int largura, int altura) throws Exception

{
if (largura <= 0 || altura <= 0)

throw new Exception("Retangulo deve ter largura e altura maior que zero");

this.x = x;
this.y = y
this.largura = largura;
this.altura = altura;
}

Nota: Se largura ou altura forem menores ou iguais a zero a execução do construtor será
interrompida e a exceção será disparada.

Classes de exceção que devem ser trabalhadas no curso: NullPointerException,

InputMismatchException, NumberFormatException, ArrayIndexOutOfBoundsException,
ArithmeticException.

Procedimentos de Ensino
Fluxo da aula:

 Motivar o estudo de exceções com situações clássicas de erros, como entrada

inválida, divisão por zero ...
 Realizar exercícios práticos variados que envolvam a criação e/ou análise de
programas que apliquem os conceitos vistos.

Estratégias de Aprendizagem
Realizar exercícios práticos que envolvam a criação e análise de programas que
implementem tratamento de exceções.

Indicação de Leitura Específica

Tratamento de Exceções

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 201 – 202]
Tratamento de Exceções em Java - https://www.devmedia.com.br/tratando-excecoes-em-
java/25514

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercício:

1) Escreva um programa em Java que leia números inteiros positivos e imprima o

somatório desses números. O programa deve parar de ler quando o usuário digitar um
número menor ou igual a zero. Faça o tratamento de exceção para o caso do usuário não
digitar um número quando solicitado.

a) 1ª. solução : ler valores com nextInt()

b) 2ª. solução : ler valores com nextLine()

2) Teste o programa e capture a exceção, adequadamente.

import java.util.*;

public class Teste {

static String nome;

static int idade;

public static void main(String[] args) {

System.out.println("\nIdade: " + idade);

System.out.println("\nTamanho do nome : " + nome.length());

} // fim main
} // fim classe

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 10
Unidade 4. Tratamento de Dados Homogêneos

Tema
Tratamento de Dados Homogêneos

Palavras-chave
Vetor, Matrizes, Vetor de Objetos, ArrayList

Objetivos
O aluno deverá ser capaz de:

· Compreender o uso de vetor de tipos primitivos e de vetor de objetos.

· Escrever programas com vetor de tipos primitivos conceito de exceção.

· Realizar aplicações com ArrayList.

Estrutura de Conteúdo
Vetor

Semelhante ao C/C++, o Java também dá suporte a vetores e matrizes multidimensionais.

No entanto, em Java, vetores são objetos.

Para declarar um vetor, usamos [ ] após o tipo desejado:

int [ ] v; ou também int v[ ];

float [] notas; ou também float notas[ ];

Outra diferença importante é que, ao declarar um vetor, NÃO definimos o seu tamanho.

Isso significa dizer que, ao declarar um vetor, o Java NÃO aloca espaço na memória para
o vetor.

Como vetor é um objeto, precisamos criá-lo com o operador new. Nesse momento
definimos o seu tamanho.

float[] nota; //poderia ser float nota[];

nota = new float[10];
O tamanho do vetor pode ser definido usando uma variável ou uma expressão.
Atenção: Se você acessar uma área fora do intervalo do vetor, ocorrerá uma exceção
(ArrayIndexOutOfBoundsException) e a execução do programa será interrompida.

Assim como fazemos com variáveis comuns, também podemos inicializar vetores.

tipo[] nome = { lista de valores };

onde:

lista de valores: é uma lista cujos elementos são separados por vírgula

Exemplo :

float[] nota = { 5.5, 6.5, 7.0, 9.0, 8.0 };

Para criar vetores multidimensionais basta usar mais de uma dimensão na definição e na
criação do vetor:

float[][] matriz;
matriz = new float[10][20];
Usamos length para recuperar o tamanho do vetor.

Existe uma outra sintaxe do comando for para percorrer vetores. Essa forma é usada
apenas para ler os dados do vetor, mas não serve para alterar o vetor.

Exemplo: Aqui estamos usando o for-each. Não é preciso indexar.

public class Vetor {

public static void main(String[] args) {
int[] v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
for (int n : v)
System.out.println(n);
}
}
Observação: Quando trabalhamos com vetor de objetos é preciso criar cada objeto com o

operador new. Este estudo será feito, em detalhes, na aula seguinte.

Vetor de objetos

Quando usamos um vetor de objetos, ao criar o vetor não estamos criando os objetos em
si, mas apenas referências para os objetos.

Além do vetor, cada objeto deve ser criado com o operador new.
 public class EditorGrafico{
public static void main(String[] args) {
Retangulo[] retangulos;
retangulos = new Retangulo[3];
retangulos[0] = new Retangulo(40, 20);
retangulos[1] = new Retangulo(20, 20);
retangulos[2] = new Retangulo(10, 30);
}
}

Generics

Quando recuperamos um objeto de uma coleção temos que usar o cast. Isso ocorre
porque, na sua versão original, essas coleções trabalham com o tipo Object, e os métodos
que retornam dados das coleções também retornam o tipo Object.

Trabalhar com o tipo Object, nesses caso, tem duas desvantagens:

1. Tem que sempre usar o cast para retornar ao tipo original que foi armazenado na
coleção;
2. Possibilita a inserção de objetos "errados" nas coleções (por exemplo, o
programador pode se enganar e inserir um objeto Turma em uma lista de Alunos).

O conceito de Generics veio para resolver esse problema. Podemos definir o tipo a ser
armazenado nas coleções colocando o nome do tipo desejado entre < e > logo após o
nome da coleção:

ArrayList<Aluno> alunos;

ArrayList<Float> notas;

ArrayList<String> palavras;

ArrayList<Veiculo> veiculos;//é possível armazenar carro ou caminhão nesta

//lista

ArrayList<Conta> contas;

Para criar a coleção colocamos os símbolos <> logo após o nome da coleção:

alunos = new ArrayList<>();

notas = new ArrayList<>();

 palavras = new ArrayList<>();

veículos = new ArrayList<>();

contas = new ArrayList<>();

Importante:

Podemos retirar o <> que o código compilará normalmente, mas o compilador Java
emitirá alguns avisos.

· Se tentarmos armazenar objetos de tipos diferentes daquele declarado,

ocorrerá um erro de compilação.

· Ao recuperar um objeto da coleção não precisamos mais do casting, pois o

compilador já sabe que tipo está armazenado na coleção.

Exemplo:

ArrayList<Aluno> alunos = new ArrayList<>();

alunos.add(new Turma(1, "POO")); //Erro de compilação: tipos incompatíveis

Aluno a = alunos.get(5); // Não precisamos do cast, pois o método get()

// retorna Aluno!

Procedimentos de Ensino
Fluxo da aula:

 Trabalhar com vetores, vetores de objetos e ArrayList.

 Realizar exercícios práticos variados que envolvam a criação e/ou análise de
programas que apliquem os conceitos vistos.

Estratégias de Aprendizagem
Realizar exercícios práticos que envolvam a criação e análise de programas que
implementem vetores, vetores de objetos e ArrayList.

Indicação de Leitura Específica

Vetores
DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 192 – 198]

Matrizes

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 213 – 216]

ArrayList

DEITEL, Paul. Java: como programar (Biblioteca Virtual). 10. ed. São Paulo: Pearson,
2017. [Páginas: 225 – 227]

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercício:

1) Escreva um programa em Java para:

·ler o nome do curso.

·ler as notas de uma turma.

·imprimir a média da turma.

·imprimir as notas acima da média.

O programa deverá pedir, inicialmente, o total de notas que serão lidas.

2) Faça um programa em Java que crie uma lista de alunos, sabendo que qualquer aluno
possui nome, matrícula e média. Depois de criada a lista, faça o que se pede:

· imprima todos os dados de todos os alunos.

 · imprima os nomes dos alunos com média abaixo de 6.0.

Avaliação
O aluno deverá resolver exercícios propostos sobre o tema nas referências bibliográficas
ou nas indicações dadas pelo professor da disciplina; ou Pesquisa, onde o professor pode
solicitar a pesquisa de um tema relacionado com os assuntos abordados na aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 11
Unidade 2 - Conceitos de orientação a objetos

Tema
Classe Abstrata e Interface

Palavras-chave
Classe abstrata, abstract, interface, implements

Objetivos
O aluno deverá ser capaz de:

· Compreender o conceito de classe abstrata

· Aplicar o conceito de classe abstrata na construção de programas em Java

· Compreender e aplicar o conceito de interface

Estrutura de Conteúdo
· Classe abstrata / abstract

· Operador instanceof

· Modificador final / Classe final e método final

· Interface

· Aplicar o conceito de interface

>>>>>>>>>>>>>>> Detalhando <<<<<<<<<<<<<<<<<<<<<<<<<<

Classe abstrata

São classes que representam abstrações e não objetos concretos do mundo que estamos
representando.

São usadas como moldes para a criação de outras classes e podem encapsular atributos e
comportamentos comuns.
 No exemplo da concessionária temos:

Carro é um tipo de Veículo

Caminhão é um tipo de Veículo

Veículo possui modelo e ano de fabricação

Perguntas:

Se algum cliente entrar na concessionária e pedir para comprar um Veículo, o

vendedor saberá o que deve vender?

Se a concessionária anunciar que está vendendo um Veículo, o cliente tem

condições de saber exatamente o que está comprando ?

· Isso ocorre porque Veículo é uma abstração para Carro e Caminhão nessa
concessionária.

· Classes abstratas são definidas em Java com o uso da palavra abstract na sua
definição.

· Por não representarem objetos concretos, classes abstratas não podem ser
criadas com o operador new.

Exemplo :

public abstract class Veiculo {

protected String modelo;

protected int anoFabricacao;

public Veiculo(String modelo, int anoFabricacao)

this.modelo = modelo;

this.anoFabricacao = anoFabricacao;

}
}

Veiculo v = new Veiculo("gol", 2011); //ERRO de compilação

· Métodos definidos nas classes abstratas, mas não implementados são

chamados métodos abstratos.

· As classes concretas derivadas da classe abstrata devem, obrigatoriamente,

definir esses métodos e de preferência implementá-los, caso contrário, nada
ocorrerá ao chamá-los.

· Com o mecanismo de herança, nem sempre a instância referenciada por uma

variável é do tipo dessa variável.

Poligono p = new Retangulo(0, 0, 10, 20);

· Para verificarmos a instância referenciada por uma variável, em tempo de

execução, usamos o operador instanceof.

· Para evitar que sejam criadas sub-classes a partir de uma classe podemos
defini-la com o modificador final.
· Podemos usar o modificador final para evitar que um método seja sobrescrito
pelas sub-classes.

Interface

Interface é um recurso muito utilizado em Java. Assim, boa parte da API do Java é
formada por Interfaces.

Uma definição de interface inicia com a palavra interface e contém um conjunto de

métodos públicos abstratos e/ou constantes públicas estáticas.

Uma classe indica que vai implementar uma interface através da palavra implements.
Dessa forma, a classe tem que definir todos os métodos da interface. Caso a classe não
defina os métodos da interface, ocorrerá erro de compilação, indicando que a classe deve
ser abstract.

Exemplo :

public interface Autenticavel {

public boolean autenticar(String login, String senha); //Note : Sem corpo.

 }

public class Cliente implements Autenticavel {

public boolean autenticar(String login, String senha) {

// aqui escreve o código que implementa o metodo

// para o cliente

Implementar uma interface é como assinar um contrato com o compilador que declara :
" Definirei todos os métodos especificados pela interface." Fonte : Deitel & Deitel

· Uma classe pode implementar várias interfaces. É só separar o nomes das

interfaces por vírgula.
· É permitido que uma mesma classe use o extends e o implements ao mesmo
tempo. Ou seja, a classe herda de uma classe mãe e implementa uma ou mais
interfaces.

· Não se pode criar objetos usando uma interface. No entanto, é possível ter
variáveis do tipo da interface referenciando objetos.

Exemplo :

Autenticavel a;

a = new Cliente();

a.autenticar(?joao?, ?123?); //Chama o método autenticar() do Cliente

A definição de Interfaces deve seguir algumas regras:

1. Interfaces não podem ter construtores;

2. Interfaces só podem ter membros públicos (private e protected não são

permitidos);
 3. Interfaces não podem implementar métodos, somente defini-los;

4. Interfaces não podem ter atributos, somente constantes;

5. Uma Interface pode estender outra interface (com extends) para criar uma
hierarquia de interfaces.

6. Importante: as constantes definidas em uma interface são herdadas pelas classes

que implementam essa interface. Entretanto, como elas são públicas, elas podem
ser usadas em qualquer lugar.

Procedimentos de Ensino
1. Aula teórica (2 tempos) e prática (2 tempos)

2. Aula expositiva dialogada, interagindo o máximo com a turma, tanto na hora de expor
o conteúdo, quanto na hora de fazer e corrigir os exercícios.

3. Fluxo da aula :

· Intercalar conceitos e exemplos práticos.

· Realizar exercícios práticos que envolvam a criação e análise de programas que

implementem classe abstrata e interface .

Estratégias de Aprendizagem
Para que o aprendizado seja proveitoso, o aluno deve se envolver ativamente na
participação da aula, deve realizar as tarefas propostas, realizar testes por conta própria
nos programas desenvolvidos e compartilhar sua experiência/conclusão com todos.

Toda tarefa realizada pode ser conferida com o professor, para que haja certeza se está
ou não correta.
Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

1) Considere, conforme especificado abaixo, a superclasse abstrata Empregado e suas
sub-classes concretas Chefe, Comissionado e Horista, além da main fornecida. Depois,
faça o que se pede, sabendo ainda que qualquer empregado recebe um salário semanal
acrescido ou não de um extra, dependendo se é chefe ou comissionado. O salário do
horista, no entanto, está de acordo com o número de horas trabalhadas e o valor da hora.

· Classe Abstrata : Empregado

Atributos privados : primeiroNome e ultimoNome (ambos String)

Construtor : Deverá receber o primeiro e último nomes

Métodos concretos:

1) getPrimeiroNome()

2) getUltimoNome()

3) toString() è retorna o primeiro nome seguido do último nome

Método abstrato : getSalario()

Objetivo : retornar o salário semanal (double)

· Classe concreta : Chefe

Atributo privado : salarioSemanal (double)

 Construtor : Deverá receber todos os dados necessários p/a construção de um
chefe.

Métodos:

1) setSalarioSemanal

2) toString() è retorna ?Chefe : ? seguido do primeiro nome, que

por sua vez, deverá ser seguido do último nome

3) para retornar o valor do salário semanal do chefe.

· Classe concreta : Comissionado

Atributos privados : salarioSemanal (double), comissao (double) e quantidade

(int)

Construtor : Deverá receber todos os dados necessários à construção de um

comissionado.

Métodos :

1) setSalarioSemanal

2) setComissao

3) setQuantidade

4) toString() è retorna ?Comissionado : ? seguido do

primeiro nome, que deverá ser seguido do último nome

5) calcular o salário do comissionado e retorná-lo. Para este

cálculo, usa-se o salário semanal, acrescido do resultado de
comissão x quantidade.

· Classe concreta : Horista

Atributos privados :

· peso (double) è remuneração paga por hora

· horas (double) è número de horas trabalhadas por semana

Construtor : Deverá receber todos os dados necessários à construção de um

horista.
 Métodos :

1) setPeso

2) setHoras

3) toString() è retorna ?Horista: ? seguido do primeiro

nome, que deverá ser seguido do último nome

4) calcular o salário do horista, conforme já especificado.

Monte uma classe teste conforme abaixo. Observe o uso do método printf que
permite formatar o número de casas decimais.

public class ExemploClasseAbstrataEmpregadoTeste {

public static void main(String[] args) {

Empregado e;

Chefe cf = new Chefe("João", "Silva",1000.0);

Comissionado c = new Comissionado ("Maria", "Silva", 400.0, 3.0, 150);

Horista h = new Horista("Pedro","Silva",15.00, 40);

e = cf ; // empregado recebe chefe - referência Empregado para um Chefe

System.out.printf("\n%s recebeu R$%.2f\n", e.toString(), e.getSalario());

System.out.printf("\n%s recebeu R$%.2f\n", cf.toString(), cf.getSalario());

e = c;

System.out.printf("\n%s recebeu R$%.2f\n", e.toString(), e.getSalario());

System.out.printf("\n%s recebeu R$%.2f\n", c.toString(), c.getSalario());

 e = h;

System.out.printf("\n%s recebeu R$%.2f\n", e.toString(), e.getSalario());

System.out.printf("\n%s recebeu R$%.2f\n", h.toString(), h.getSalario());

2) Considere o projeto TestaInterface formado pelas classes Quadrado,

ConjuntoQuadrados e TestaInterface, além da interface Ordenacao. Depois, faça o que
se pede nos itens a, b, c, ao longo do código :

//Classe Quadrado

public class Quadrado

private double lado;

public Quadrado () {

this. lado = 0;

public Quadrado (double l) {

this.lado = l;

public double getLado() {

return lado;

}
 public void setLado(double lado) {

this. lado = lado;

public double calcularArea() {

return (lado * lado);

public double calcularPerimetro() {

return (4 * lado);

public String getNome() {

return "quadrado";

} // fim classe Quadrado

//Classe ConjuntoQuadrados

import java.util.Scanner;

public class ConjuntoQuadrados implements Ordenacao

{
private int n; // No. de quadrados

private Quadrado v[] ; // declara vetor de quadrados

public ConjuntoQuadrados(int quant)

n = quant;

v = new Quadrado[n];

public void inserir()

Scanner teclado = new Scanner(System.in);

double lado;

System.out.print("Entrada dos lados dos quadrados : " );

//Item a)

// Monte o vetor de quadrados com dados obtidos via console.

// Capture exceção se necessário.

public void listar()

System.out.println("\nLados dos quadrados : ");

for (int i = 0; i < v.length; i++)

System.out.println(v[i].getLado());

public void ordenar()

{

// Item b) Implemente o método ordenar, usando algum

// método de ordenação já estudado.

} // fim ordenar

} // fim classe ConjuntoQuadrados

// Classe TestaInterface

public class TestaInterface

public static void main(String[] args)

/*********** Item c) TAREFAS :

1. Crie uma instância de ConjuntoQuadrados com 4 quadrados

2. Invoque o método inserir

3. Liste a coleção de quadrados

4. Ordene a coleção de quadrados

5. Liste a coleção novamente

************************************************************************
*********/

}
// Interface

public interface Ordenacao {

public abstract void ordenar();

GABARITO :

1) Veja com seu professor, por favor.

2)

import java.util.Scanner;

public class ConjuntoQuadrados implements Ordenacao

{
private int n; // No. de quadrados
private Quadrado v[] ; // declara vetor de quadrados

public ConjuntoQuadrados(int quant)

{
n = quant;
v = new Quadrado[n];
}

public void inserir()

{
Scanner teclado = new Scanner(System.in);
double lado;

System.out.print("Entrada dos lados dos quadrados : " );

for (int i = 0; i < v.length; i++)
{
System.out.print("\nLado ? ");
lado = teclado.nextDouble();
v[i] = new Quadrado(lado);

}
}
public void listar()
{
System.out.println("\nLados dos quadrados : ");
for (int i = 0; i < v.length; i++)
System.out.println(v[i].getLado());

public void ordenar()

{
int menor, i, j ; // índices
Quadrado aux; // armazena o dado do vetor

for ( j= 0; j < v.length - 1; j++)

{
menor = j;
for (i = j+1; i < v.length ; i++)
if (v[i].getLado() < v[menor].getLado())
menor = i;

// realizando a troca entre v[j] e v[menor], usando aux (fora do 2º for )

aux = v[j];
v[j] = v[menor];
v[menor] = aux;

}// fim 1º for

} // fim ordenar

} // fim classe ConjuntoQuadrados

///////////////

public class Quadrado

{
private double lado;

public Quadrado () {
this. lado = 0;
}

public Quadrado (double l) {

this.lado = l;
}

public double getLado() {

return lado;
}

public void setLado(double lado) {

this. lado = lado;
}

public double calcularArea() {

return (lado * lado);
}

public double calcularPerimetro() {

return (4 * lado);
}

public String getNome() {

return "quadrado";
}

} // fim classe Quadrado

////////////////////////

public interface Ordenacao {

public abstract void ordenar();

}

////////////////////////////

public class TestaInterface {

public static void main(String[] args) {

/************************* TAREFAS :
1. Crie uma instância de ConjuntoQuadrados com 4 quadrados
2. Invoque o método inserir
3. Liste a coleção de quadrados
4. Ordene a coleção de quadrados
5. Liste a coleção novamente

************************************************************************
*********/

ConjuntoQuadrados c = new ConjuntoQuadrados(4);

System.out.println("\nInserindo ... ");

c.inserir();

System.out.println("\nListando após inserção ... ");

c.listar();

System.out.println("\nOrdenando...");
c.ordenar();

System.out.println("\nListando após ordenação...");

c.listar();

}
}

Avaliação
Testar e criar programas durante a aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 12
Unidade 2 - Conceitos de orientação a objetos

Tema
Classe Abstrata e Interface

Palavras-chave
Classe abstrata, interface

Objetivos
O aluno deverá ser capaz de:

· Realizar tarefa prática com a interface comparable e método compareTo

· Realizar tarefas com herança, classe abstrata e interface

Estrutura de Conteúdo
A interface Comparable possui o método abstrato compareTo declarado na interface da
seguinte forma :

int compareTo(Object o)

Tal método pode retornar :

· -1 (se o objeto em uso for menor que o objeto passado),

· 1 (se o objeto em uso for maior que o objeto passado) e

· 0 (se forem iguais)

Procedimentos de Ensino
1. Aula teórica (2 tempos) e prática (2 tempos)

2. Aula expositiva dialogada, interagindo o máximo com a turma, tanto na hora de expor
o conteúdo, quanto na hora de fazer e corrigir os exercícios.

3. Fluxo da aula :
 · Correção de exercícios, se houver.

- Intercalar conceitos e exemplos práticos.

· Realizar exercícios práticos que envolvam a criação e análise de programas que

implementem classe abstrata e interface .

Estratégias de Aprendizagem
Para que o aprendizado seja proveitoso, o aluno deve se envolver ativamente na
participação da aula, deve realizar as tarefas propostas, realizar testes por conta própria
nos programas desenvolvidos e compartilhar sua experiência/conclusão com todos.

Toda tarefa realizada pode ser conferida com o professor, para que haja certeza se está
ou não correta.

Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercícios :

1) Considere o projeto TestaInterface trabalhado na aula anterior e faça a classe

Quadrado implementar a interface Comparable da linguagem Java. Para isto, neste
caso, é preciso escrever, após o nome da interface, a classe dos objetos que serão
comparados da seguinte forma :

public class Quadrado implements Comparable<Quadrado> { ..... }

Sabe-se que, a interface Comparable possui o método abstrato compareTo declarado na

interface da seguinte forma :
 int compareTo(Object o)

Cientes de que estamos comparando quadrados, implemente este método para retornar :

· -1 (se o objeto em uso for menor que o objeto passado),

· 1 (se o objeto em uso for maior que o objeto passado) e

· 0 (se forem iguais)

Neste exercício, estamos comparando os lados dos quadrados.

2) Usando o projeto anterior TestaInterface, reescreva o método ordenar com o método

compareTo da interface Comparable.

3) Implemente a classe Banco que possui: código, nome e um conjunto de contas (pode
ser conta corrente, conta poupança ou conta especial). Implemente métodos para:

* Listar todas as contas com número e saldo.

* Imprimir o total existente no banco (somatório dos saldos).

Veja que será necessário usar as classes para conta corrente, conta poupança e conta
especial, como solicitado em tarefa da aula 10.

Avaliação
Testar e criar programas durante a aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 13
Unidade 3 - Tratamento de exceções

Tema
Tratamento de exceções

Palavras-chave
Exceção, try/catch , finally, throw e throws

Objetivos
O aluno deverá ser capaz de:

· Compreender o conceito de exceção

· Compreender e aplicar o conceito de captura de exceção com try/catch

· Compreender e aplicar o conceito de lançar exceção com throw

· Compreender e aplicar o conceito de declarar exceção com throws

Estrutura de Conteúdo
· Exceção

· Hierarquia de classes de exceção

· Captura de exceção com try/catch ? uso de finally

· Declarar exceção com throws

· Lançar exceção com throw

>>>>>>>>>>>>>>>>>>>> Detalhando <<<<<<<<<<<<<<<<<<<<<<<

Introdução

Como tratar, em Java, as seguintes situações?

· Divisão por zero

 · Erro na conversão de tipos (por exemplo, converter uma string que só
contém letras em número)

· Erro na abertura de um arquivo etc...

Todas essas situações em Java são chamadas de exceções e existe um mecanismo

específico para tratá-las.

Exemplo :

1 public class DividePorZero {

2 public static void main(String args[]) {

3 System.out.println(3/0);

4 System.out.println("imprime");

5 }

6}

Observamos a seguintes mensagens:

Exception in thread "main" java.lang.ArithmeticException: / by zero

at DividePorZero.main(DividePorZero.java:3)

Note :

java.lang.ArithmeticException : nome da exceção

/ by zero : descrição da exceção

Ocorreu na main, no arquivo DividePorZero.java linha 3.

As exceções em Java estão organizadas em uma hierarquia de classes : No topo da

hierarquia temos a classe Throwable. Suas classes filhas são Error e Exception. Veja a
hierarquia completa em aula com seu professor.
O que acontece quando ocorre uma exceção ?

1) O método cria um objeto do tipo Exception e o envia para a JVM:

· Esse processo é chamado de "disparar uma exceção" (throw an

exception)
· O objeto Exception criado contém todas as informações sobre o
erro: seu tipo, o local onde ocorreu, uma mensagem de descrição, a
pilha de chamadas, etc.

2) A JVM procura na pilha de chamadas dos métodos quem trata aquela exceção e
não encontra.

O tratamento de exceções é um mecanismo que permite que o programa defina como as

situações inesperadas serão tratadas.

Com relação ao tratamento de exceções temos :

1. Blocos try...catch...finally

2. Comando throws

3. Comando throw

Bloco try...catch

try {

// Código a ser tratado

} catch(Exception e) {

// Código que será executado quando ocorrer a exceção

Comentários :

1. Se ocorrer uma exceção no bloco do try, então a execução é automaticamente desviada

para o bloco catch.
2. No catch devemos definir a exceção a ser tratada. Quando definimos uma exceção
estamos tratando também todas as suas subclasses.

3. O e, mostrado na linha do catch, referencia a exceção que ocorreu. Com ela é possível
acessar informações sobre essa exceção.

Exemplo : Trecho de programa em Java

int a, b, c;

Scanner t = new Scanner(System.in);

try {

a = t.nextInt();

b = t.nextInt();

c = a / b;

System.out.println(a + " / " + b + " = " + c);

} catch(Exception e) {

System.out.println("Erro: " + e.getMessage());

Que exceções podem acontecer ?

· Usuário digitar um número inválido para a

· Usuário digitar um número inválido para b

· Usuário digitar ZERO para b

Ao tratar várias exceções ... Os tratadores devem estar ordenados das subclasses para a
superclasse.

Bloco try...catch..finally

try {
 // Código a ser tratado

} catch(Exception e) {

System.out.println("Erro: " + e.getMessage());

} finally {

// Esse código será sempre executado, independente

// se houve exceção ou não

Comentários :

1. A variável e referencia a exceção que ocorreu. Com ela é possível acessar informações
sobre essa exceção, como por exemplo, com o uso do método getMessage.

2. finally não é obrigatório. Deve ser usado para instruções de "limpeza"

As exceções do Java são classificadas como checked ou unchecked.

Para as exceções checked, o Java nos obriga a:

1) Tratar a exceções no método onde ela pode ocorrer

OU

2) Avisar que estamos cientes de que aquela exceção pode ocorrer, mas não
desejamos tratá-la.

· Para a opção 1 implementamos o bloco try...catch visto anteriormente.

· Para a opção 2 usamos o comando throws

Exemplo : Se escrevermos um programa para ler e imprimir arquivo texto ocorrerá

exceção do tipo FileNotFoundException ou IOException. Note que, neste caso, o Java
não compila esse código ! Para conseguirmos compilar usamos throws.
public class ImprimeArquivo {

public static void main(String[] args) throws Exception

FileReader fr = new FileReader("arquivo.txt");

BufferedReader f = new BufferedReader(fr);

String linha;

linha = f.readLine();

while (linha != null) {

System.out.println(linha);

linha = f.readLine();

f.close();

Note que usou-se throws e agora, o programa será compilado.

Como tratar situações de erro que são específicas dos nossos programas ?

Exemplo: Para construir um retângulo, que valores seriam inválidos?

public Retangulo(int x, int y, int largura, int altura)

Note : Largura e altura devem ser maiores que zero.

Como podemos tratar a situação onde Largura ou Altura é menor ou igual a zero?

Resposta: Criando e disparando exceções !

Veja como :
 · Criamos uma instância da classe Exception com o operador new;
· Disparamos a exceção com o comando throw;

· Declaramos que o método irá disparar uma exceção com o comando throws.

A classe Exception é a classe mãe de todas as exceções que nos interessa. Ela possui
alguns métodos úteis e comuns a todas as exceções:

· Construtor Exception(String msg): permite criar uma exceção e

armazenar a mensagem de erro.

· getMessage(): retorna a mensagem de erro.

· printStackTrace(): imprime a pilha de chamadas no mesmo formato da

JVM.

· getStackTrace(): retorna a pilha de chamadas. Nesse caso você pode

implementar a sua própria impressão ou salvar essa informação em outro
local ou formato (por exemplo, para montar um log de erros).

Exemplo :

Se depararmos com uma situação na qual o objeto não pode ser criado, disparamos
uma exceção:

public class Retangulo {

private int x, y, largura, altura;

public Retangulo(int x, int y, int largura, int altura) throws Exception

if (largura <= 0 || altura <= 0)

throw new Exception("Retangulo deve ter largura e altura maior que zero");

this.x = x;

this.y = y

this.largura = largura;
 this.altura = altura;

Nota : Se largura ou altura forem menores ou iguais a zero a execução do construtor

será interrompida e a exceção será disparada

Classes de exceção que devem ser trabalhadas no curso: NullPointerException,

InputMismatchException, NumberFormatException, ArrayIndexOutOfBoundsException,
ArithmeticException.

Procedimentos de Ensino
1. Aula teórica (2 tempos) e prática (2 tempos)

2. Aula expositiva dialogada, interagindo o máximo com a turma, tanto na hora de expor
o conteúdo, quanto na hora de fazer e corrigir os exercícios.

3. Fluxo da aula :

· Motivar o estudo de exceções com situações clássicas de erros, como

entrada inválida, divisão por zero ...

· Intercalar conceitos e exemplos práticos.

· Realizar exercícios práticos variados que envolvam a criação e/ou

análise de programas que apliquem os conceitos vistos

Estratégias de Aprendizagem
Para que o aprendizado seja proveitoso, o aluno deve se envolver ativamente na
participação da aula, deve realizar as tarefas propostas, realizar testes por conta própria
nos programas desenvolvidos e compartilhar sua experiência/conclusão com todos.
 Toda tarefa realizada pode ser conferida com o professor, para que haja certeza se está
ou não correta.

Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos;

Recursos audiovisuais (computador com software específico e data-show);

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java

Aplicação: articulação teoria e prática

1) Escreva um programa em Java que leia números inteiros positivos e imprima o
somatório desses números. O programa deve parar de ler quando o usuário digitar
um número menor ou igual a zero. Faça o tratamento de exceção para o caso do
usuário não digitar um número quando solicitado.

a) 1ª. solução : ler valores com nextInt()

b) 2ª. solução : ler valores com nextLine()

2) Teste o programa e capture a exceção, adequadamente.

import java.util.*;

public class Teste {

static String nome;

static int idade;

public static void main(String[] args) {

 System.out.println("\nIdade: " + idade);

System.out.println("\nTamanho do nome : " + nome.length());

} // fim main

} // fim classe

3) Melhore programas anteriores de outras aulas com a captura de exceção. Use

finally em alguns casos, para treinar.

Avaliação
Testar, analisar e criar programas durante a aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 14
Unidade 4 - Coleções

Tema
Coleções

Palavras-chave
Coleção, ArrayList, Wrapper

Objetivos
O aluno deverá ser capaz de:

· Compreender o conceito e o objetivo do uso de coleções

· Compreender a classe ArrayList

· Realizar aplicações com ArrayList

· Compreender o uso de classes Wrapper

Estrutura de Conteúdo
Introdução

· A linguagem Java possui um conjunto de classes que servem para armazenar,

na memória, coleções de objetos.

· Tais classes possuem a vantagem de não termos que saber, de antemão, a

quantidade de elementos que iremos armazenar (que é uma grande desvantagem
dos vetores).

· Todas as coleções estão definidas no pacote java.util.

· As coleções em Java são definidas a partir de 4 interfaces principais:

· Collection

· Set
 · List: define métodos para manipulação de listas.

· Mapa

· Algumas classes que implementam estas interfaces são : ArrayList,

LinkedList (implementam interface List), entre outras.

Classe ArrayList

O ArrayList é uma classe concreta que implementa a interface List, ou seja, uma lista
de objetos. Cada objeto armazenado no ArrayList possui um índice e através desse
índice, é possível recuperar determinado objeto da lista.

Note que a interface List é sub-interface de Collection.

A interface Collection define vários métodos básicos para manipulação de conjuntos e

listas de objetos:

· boolean add(Object): adiciona um objeto à coleção. Retorna true ou false

para indicar se a operação foi bem sucedida ou não.

· boolean remove(Object): remove o objeto especificado da coleção. Retorna

false se o objeto não pertence à coleção.
· boolean contains(Object): procura por um determinado objeto na coleção e
retorna true ou false, se o objeto existir ou não. A comparação é feita pelo
método equals().

· int size(): retorna a quantidade de objeto presentes na coleção.

· boolean isEmpty(): retorna true se a coleção está vazia ou false caso

contrário.

· void clear(): remove todos os objeto da coleção.

Além dos métodos definidos na interface Collection, a interface List acrescenta mais
alguns métodos importantes:

· void add(índice, Object): adiciona o objeto à coleção na posição do

índice.

· Object get(índice): recupera o objeto de determinada posição da lista (da

mesma forma como é feito com vetores).

· Object set(índice, Object): substitui o objeto da posição do índice pelo

novo objeto. Retorna o objeto que estava armazenado anteriormente.
 · Object remove(índice): remove o objeto de determinada posição da lista.
Retorna o objeto removido.

· int indexOf(Object): retorna o índice da primeira ocorrência de um

objeto ou ?1 se ele não existir na lista. A comparação é feita pelo método
equals().

· int lastIndexOf(Object): retorna o índice da última ocorrência de um

objeto ou ?1 se ele não existir na lista. A comparação é feita pelo método
equals().

É importante notar o efeito dos métodos na lista de objetos :

Método / Descrição :

· boolean add(Object) : Adiciona o objeto sempre no final da lista.

· void add(índice, Object) : Adiciona um objeto na i-ésima posição e move os

objetos subsequentes para a posição posterior (índice deve ter valor de 0 a size()).

· boolean remove(Object) : Remove o objeto da lista e move os objetos

subsequentes para a posição anterior.

· Object remove(índice) : Remove o objeto da i-ésima posição da lista e move

os objetos subsequentes para a posição anterior (índice deve ter valor de 0 a
size()-1).

· Object set(índice, Object) : Substitui o elemento da i-ésima posição pelo

novo objeto (índice deve ter valor de 0 a size()-1).

Exemplo 1: Adicionando e removendo elementos da lista.

import java.util.ArrayList;

public class ExemploArrayList {

public static void main(String[] args) {

ArrayList lista = new ArrayList();

lista.add("Dinardo");

lista.add("Rosa");

lista.add("Dinardo");

lista.add("Rafael");
 lista.add("Luís");

lista.remove("Carlos");

lista.remove("Rafael");

lista.remove("Dinardo");

Exemplo 2: Podemos armazenar objetos de tipos diferentes.

import java.util.ArrayList;

public class ExemploArrayList {

public static void main(String[] args) {

// Definido dessa forma, o ArrayList armazena objetos do tipo Object.

ArrayList lista = new ArrayList();

lista.add("Dinardo");

lista.add("Rosa");

lista.add(10);

lista.add(2465);

lista.add(3.14159);

lista.add('A');

}
Considere lista do exemplo anterior, então podemos ter :

O método get(i) recupera o elemento da i-ésima posição. A primeira posição é ZERO.

System.out.println(lista.get(0));

System.out.println(lista.get(3));

System.out.println(lista.get(4));

System.out.println(lista.get(5));

O método set(i, obj) altera o elemento da i-ésima posição.

lista.set(1, 200);

lista.set(2, "Andre");

O método remove(i) remove o elemento da i-ésima posição.

lista.remove(2);

lista.remove(4);

Para percorrer um ArrayList podemos adotar uma das 3 estratégias:

· for

· for each

· Iterator ou ListIterator

Exemplo : usando um for tradicional.

 import java.util.ArrayList;

public class ExemploArrayList {

public static void main(String[] args) {

ArrayList lista = new ArrayList();

lista.add("Dinardo");

lista.add("Rosa");

lista.add(10);

lista.add(2465);

lista.add(3.14159);

lista.add('A');

for (int i = 0; i < lista.size(); i++)

System.out.println(lista.get(i));

Exemplo: usando um for each.

import java.util.ArrayList;

public class ExemploArrayList {

public static void main(String[] args) {

ArrayList lista = new ArrayList();

lista.add("Dinardo");

lista.add("Rosa");

lista.add(10);
 lista.add(2465);

lista.add(3.14159);

lista.add('A');

for (Object obj : lista)

System.out.println(obj);

Na interface Collection também é definido o método:

· Iterator iterator(): retorna um objeto Iterator que permite

percorrer os objetos da coleção de forma sequencial.

A classe Iterator implementa os seguintes métodos:

· boolean hasNext(): informa se existe um próximo elemento na

coleção.
· Object next(): retorna o próximo elemento da coleção.

Como é possível perceber, o Iterator só permite varrer a coleção em uma única

direção: do início para o fim.

Na interface List também é definido o método:

· ListIterator listIterator(): retorna um objeto ListIterator que permite percorrer

os objeto da lista da frente para trás ou vice-versa.

A classe ListIterator possui todos os métodos da Iterator, mais:

· boolean hasPrevious(): informa se existe um elemento anterior na

lista.
· Object previous(): retorna o elemento anterior da lista.

Como é possível perceber, o ListIterator permite varrer a lista do início para o fim ou
vice-versa.

Exemplo: usando um ListIterator.

 import java.util.ArrayList;

public class ExemploArrayList {

public static void main(String[] args) {

ArrayList lista = new ArrayList();

lista.add("Dinardo");

lista.add("Rosa");

lista.add(10);

lista.add(2465);

lista.add(3.14159);

lista.add('A');

ListIterator it = lista.listIterator();

while (it.hasNext()) {

Object obj = it.next();

System.out.println(obj);

Nos exemplos anteriores armazenamos na lista, objetos já existentes na linguagem Java

(Strings, caracteres, inteiros e reais). Entretanto, podemos armazenar na lista nossos
próprios objetos. Por exemplo, uma lista de objetos de uma classe Aluno.

Exemplo :
public class Aluno {

private int matricula;

private String nome;

public Aluno(int matricula, String nome) {

this.matricula = matricula;

this.nome = nome;

public String toString() {

return String.format("Matricula: %d Nome: %s\n", matricula, nome);

import java.util.ArrayList;

public class ExemploArrayList {

public static void main(String[] args) {

ArrayList alunos = new ArrayList();

alunos.add(new Aluno(123, "Joao"));

alunos.add(new Aluno(456, "Rosa"));

alunos.add(new Aluno(789, "Ana"));

alunos.add(new Aluno(246, "Lucas"));

for (int i = 0; i < alunos.size(); i++)

System.out.println(alunos.get(i));

Importante:
 Para usar os métodos:

o boolean remove(Object)

o boolean contains(Object)

o int indexOf(Object)

o int lastIndexOf(Object)

as classes armazenadas no ArrayList têm que, obrigatoriamente, implementar o método

boolean equals(Object)

Caso esse método não seja implementado, os métodos acima não funcionarão
corretamente. Isso acontece porque os métodos acima usam o método equals para
procurar o objeto desejado.

Classe Wrapper

· Em Java os tipos básicos int, long, byte, short, float, double, char e boolean
não são objetos.

· Entretanto, a maioria das classes da biblioteca Java (como as classes que

implementam as coleções, por exemplo), trabalham somente com objetos.

· Para resolver esse problema foram definidas classes wrapper, ou seja, classes
que encapsulam os tipos básicos para que estes possam ser tratados como objetos.

Classe Wrapper / tipo armazenado na classe

Integer int

Long long

Byte byte

Short short

Float float

Double double
 Character char

Boolean boolean

Na maior parte das vezes, o Java converte o tipo básico em uma classe wrapper
(boxing) ou uma classe wrapper em um tipo básico (unboxing).

Exemplo :

int x = 10;

Integer a = 10;

Integer b = x + 1;

int y = a;

a = a + 1;

b++;

Nas classes wrapper estão definidos métodos para converter tipos básicos em classes
(boxing) e classes em tipos básicos (unboxing).

Classe Tipo básico à Classe Classe à tipo básico

Wrapper
(boxing) (unboxing)

Integer Integer n = Integer.valueOf(10) int x = n.intValue()

Float Float n = Float.valueOf(10.5f) float x = n.floatValue()

Double Double n = double x = n.doubleValue()

Double.valueOf(10.5)
 Long Long n = Long.valueOf(10) long x = n.longValue()

Short Short n = Short.valueOf(10) short x = n.shortValue()

Byte Byte n = Byte.valueOf(10) byte x = n.byteValue()

Character Character c = char ch = c.charValue()

Character.valueOf('A')

Boolean Boolean b = boolean bl =

Boolean.valueOf(true) b.booleanValue()

Quando armazenamos inteiros, reais ou caracteres em uma lista, o Java faz

automaticamente o boxing, ou seja, ele cria objetos usando as classes wrapper e insere
esses objetos na lista.

Exemplo : Seja o trecho abaixo. Note que para armazenar esses valores são usadas as
classes Integer, Double e Character.

ArrayList lista = new ArrayList();

lista.add(10);

lista.add(2465);

lista.add(3.14159);

lista.add('A');

lista.add('C');

Quando temos na lista objetos do tipo Integer, Double, Character, etc., temos que usar o
casting para obter o valor de dentro do objeto.

Exemplo : Seja o trecho abaixo.

ArrayList lista = new ArrayList();

 lista.add(10);

lista.add(2465);

lista.add(3.14159);

lista.add('A');

lista.add('C');

int n1 = (int) lista.get(0);

int n2 = (int) lista.get(1);

double n3 = (double) lista.get(2);

char c1 = (char) lista.get(3);

char c2 = (char) lista.get(4);

As classes wrapper possuem, ainda, métodos estáticos úteis para converter strings em
tipos específicos. Caso a conversão não seja possível, será disparada uma exceção.

Classe Wrapper Conversão de String

Integer int Integer.parseInt(String s)

Float float Float.parseFloat(String s)

Double double Double.parseDouble(String s)

Long long Long.parseLong(String s)

Short short Short.parseShort(String s)

 Byte byte Byte.parseByte(String s)

Procedimentos de Ensino
1. Aula teórica (2 tempos) e prática (2 tempos)

2. Aula expositiva dialogada, interagindo o máximo com a turma, tanto na hora de expor
o conteúdo, quanto na hora de fazer e corrigir os exercícios.

3. Fluxo da aula :

Correção de exercício de aula anterior e retirada de eventuais dúvidas.

· Motivar o estudo de coleções

· Intercalar conceitos e exemplos práticos com testes.

· Realizar exercícios práticos que envolvam a criação e/ou análise de

programas com as classes e métodos ensinados nesta aula.

Estratégias de Aprendizagem
Para que o aprendizado seja proveitoso, o aluno deve se envolver ativamente na
participação da aula, deve realizar as tarefas propostas, realizar testes por conta própria
nos programas desenvolvidos e compartilhar sua experiência/conclusão com todos.

Toda tarefa realizada pode ser conferida com o professor, para que haja certeza se está
ou não correta.

Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Exercícios :

1) Faça um programa em Java que leia strings e armazene-as em uma lista até que o
usuário digite uma string vazia. Não permita que sejam armazenadas strings
duplicadas na lista. Ao final, imprima a lista na ordem inversa.

2) Faça um programa em Java que leia uma string e imprima quantas vezes as letras
de A a Z aparecem na string. Dica: Use uma lista para armazenar as letras lidas e
outra lista para contar quantas vezes as letras aparecem.

GABARITO :

1) Veja com seu professor, por favor.

2)

package ex46;

import java.util.ArrayList;
import java.util.Scanner;

public class Ex46 {

public static void main(String[] args) {

Scanner t = new Scanner(System.in);
ArrayList letras = new ArrayList();
ArrayList contador = new ArrayList();
String str;

// Le a string
System.out.println("Digite uma string:");
str = t.nextLine();

// Retira os espacos do fim e do inicio

str = str.trim();
 // Converte tudo para maiuscula
str = str.toUpperCase();

// Percorre a string caracter por caracter

for (int i = 0; i < str.length(); i++) {
// Pega o caracter da i-esima posicao
char c = str.charAt(i);

// Verifica se caracter esta no intervalo de A a Z

if (c >= 'A' && c <= 'Z') {
// Verificar se a letra ja existe na lista de letras
if (letras.contains(c)) {
// Incrementa o contador da letra
// Recuperar a posicao da letra na lista
int p = letras.indexOf(c);

// Incrementar o contador na posicao P

int cont = (int) contador.get(p);
cont++;
contador.set(p, cont);
}
else {
// Inserir a letra na lista de letras com contador = 1
letras.add(c);

// Inserir o 1 no contador
contador.add(1);
}
}
}

System.out.println("Estatistica:");
for (int i = 0; i < letras.size(); i++)
System.out.printf("%c %d\n", letras.get(i), contador.get(i));
}
}

Avaliação
Testar, analisar e criar programas durante a aula.
Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 15
Unidade 4 - Coleções

Tema
Coleções

Palavras-chave
Coleção, ArrayList, Wrapper, Generics

Objetivos
O aluno deverá ser capaz de:

· Compreender o uso de Generics

· Realizar aplicações com ArrayList

Estrutura de Conteúdo
Generics

Como vimos nos exemplos anteriores, quando recuperamos um objeto de uma coleção
temos que usar o cast. Isso ocorre porque, na sua versão original, essas coleções
trabalham com o tipo Object, e os métodos que retornam dados das coleções também
retornam o tipo Object.

Trabalhar com o tipo Object, nesses caso, tem duas desvantagens:

1. Tem que sempre usar o cast para retornar ao tipo original que
foi armazenado na coleção;

2. Possibilita a inserção de objetos "errados" nas coleções (por

exemplo, o programador pode se enganar e inserir um objeto
Turma em uma lista de Alunos).

O conceito de Generics veio para resolver esse problema. Podemos definir o tipo a ser
armazenado nas coleções colocando o nome do tipo desejado entre < e > logo após o
nome da coleção:
ArrayList<Aluno> alunos;

ArrayList<Float> notas;

ArrayList<String> palavras;

ArrayList<Veiculo> veiculos; //é possível armazenar carro ou caminhão nesta lista

ArrayList<Conta> contas;

Para criar a coleção colocamos os símbolos <> logo após o nome da coleção:

alunos = new ArrayList<>();

notas = new ArrayList<>();

palavras = new ArrayList<>();

veículos = new ArrayList<>();

contas = new ArrayList<>();

Importante: Podemos retirar o <> que o código compilará normalmente, mas o

compilador Java emitirá alguns avisos.

· Se tentarmos armazenar objetos de tipos diferentes daquele declarado,

ocorrerá um erro de compilação.

· Ao recuperar um objeto da coleção não precisamos mais do casting, pois o

compilador já sabe que tipo está armazenado na coleção.

Exemplo:

ArrayList<Aluno> alunos = new ArrayList<>();

alunos.add(new Turma(1, "POO")); //Erro de compilação : tipos incompatíveis

Aluno a = alunos.get(5); // Não precisamos do cast, pois o método get() retorna

Aluno !
Procedimentos de Ensino
1. Aula teórica (2 tempos) e prática (2 tempos)

2. Aula expositiva dialogada, interagindo o máximo com a turma, tanto na hora de expor
o conteúdo, quanto na hora de fazer e corrigir os exercícios.

3. Fluxo da aula :

· Correção de exercício de aula anterior e retirada de eventuais dúvidas.

· Intercalar conceitos e exemplos práticos com testes.

· Realizar exercícios práticos que envolvam a criação e/ou análise de

programas com as classes e métodos ensinados nesta aula.

Estratégias de Aprendizagem
Para que o aprendizado seja proveitoso, o aluno deve se envolver ativamente na
participação da aula, deve realizar as tarefas propostas, realizar testes por conta própria
nos programas desenvolvidos e compartilhar sua experiência/conclusão com todos.

Toda tarefa realizada pode ser conferida com o professor, para que haja certeza se está
ou não correta.

Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática
Exercício : Faça um programa em Java que crie uma lista de alunos, sabendo que
qualquer aluno possui nome, matrícula e média. Depois de criada a lista , faça o que
se pede:

a) imprima todos os dados de todos os alunos.

b) imprima os nomes do alunos com média abaixo de 6.0.

Avaliação
Testar, analisar e criar programas durante a aula.

Considerações Adicionais
PROGRAMAÇÃO I - CCT0827
Semana Aula: 16
Unidades 1 a 4 - Exercícios variados

Tema
Exercícios

Palavras-chave
Orientação a Objetos, herança, polimorfismo, ArrayList

Objetivos
O aluno deverá ser capaz de:

· Aplicar o conhecimento adquirido nas aulas anteriores

Estrutura de Conteúdo
Todo o conteúdo ensinado na disciplina

Procedimentos de Ensino
1. Aula teórica (2 tempos) e prática (2 tempos)

2. Aula expositiva dialogada, interagindo o máximo com a turma, tanto na hora de expor
o conteúdo, quanto na hora de fazer e corrigir os exercícios.

3. Fluxo da aula :

· Correção de exercício de aula anterior, se houver.

· Realizar exercícios práticos diversos que envolvam o máximo de conteúdo

ensinado na disciplina.

Sugestão :

1) Dividir a turma em duplas e solicitar que definam um problema ou situação

do dia a dia para criarem classes que modelem uma hierarquia de classes.

2) Solicitar a implementação dos conceitos de OO, como herança e

polimorfismo.
 3) Solicitar que usem ArrayList e JOptionPane.

Estratégias de Aprendizagem
Para que o aprendizado seja proveitoso, o aluno deve se envolver ativamente na
participação da aula, deve realizar as tarefas propostas, realizar testes por conta própria
nos programas desenvolvidos e compartilhar sua experiência/conclusão com todos.

Toda tarefa realizada pode ser conferida com o professor, para que haja certeza se está
ou não correta.

Indicação de Leitura Específica

Recursos
Quadro branco e marcadores para quadro branco coloridos.

Recursos audiovisuais (computador com software específico e data-show).

Sala de aula e laboratório com computadores.

Ambiente para a linguagem Java.

Aplicação: articulação teoria e prática

Vide item acima ....em Procedimentos de Ensino.

Avaliação
Testar, analisar e criar programas durante a aula.

Considerações Adicionais