Buscar

Aulas_Programacao_I

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Aula 01 - Programacao I.pdf
Programação I
Aula 1: A tecnologia Java
Apresentação
Nesta aula, compreenderemos como surgiu a linguagem de programação Java. Abordaremos como a linguagem Java foi
importante no processo de portabilidade no desenvolvimento de sistemas. Além disso, destacaremos as principais
características da linguagem, o ambiente de desenvolvimento e descreveremos o processo de instalação e criação de um
projeto nas ferramentas IDEs NetBeans e Eclipse.
Objetivos
Conhecer como surgiu a linguagem Java.
Identi�car as principais características da linguagem Java;
Descrever o ambiente de programação Java.
Primeiras palavras
Hoje em dia, o desenvolvimento de sistemas se baseia em vários e diferentes paradigmas, tais como os listados a seguir:
IMPERATIVO
Segue sequências de comandos ordenados segundo uma
lógica.
FUNCIONAL
Trabalha com a divisão de problemas através de funções,
que resolvem separadamente problemas menores e que, ao
serem organizados, resolvem o problema como um todo.
LÓGICO
Voltado ao desenvolvimento de problemas de lógica e
usado em sistemas de inteligência computacional.
ORIENTADO A OBJETOS
De�ne um conjunto de classes para dividir o problema e
realiza a interação entre as diferentes classes para também
resolver o problema como um todo.
 Histórico da linguagem Java 
 Clique no botão acima.
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 à criação de uma linguagem de programação que pudesse ser utilizada em
diferentes sistemas, alterando o paradigma de que uma aplicação só poderia ser desenvolvida para uso em um único
ambiente de hardware e sistema operacional, como era bastante comum na época.
As grandes empresas desenvolviam suas aplicações voltadas para seu ambiente de hardware e software (sistema
operacional - SO), e estas aplicações não eram capazes de serem executadas em diferentes plataformas,
principalmente de outros fabricantes. Se analisarmos a linguagem C, criada junto com o sistema operacional UNIX,
temos uma biblioteca muito vasta de funções, mas poucas são consideradas padrão para atender a diferentes
sistemas; e, mesmo assim, uma aplicação compilada em um sistema operacional (ambiente) não pode ser executada
em outro.
A linguagem Java rompeu este paradigma e passou a permitir que uma aplicação desenvolvida em um ambiente -
hardware + software (SO) - possa ser executada em outro sem necessidade de qualquer outro procedimento. A Sun
Microsystems, ao tomar conhecimento desta ideia, deu total apoio ao seu desenvolvimento e criou um grupo com 13
membros, liderado por James Gosling, que passaram a trabalhar exclusivamente neste projeto. A equipe foi batizada
de “Green Team” e o grupo passou a trabalhar em um conjunto de escritórios fora das dependências físicas da Sun, e
sem qualquer tipo de comunicação com a matriz, durante 18 meses para a concretização desta ideia.
Com a tecnologia Java, as aplicações passaram a ser portáveis de um sistema para o outro, sem nenhuma
necessidade de alteração. Por isso, a�rmamos que a portabilidade é uma das mais importantes características da
linguagem Java.
Ainda naquela época, o grupo já havia antecipado uma nova onda na computação, na convergência entre dispositivos
controlados digitalmente e computadores. Hoje em dia, percebemos bem isso quando analisamos um smartphone,
um dispositivo digital que possui inúmeras funções de computadores; entre elas, podemos destacar a execução de
aplicativos. Inicialmente, a linguagem foi batizada de Oak, pois o grupo tinha como vista da janela do escritório um
carvalho. Posteriormente, a linguagem foi rebatizada como Java, em função do gosto do grupo pelo tipo de café. Por
isso, temos como ícone da linguagem uma xícara de café com sua fumaça característica.
A linguagem é muito poderosa para o desenvolvimento de aplicações, seja para o desenvolvimento de aplicações
menos so�sticadas ou para uso em dispositivos menos complexos que computadores, conhecidos como dispositivos
inteligentes, tais como cafeteiras, micro-ondas, geladeiras e uma gama de outros dispositivos que possam ser
controlados por software. A linguagem ainda é muito e�ciente no desenvolvimento de sistemas de entretenimento
doméstico, dando suporte a streaming de vídeo e televisão digital, que ainda não era tão desenvolvida na época.
A tecnologia Java permite ainda o desenvolvimento de todos os tipos de aplicações, indo do mais simples controle de
um eletrodoméstico, passando por aplicações domésticas, comerciais, de automação, até o desenvolvimento de
aplicações mais complexas, com comunicação de dados e aplicações para supercomputadores.
A linguagem Java teve início ao incorporar a tecnologia Java ao navegador de internet Netscape navigator, em sua
versão de 1995. A tecnologia ganhou a aceitação do mercado e dos desenvolvedores, sendo uma das mais
importantes linguagens de programação para o desenvolvimento de sistemas. São dezenas de milhões de
desenvolvedores Java no mundo e, atualmente, esta tecnologia é encontrada em supercomputadores, servidores,
desktops, notebooks, máquinas de cartões de crédito e débito, robôs, automóveis, jogos eletrônicos, bem como uma
gama de dispositivos digitais, redes e demais tecnologias de programação. A linguagem Java ainda é a linguagem
nativa para o desenvolvimento de aplicações para o Android (sistema operacional para smartphones).
A tecnologia Java foi totalmente gratuita por muito tempo, mas recentemente a Oracle, que passou a deter os direitos
da linguagem após adquirir a Sun Microsystems, está licenciando o uso para empresas com custos. A empresa deve
permitir o licenciamento gratuito somente para desenvolvedores avulsos que criam aplicações pessoais sem custo ou
para simples aprendizado.
Principais características e vantagens da tecnologia Java
Orientada a objetos, com uma grande diversidade de bibliotecas de classes disponível; 
• Independe de plataforma: write once, run everywhere ; 
• Segurança - Mecanismos para sistemas livres de vírus, pacotes para criptogra�a; 
• 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; 
•  Em inglês: escreva uma vez, rode em qualquer lugar. 
• 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 (limpeza de memória); 
• 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.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Plataforma Java
De forma geral, entendemos que plataforma (ambiente de execução) é composta por hardware + software básico (sistema
operacional).
A plataforma Java é de�nida apenas em software e possui dois componentes:
1
Máquina Virtual Java (JVM - Java Virtual Machine)
2
Conjunto de bibliotecas que disponibilizam classes comuns
API Java
"Diferentemente das linguagens convencionais, que são compiladas para código nativo, a linguagem Java é compilada para
"bytecode" (gerando o .class ou .jar), que é executado por uma máquina virtual Java (JVM - Java Virtual Machine)."
O modelo inicial era interpretado. Já o atual trocou a etapa do interpretador por uma 2ª compilação (compilador JIT, isto é, just-
in-time).
A tecnologia Java é composta por três plataformas: 
1. J2SE ou Java SE (Java Standard Edition): base da plataforma, inclui o ambiente de execução e as bibliotecas comuns; 
2. J2EE ou Java EE (Java Enterprise Edition): versão voltada para o desenvolvimento de aplicações corporativas e aplicações
web; 
3. J2ME ou Java ME (Java Micro Edition): versão voltada para o desenvolvimento de aplicações móveis ou embarcadas.
Ambiente de desenvolvimento
Clique nos botões para ver as informações.
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 o suporte para a criação de aplicações em Java. 
 
Exemplo: 
• Javac (compilador Java); 
• Javadoc (utilitário para documentação); 
• Java; 
• Outros.
Java Development Kit (JDK) 
Kit com todos os programas necessários para executar aplicações Java. Faz parte do JDK, mas pode ser instalado
separadamente para execução em máquinas clientes, uma vez que o JDK é voltado para os desenvolvedores. O JRE pode
ser instalado separadamente e dá suporte somente a execução de aplicações, por isso é a versão mais indicada para
instalação nas máquinas clientes que apenas executarão aplicações, não sendo responsáveis pelo seu desenvolvimento.
Java Runtime Environment (JRE) 
Fases de um programa em linguagem Java
O código de um programa Java é
compilado apenas uma vez, gerando
um código intermediário, o bytecode,
que pode ser executado quantas
vezes forem necessárias em qualquer
ambiente que possua uma máquina
virtual Java (JVM) disponível.
Inicialmente a tecnologia Java
realizava uma interpretação completa
do bytecode, mas atualmente o
interpretador realiza uma compilação
just-in-time (compila o bytecode para
o ambiente onde ocorrerá a
execução), permitindo aumentar o
desempenho da aplicação.
Para o desenvolvimento de aplicações em Java é comum o uso de ferramentas IDEs (Integrated Development Environment),
que facilitam a codi�cação e a realização de testes, sendo as mais conhecidas: 
• Eclipse; 
• NetBeans; 
• IntelliJ; 
• BlueJ.
Ambiente de Programação
Existem várias ferramentas para o desenvolvimento de sistemas utilizando a linguagem Java, mas os desenvolvedores têm
preferência pelos IDEs Netbeans e Eclipse. Ambos são gratuitos e podem ser adquiridos pela internet através de download.
É importante que você já tenha instalado o JDK antes de instalar o seu IDE escolhido (Netbeans ou Eclipse).
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Netbeans
Existem dois arquivos diferentes: o primeiro, com o source, contém os códigos fonte no Netbeans e não é o ideal para
trabalharmos o desenvolvimento. A versão adequada para nós é a versão bin, que contém todos os códigos já compilados e
prontos para a execução e desenvolvimento de projetos e aplicações Java.
Em suas últimas versões, o Netbeans não usa instalador, mas você deve descompactar o arquivo do Netbeans (Bin -
executável) em uma pasta em seu computador. Uma vez o Java JDK instalado, você poderá executar o Netbeans
tranquilamente.
Dica
Clique para baixar o Netbeans.
javascript:void(0);
Eclipse
O Eclipse tem como padrão a não necessidade de instalador, pois sua instalação é feita por meio da descompactação do
pacote em uma pasta em seu computador.
É comum para usuários Eclipse instalar em um pendrive e, quando necessário, executá-lo diretamente do mesmo. Atualmente,
procedimento idêntico pode ser feito com o Netbeans.
Dica
Clique para baixar o Eclipse.
Você não precisa e não deve instalar as duas versões, pois elas são concorrentes e possuem o mesmo objetivo. Normalmente,
cada desenvolvedor tem sua preferência por uma delas.
A linguagem Java possui uma base de construção semelhante à linguagem C e, por isso, boa parte de sua estrutura e sintaxe
se assemelha a ela. Desta forma, programadores com conhecimento nesta linguagem tem grande facilidade com a sintaxe da
linguagem Java. Outra importante semelhança está nas estruturas de controle de �uxo, que são construídas da mesma forma
em ambas as linguagens.
Atenção
Cuidado com as diferenças de versões no sistema operacional: se instalar o Java para 64 bits, você deverá usar um IDE (Netbeans
ou Eclipse) de 64 bits. O mesmo para a versão de 32 bits: tanto o Java quanto o IDE deverão ser para 32 bits.
A seguir, aprenderemos a criar uma aplicação Java básica em cada um deles para que você possa escolher o de sua
preferência.
Exemplos de aplicação utilizando o Netbeans
No Netbeans, a prática foi realizada na versão 11 (mais atual):
javascript:void(0);
Tela padrão do Netbeans:
Para criar um novo projeto:
No menu File >New Project.
Tela de criação do projeto:
Para os nossos projetos usaremos sempre Java with Ant e Java Application.
Clique no botão Next para prosseguiremos com a criação do projeto.
De�na o nome do Projeto e o local onde o mesmo será criado.
Clique em Finish para concluir a criação do projeto.
O projeto Exemplo foi criado e automaticamente teremos uma classe inicial para execução da aplicação.
O ambiente está pronto para digitarmos o código da aplicação: preencha o código conforme o exemplo a seguir.
Após o código estar pronto e sem erros, podemos executar a aplicação clicando sobre o “arquivo da classe” com o botão
direito, e em seguida clicar sobre a opção Run �le.
A aplicação executará na parte inferior do Netbeans:
Você poderá fechar outros códigos clicando sobre o X ao lado de cada janela de código para facilitar a criação de novos
programas.
No Eclipse, a prática foi realizada na versão Oxygen (atualizada para março de 2018), mas você poderá utilizar a versão 2019-
03 da mesma forma:
Tela padrão do Eclipse
Para criar um novo projeto:
No menu, clique em File > New, e escolha Java Project.
2) De�na o nome do projeto e o local onde o mesmo será criado.
Vamos conferir se o projeto foi criado:
Podemos conferir no Package Explorer se o projeto Exemplo foi criado.
Uma vez que o projeto foi criado, vamos abri-lo e criar a nossa primeira classe Java, uma aplicação simples apenas para
conhecermos a ferramenta. Posteriormente discutiremos todos os comandos utilizados.
Clique sobre o sinal de maior “>” que aparece ao lado do projeto Exemplo.
Pressione o botão direito do mouse sobre o src (source, onde �cam os arquivos do projeto), New e escolha Class (classe Java).
1. O nome da classe deve começar por letra maiúscula, sem
espaços ou acentuação. O nome da classe deverá ser o
mesmo da classe no código. No caso o exemplo é do
cálculo da média de duas notas, por isso o nome será
Media, começando por maiúsculas e sem acentuação.
2. Como esta classe será uma aplicação, devemos marcar a
opção de aplicação.
3. Depois basta con�rmar com [Finish].
O ambiente está pronto para digitarmos o código da aplicação.
No Eclipse teremos:
Preencha o código todo.
A aplicação será executada na parte inferior do Eclipse:
• Para os testes, é necessário que você responda com os valores das entradas de dados e pressione a tecla [enter].
• As aplicações serão testadas com aplicações em formato texto e não grá�co. A criação de interfaces será outro assunto.
• Você poderá fechar outros códigos clicando sobre o X ao lado de cada janela para facilitar a criação de novos programas,
evitando que alterações ocorram indevidamente em outros projetos.
Agora você já entendeu as características da tecnologia Java e já teve contato com as duas principais ferramentas de
desenvolvimento mais utilizadas pelos desenvolvedores Java. Escolha aquela mais confortável para você e pratique bastante
para aumentar seus conhecimentos e se preparar melhor para o mercado de trabalho.
Pro�ssionalmente, é importante que você conheça mais de uma ferramenta, pois cada empresa possui um conjunto próprio e
nem sempre usam ao mesmo tempo
mais de uma ferramenta para o mesmo propósito. Como não sabemos em qual empresa
iremos trabalhar, é importante conhecermos mais de uma ferramenta, ainda que tenhamos nossa preferência.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
 Atividade
1) Podemos utilizar a tecnologia Java no desenvolvimento de diferentes tipos de aplicações, e dentre elas podemos destacar o
desenvolvimento de aplicações para dispositivos móveis. Em qual sistema operacional para smartphones a linguagem Java é
uma linguagem “nativa”?
2) Avalie cada assertiva no que se refere às características da linguagem Java. 
I. A linguagem Java é mais rápida do que as linguagens de scripts e as compiladas; 
II. A linguagem Java é independente de plataforma; 
III. Problemas de desempenhos são resolvidos com a compilação just-in-time. 
 
Com base em sua análise, marque a opção que apresenta apenas as assertivas corretas.
a) I
b) II
c) III
d) I e II
e) II e III
3) Assinale a opção com a sequência correta das fases de um programa em linguagem Java.
a) Editor – Programa.java – Interpretador – Programa.class - Compilador
b) Editor – Programa.class – Compilador – Interpretador
c) Editor – Programa.class – Interpretador - Compilador
d) Editor – Programa.java – Compilador – Programa.class – Interpretador
e) Editor – Programa.java – Interpretador
Referências
Próxima aula
Tipos de dados 1;
Constantes e variáveis;
Operadores e expressões;
Comando de controle de �uxo;
Estrutura de repetição.
Explore mais
Visite o site o�cial do Java (português).
Conheça os sites para baixar a ferramenta IDE:
Netbeans;
Eclipse;
javascript:void(0);
javascript:void(0);
javascript:void(0);
__MACOSX/._Aula 01 - Programacao I.pdf
Aula 02 - Programacao I.pdf
PROGRAMAÇÃO I
Aula 2: Características da linguagem Java
Apresentação
Trabalharemos, em Java, com os principais conceitos de linguagens de programação, como variáveis, constantes e tipos
de dados. 
Em seguida, abordaremos operadores e expressões, estruturas condicionais e de repetição.  
Ao �nal, desenvolveremos programas simples em Java.
Bons estudos!
Objetivos
Analisar os tipos de dados, constantes e como declarar variáveis em Java;
Identi�car operadores e expressões da linguagem Java;
Apontar os comandos das estruturas condicionais e de repetição;
Desenvolver programas simples em Java.
 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
identi�cadores, comandos de controle de �uxo 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 “;”. Você não usará o ponto e vírgula
quando a instrução for uma codi�cação que irá continuar com um bloco de comandos.
Vejamos um exemplo:
System.out.println(“Mensagem do sistema”);
Os blocos de comandos em Java são delimitados por { (abrir) e } (fechar) chaves, em que a instrução anterior de�ne que todos
os comandos do bloco farão parte desta. Isso irá ocorrer em classes, métodos e instruções de controle de �uxo. 
Exemplo:
if(nota>10.0) {
System.out.println(“Nota inválida”);
}
Como usar a endentação?
Quando desenvolvemos um programa em qualquer linguagem, é comum que utilizemos um conjunto de espaços na frente das
instruções de forma a facilitar a visualização de blocos. Sempre que iniciamos um bloco, devemos começar na próxima linha
com um deslocamento de pelo menos quatro espaços em brando ou uma tabulação (normalmente quatro espaços). Isso
permite que identi�quemos rapidamente que certo conjunto de instruções faz parte de um conjunto que será executado em
bloco. 
Exemplo:
import java.util.Scanner;
public class Exemplo {
// identação do bloco da classe Exemplo
public static void main(String[] args) {
// identação do bloco do método main
// 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();
} // encerramento da identação do bloco do método main
} // encerramento da identação da classe Exemplo
Em todas as linguagens de programação, devemos identi�car variáveis, programas, funções, métodos, parâmetros etc. O ato
de nomear algo em uma linguagem de programação é uma forma de identi�cação da linguagem. Em Java são permitidos
identi�cadores 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 identi�cador.
Java é uma linguagem de programação sensível à caixa (alta ou baixa ou case sensitive). Desta forma, a linguagem faz
distinção entre letras maiúsculas e minúsculas. Mas isso não quer dizer que podemos utilizar qualquer nome como um
identi�cador, pois existem algumas palavras reservadas que não podem ser utilizadas para tal. 
Exemplos de identi�cadores válidos em Java:
identificador
nomeCompleto
NomeCompleto
nota1
_sys_path
$user
Observe que os exemplos 2 e 3 possuem a mesma gra�a, mas, como existe mudança entre caixa alta e baixa, para a
linguagem Java são dois diferentes identi�cadores. 
Palavras reservadas da linguagem Java (não podem ser usadas como identi�cadores); dentre elas podemos destacar:
abstract do implements private tdrow
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this
Atenção
Todas as palavras reservadas começam por letras minúsculas e são palavras do idioma inglês.
 Comentários
O uso de comentários em Java é semelhante ao usado na linguagem C, mas apenas dois destes tipos são iguais nas duas
linguagens, sendo o terceiro tipo somente disponibilizado na linguagem Java.
Vejamos:
Clique nos botões para ver as informações.
// comentário de linha  
Quando usamos duas barras em uma linha de código, todo o seu conteúdo, após as duas barras, é desconsiderado pelo
compilador, o que quer dizer que podemos escrever qualquer conteúdo que o mesmo não será compilado. É muito usado
para deixar informações e avisos do programador no código.
1) Comentário de linha 
/*
comentário de linha
*/
Ao usarmos o comentário de bloco, podemos comentar não apenas um trecho de uma linha, mas todo um conjunto de
linhas. É utilizado quando temos longos trechos de textos com avisos e informações, ou para a depuração do código. Para
a depuração do código, podemos comentar um conjunto de linhas para realizar um conjunto de testes. Neste caso,
podemos comentar um conjunto de instruções ou porque estas instruções estão com problemas e queremos veri�car as
demais. Ou, ao contrário, onde temos um conjunto de instruções já testadas e corretas e queremos apenas testar as
demais. Seja como for, o uso do comentário de bloco é muito usual e comum entre os programadores.
2) Comentário de bloco 
/**
comentário de documentação
*/
O comentário de documentação se difere do comentário de bloco por possuir um asterisco a mais no início, mas ambos
encerram da mesma forma. Existe uma ferramenta na linguagem Java 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.  
Neste caso, usamos este tipo de comentário apenas para descrever avisos e informações das classes, de forma a realizar
a documentação do sistema ainda durante sua fase de criação. Isto permite que o desenvolvedor descreva todo a
documentação
no próprio projeto, facilitando a descrição e a manutenção do sistema. Assim, ao terminar um projeto ou
realizar algum tipo de modi�cação, basta gerar novamente a documentação do sistema que tudo estará atualizado.
3) Comentário de documentação 
 Tipos de dados
A linguagem Java possui nove tipos de dados básicos, sendo oito deles primitivos e um tipo especial.
Primitivos (armazenam apenas valores)
Tipo lógico (boolean)
O tipo lógico só permite dois estados, verdadeiro (true) ou falso (false); em Java ainda é permitido o uso de on e off, ou yes e
no. 
Exemplo:
boolean status = true;
Tipo caractere (char)
O tipo char permite que seja armazenado na memória apenas um caractere e se difere do texto (String) por ser de�nido entre ‘e’.
Quando usamos aspas simples ou plica determinamos apenas um caractere.
Exemplo:
char letra = ‘A’;
 Armazenamento de caracteres de controle
 Clique no botão acima.
Armazenamento de caracteres de controle
Também é possível armazenar caracteres de controle:
Caractere Especial Representação
ʼ\nʼ novalinha
ʼ\rʼ enter
ʼ\u????ʼ especificaum caractere Unicode o qual é representado na forma Hexadecimal.
ʼ\tʼ tabulação
ʼ\\̓ representaum caractere \ (barra invertida)
ʼ\” ʼ representaum caractere “ (aspas)
Atenção
A barra invertida na frente indica que é um caractere especial.
Tipos inteiros (byte, short, int e long)
São quatro diferentes tipos de inteiros, que se diferenciam pela quantidade de bits que cada um ocupa em memória para
armazenar um valor. Isto faz com que, quanto menor a quantidade de bits, maior seja a limitação do valor a ser armazenado.
Entretanto, em ocasiões onde a memória é pouca, devemos trabalhar muito bem com estas diferenças para reduzir o espaço
de memória necessário. O uso mais comum é do int, mas, para números muito grandes ou muito pequenos, devemos usar o
long. Já para economizar memória podemos usar byte ou short, de acordo com o valor que será armazenado.
Tipo de
dado
Quantidade de
bits
Quantidade de
Bytes
Escopo (valores que podem
serarmazenados)
byte 8 1 -2 . . . . 2 - 1
short 16 2 -2 . . . . 2 - 1
int 32 4 -2 . . . . 2 - 1
long 64 8 -2 . . . . 2 - 1
7 7
15 15
31 31
63 63
Tipos reais (�oat e double)
São dois diferentes tipos de valores reais, sendo um de precisão simples (�oat), que ocupa menos espaço de memória, e o de
dupla precisão, que ocupa mais memória. Quanto maior o número de bits para armazenar um valor real, maior será a precisão
deste número dentro do sistema. O uso do �oat é comum quando necessitamos economizar espaço de memória. Em Java,
todo tipo de dado numérico é convertido para double automaticamente por coerção (força a conversão de tipo). Por isso, é
mais indicado, quando não houver falta de espaço de memória, a utilização de double para armazenamento de valores reais.
Tipo de dado Quantidade de bits Quantidade de Bytes
float 32 4
double 64 8
Tipo especial
Tipo texto (String)
O tipo texto (String) não é um tipo primitivo, mas um tipo especial. Na verdade, o tipo String é uma classe e por isso começa
com letra maiúscula, ao contrário dos tipos primitivos, que sempre começam por minúsculas. Este tipo de dado armazena um
conjunto de caracteres, formando palavras ou frases de tamanhos variados. Como classe, veremos mais tarde que elementos
do tipo String possuem métodos que podem realizar ações especí�cas sobre o seu conteúdo. 
Exemplo:
String nome = “João da Silva”;
 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.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Linguagens de programação fortemente tipadas
Obrigam que todas as variáveis e constantes sejam
de�nidas por um tipo de dado.
Linguagens de programação fracamente tipadas
Permitem que variáveis sejam usadas a qualquer
momento, sem a necessidade de terem um tipo
prede�nido. Isso quer dizer que o tipo de dado pode
variar em diferentes partes do programa.
Variáveis são declaradas por meio de um tipo e um identi�cador, 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. 
Exemplos:
int c;
double nota1 = 0; // indica que a variável será inicializada com 0 (zero)
String nomeCompleto;
A de�nição de constantes precisam do modi�cador �nal, que indica que, uma vez que ocorreu uma atribuição a variável, seu
conteúdo não poderá ser mudado. Em Java, constantes podem ser criadas em nomes em minúsculas ou maiúsculas, mas a
boa prática de programação determina que sua identi�cação deve ser toda em maiúsculas. 
Exemplos:
final int IDADEMINIMA = 15;
final double VALORDOLAR = 3.96;
final NOMEEMPRESA = “Super Empreendimentos”;
 Operadores e expressões
Operadores aritméticos
Operador Descrição
= Atribuição
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Restoda divisão inteira (ambos os operandos devem ser inteiros
Atenção
Java sempre realizará a operação inteira quando os operandos forem inteiros, e a operação real ocorrerá caso um ou mais
operando seja real.
Exemplos:
int v = 7 / 2; // o valor atribuído será 3 e não 3.5, porque ambos os operandos são
// inteiros
double v = 7.0 / 2; // o valor atribuído será 3.5, porque o primeiro operando é real.
A mesma lógica serve para variáveis:
int a, b=7, c=2;
a = b / c; // será armazenado 3 em a.
double a, b=7.0, c=2.0;
a = b / c; // será armazenado 3.5 em a.
Podemos alterar o tipo de um operando em uma expressão utilizando o cast, que nada mais é do que informar que o valor
armazenado na variável terá o seu valor em função do tipo alterado. 
Exemplo:
int b=7, c=2;
double a=0;
a = (double) b / c; // o valor de b será convertido para double antes da operação
// e isso fará com que o primeiro operando seja real e desta
// forma a operação será real, armazenado 3.5 em a.
Operadores aritméticos
+=   -=   *=   /=   %=
Exemplo:
int alturaParede = 2.85; // declaração da variável alturaParede
alturaParede += 0.15; // a variável alturaParede terá o valor
// acrescido (somado) em 0.15, sendo
// equivalente a:
// alturaParede = alturaParede + 0.15;
Desta forma, não precisamos colocar o nome da variável duas vezes.
Operadores de Incremento e decremento
Em Java temos os operadores de incremento ++ e de decremento --, que sempre adicionam uma unidade (++) ou subtraem
uma unidade (--). Eles podem ser ainda divididos em pré-incremento e pós-incremento, e pré-decremento e pós-decremento. 
O pré-incremento determina que primeiro seja realizada a operação de incremento e depois é realizada a operação de
atribuição. 
Exemplo:
int a = 20, b=0;
b = ++a; // primeiro a variável a será incrementada de uma unidade, valendo 21,
// depois b receberá o valor de a e assim, também valerá 21.
O pós-incremento determina que antes seja realizada a atribuição para só então ser realizada a operação de incremento. 
Exemplo:
int a = 20, b=0;
b = a++; // primeiro b receberá o valor de a, que é 20 (antes do incremento),
// depois a será incrementado e assim, o valor de a será 21 e o de b será 20.
O pré-decremento determina que primeiro seja realizada a operação de decremento e depois é realizada a operação de
atribuição.
Exemplo:
int a = 20, b=0;
b = --a; // primeiro a variável a será decrementada de uma unidade, valendo 19,
// depois b receberá o valor de a e assim, também valerá 19.
O pós-decremento determina que antes seja realizada a atribuição para só então ser realizada a operação de decremento. 
Exemplo:
int a = 20, b=0;
b = a--; // primeiro b receberá o valor de a, que é 20 (antes do incremento),
// depois a será decrementado e, assim, o valor de a será 19 e o
de b será 20.
Operadores de Relacionais (usados para de�nir condições)
Operador Descrição
== Igualdade/ Comparação
!= Negação
> Maiorque
< Menorque
>= Maiorou igual a
<= Menorou igual a
Exemplos:
1) if(a > b) { ... }
2) while (a <=100) { ... }
3) for (int c =0; c<50; c++) { ... }
Operadores de em Expressões Lógicas
Operador Descrição
! NÃO lógico
&& E lógico
|| OU lógico
São os determinantes das tabelas-verdade. 
Ordem de precedência: !, &&, || 
Exemplos:
if(a > b && c < d) { ... }
while (a <=100 || b == 10) { ... }
if( !a == 15 && b >= 10) { ... }
if( !a == 15 || c > d && b >= 10) { ... }
Pela ordem de precedência: if( (!a == 15) || (c > d && b >= 10)) 
Primeiro será executada a negação (!); depois o e lógico (&&) e por último o ou lógico (||).
Operadores de bits
Operador Descrição
& E entre bits
^ OU EXCLUSIVO entre bits
| OU entre bits
Ordem de precedência: &, ^, |
Exemplo
Veja alguns exemplos dos operadores de bits.
javascript:void(0);
 Comandos de controle de �uxo
Estruturas Condicionais
Primeira estrutura
Se (if):
if (condição) {
// instruções;
}
// A cláusula else é opcional.
Segunda estrutura
if ... else,
if (condição) {
// instruções;
}
else {
// instruções;
}
Terceira estrutura
if ... else if ... else,
if (condição1) {
instruções;
}
else if (condição2) {
instruções;
}
else if (condição3) {
instruções;
}
else {
instruções;
}
Atenção
A cláusula if deve ocorrer apenas uma vez;
As cláusulas else if podem ocorrer: nenhuma, uma ou várias vezes;
A cláusula else só pode ocorrer uma única vez.
switch … case
Estruturas de decisão caracterizadas pela possibilidade de uma variável possuir vários valores diferentes em uma determinada
situação.  
Uma única estrutura switch pode analisar vários diferentes valores para a variável de controle. A variável de controle em Java
pode ser do tipo: inteiro, caractere, ou String. 
A cláusula case pode ocorrer de uma a várias vezes, e a cláusula default é opcional.
Quarta estrutura
Exemplo
Veja alguns exemplos de switch … case.
 Estruturas de Repetição
for
Estrutura de repetição controlada por uma ou mais variáveis contadoras e caracterizada pela existência de três parâmetros,
sendo todos eles opcionais:
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
1
Inicialização da(s) variável(is) de controle
2
Condição sobre a(s) variável(is) de controle para parada das
iterações
3
Passo da(s) variável(is) de controle a cada iteração
javascript:void(0);
for((1)inicialização; (2)condição de controle; (3)passo) {
// instruções
}
Exemplo
1) Repetição controlada por uma variável:
for (int c=1; c<=limite; i++) {
instruções;
}
2) Repetição controlada por duas variáveis:
for (a=1, b=2; a*b<limite; a++, b+=2) {
instruções;
}
3) Repetição sem �m
for ( ; ; ) {
instruções;
}
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.
// realiza o teste da condição no início da estrutura
while (condição) {
instruções;
}
do ... while
Esta estrutura de repetição é semelhante à anterior, mas com o diferencial de que as condições devem ser veri�cadas apenas
no �nal da estrutura, obrigando que as instruções sejam sempre executadas pelo menos uma vez.
// Teste de condição no final
do
{
instruções;
} while (condição);
 Entrada e Saída de dados
Entrada de dados
Em Java temos muitas formas de entrada de dados, inclusive de forma grá�ca. Inicialmente trabalharemos com a classe
Scanner, responsável pela entrada de dados em formato texto, com perguntas diretas ao usuário e a inclusão da resposta em
variáveis do programa. 
Para realizarmos esta tarefa, é necessário que seja criado um objeto da classe Scanner. 
Para isso, devemos importar a classe Scanner antes do início da programação da classe:
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
import java.util.Scanner;
Depois é 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 associados a classe Scanner para a entrada de dados, mas para evitarmos problemas futuros
podemos usar sempre a entrada de dados de texto (nextLine()) e converter o texto para o tipo desejado.
Exemplo
1) Para entrada de texto (String):
String nome;
Nome = entrada.nextLine(); // não precisa de conversão, apenas da entrada.
2) Para entrada de valor real:
double nota1;
nota1=Double.parseDouble(entrada.nextLine());
// a entrada de dados em texto precisa de conversão para double.
3) Para entrada de valor inteiro:
int idade;
idade = Integer.parseInt(entrada.nextLine());
// a entrada de dados em texto precisa de conversão para int.
É aconselhável evitar o uso de métodos como:
1
entrada.nextDouble();
2
entrada.nextFloat();
3
entrada.nextInt();
Estes métodos, quando usados em conjunto, podem fazer com que a aplicação pule alguma entrada de dados, sendo
necessário que seja realizada uma “limpeza de buffer”. Este tipo de problema pode ser contornado ao usar sempre o método
“nextLine()” e a conversão de tipos.
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:
1) Apenas uma mensagem:
System.out.println("Entre com a Nota A1.........: ");
2) Mensagem e conteúdo de variáveis:
System.out.println(" Nome: " + nome + " Idade: " + idade + " Nota 1: " + nota1);
A seguir temos o exemplo completo de um programa que recebe duas notas e apresenta a média.
Exemplo
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();
}
}
 Conversão de tipos
A conversão de tipos em Java pode ser feita por cast ou com o uso de conversão por classes. Ambos já foram vistos em
exemplos anteriores:
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
convertida, 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”);
Pode-se usar ainda:
Byte.parseByte() / Short.parseShort()
 A boa prática em programação Java (BP)
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. Ao seguir estas regras, projetos podem ser desenvolvidos
em paralelo por diferentes programadores, sem que seja necessário que cada componente precise esperar que outros
terminem suas tarefas. Estas regras foram utilizadas na construção da linguagem permitindo que não seja necessário decorar
as sintaxes de instruções Java. Não são obrigatórias, mas permitem a codi�cação melhor de nossas aplicações.
Regras:
1) Variáveis auxiliares, atributos, métodos e objetos devem ser identi�cados 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;
2) Constantes devem ser identi�cadas por letras maiúsculas em todo
o seu nome; mesmo quando temos mais de uma palavra,
todo o identi�cador deve �car em maiúsculas. 
Exemplos:
final int idade;
final int maiorIdade;
final String nome;
final String nomeCompleto;
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 { ... }
 Atividade
1 - Podemos dizer que variáveis são um espaço de memória que reservamos e nomeamos. Assinale a a�rmativa que apresenta
um identi�cador válido em Java:
a) final
b) a&b
c) short
d) $test
e) 1test
2 - Durante o desenvolvimento de um programa em Java, o programador precisa armazenar a idade de uma pessoa (em anos).
Qual o tipo de dados ideal (de forma a ocupar menos bytes de memória) a ser usado?
a) long
b) byte
c) int
d) float
e) short
3 - Assinale a alternativa que apresenta APENAS os exemplos de operadores lógicos em Java.
a) <, >, >=
b) &&, || , !
c) =, >, ||
d) &&, >= , ||
e) +, - , *
4 - Indique a saída fornecida pelo trecho de programa Java abaixo:
int a=2, b=5, c=4, d=3, x;
if( d<=2 && a*2 > d+b)
{ x = a + c * b + c; }
else
{ x = a + b – c * 2; }
System.out.println(x);
a) -1
b) 6
c) 54
d) 26
e) 4
Notas
Referências
Próxima aula
Classes e objetos.
Explore mais
Pesquise na internet sites, vídeos e artigos relacionados ao conteúdo visto.
Em caso de dúvidas, converse com seu professor online por meio dos recursos disponíveis no ambiente de aprendizagem.
__MACOSX/._Aula 02 - Programacao I.pdf
Aula 03 - Programacao I.pdf
Programação I
Aula 3: Classes e objetos
Apresentação
Começaremos a trabalhar com os conceitos de orientação a objetos, com a de�nição de classes, atributos e métodos.
Em seguida, abordaremos os métodos de acesso setters e getters, bem como diferenciaremos os conceitos de classes e
objetos.
Por �m, você desenvolverá suas primeiras aplicações orientadas a objetos.
Objetivos
Analisar os conceitos de classes, objetos, atributos e métodos;
Identi�car os conceitos de métodos de acessos;
Desenvolver aplicações orientadas a objetos.
 Programação orientada 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ções que 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).
Exemplo
Por exemplo, a placa de um automóvel é importante para um sistema de estacionamento, assim como a hora de chegada e saída.
Em alguns casos, o fabricante, modelo e a cor do automóvel poderão ser importantes, mas di�cilmente iremos cadastrar o
número do chassi do mesmo. Como o número do chassi não é facilmente visto e seu cadastramento dependeria da
documentação do automóvel ou de uma análise para a identi�cação, que seria difícil, uma vez que é um identi�cador com muitas
letras e números, acabaria por gerar �las e insatisfação dos clientes.
Entretanto, para o sistema de cadastramento do DETRAN, por exemplo, o número do chassi é uma das informações mais
importantes. Dessa forma, identi�carmos a placa é importante como descritor do automóvel para o sistema de estacionamento,
já o chassi não.
Por isso, devemos analisar cada objeto separadamente e quais são as características importantes para o sistema em que o
objeto será utilizado. Como outro exemplo, podemos notar que a matrícula, nome e CR de um aluno são importantes para o
sistema acadêmico, mas o time para o qual o aluno torce ou sua religião não são. Por isso, os descritores time e religião não
são importantes para o objeto Aluno em um sistema acadêmico.
 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 possui ao ser representado em um sistema computacional, levando em
consideração as cara
Atributos
Atributo é conceitualmente um descritor do objeto e deve representar uma característica dele. O conjunto de atributos do objeto
deve representar todas as características importantes do objeto para o sistema.
Exemplo
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.
O conjunto de métodos de um objeto deve descrever todas as ações (tarefas ou funções) que o objeto poderá realizar dentro
do sistema.
Exemplo
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.
Se consideramos a classe Aluno,
podemos criar a partir desta
classe dezenas, centenas ou
mesmo milhares de objetos
Alunos com características
semelhantes, tais como
matrícula, nome e CR, mas com
propriedades (valores próprios
nos atributos de cada objeto)
diferentes.
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.
Consequentemente, todas as
suas variáveis e objetos não
existirão mais.
EXEMPLO
Aluno.java
// Classe Aluno
public class Aluno { // declaração e início da classe
// 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 imprimir( ){
System.out.println("Matrícula: " + matricula);
System.out.println("Nome : " + nome);
System.out.println("CR : " + cr);
}
} // término da classe
 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 às necessidades de um sistema.
Em cada sistema, temos apenas uma aplicação, que será responsável pela lógica de criação e uso das classes. A comunicação
entre os objetos ocorre por meio de trocas de mensagens, que são expressas com o uso de métodos. Uma aplicação, então,
cria objetos a partir de uma ou mais classes e usa os métodos dos objetos para realizar as ações que atenderão às
necessidades dos usuários.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
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.matricula = "1001";
aluno1.nome = "André";
aluno1.cr = 6.7;
//definindo valores para os atributos do aluno2
aluno2.matricula = "1002";
aluno2.nome = "Maria";
aluno2.cr = 7.5 ;
//definindo valores para os atributos do aluno3
aluno3.matricula = "1003";
aluno3.nome
= "João";
aluno3.cr = 7.0;
//exibindo os valores dos atributos de cada aluno:
aluno1.imprimir();
aluno2.imprimir();
aluno3.imprimir();
}
}
Notas:
1. Cada classe pública (public) deve ser criada em um arquivo próprio e o nome da classe deve ser o mesmo do arquivo. Ou
seja, a classe Aluno deve ser criada no arquivo Aluno.java e a classe da aplicação AppAluno deve ser criada no arquivo
AppAluno.java. No projeto, seja no Eclipse ou no Netbeans, deverão ser criadas duas classes, uma para o Aluno e outra
para a aplicação;
2. Foi criada apenas uma classe Aluno, mas a partir dela poderemos criar quantos objetos quisermos;
3. Na aplicação foram criados três diferentes objetos do tipo Aluno. Isso faz com que cada objeto Aluno (aluno1, aluno2 e
aluno3) seja criado na memória em locais diferentes (endereços) e possuam espaço de alocação de memória diferentes
para cada atributo de cada objeto;
4. Cada objeto criado é independente do outro e possui valores próprios para os seus atributos (propriedades). Como a ação
é realizada pelo objeto, cada método fará a ação sobre os atributos do objeto indicado, evitando que haja qualquer tipo de
alteração indevida nos valores de cada um.
 A classe Aluno e os objetos criados a partir dela.
 Biblioteca de classes e reaproveitamento de código
A classe Aluno passou a ser uma biblioteca, e esta
classe pode ser reutilizada em diversas outras
aplicações. Esse conceito é um dos mais importantes
na programação orientada a objetos, pois reduz o
trabalho. Qualquer classe criada poderá ser
reaproveitada inúmeras vezes por diversas aplicações,
poupando esforço de desenvolvimento e facilitando a
manutenção.
Cada classe criada se torna uma parte da sua biblioteca
de classes e, conforme você vai criando novas classes,
a sua biblioteca tende a aumentar. Dessa forma,
quando você for criar novas aplicações, terá à sua
disposição uma séria de classes já prontas e
disponíveis para reaproveitar, sem precisar de novas.
Se você precisar realizar qualquer melhoria em uma classe da sua biblioteca, você poderá realizar sem problemas, pois
qualquer inclusão não afetará o uso desta classe nas aplicações antigas, mantendo a compatibilidade entre todas as
aplicações.
Facilidade de manutenção
Com base no reaproveitamento de código da programação orientada a objetos, podemos realizar alterações de melhoria,
atualização ou qualquer manutenção em uma classe. Isso fará com que todas as aplicações sejam atualizadas quando forem
recompiladas.
 Métodos Setters e Getters
Por questões de segurança e falta de controle, não é comum realizar acessos diretos aos atributos de um objeto, por isso são
criados métodos especí�cos para receber o valor e realizar a atribuição (Setters), ou para a recuperação (Getters) de um valor
armazenado nos atributos de um objeto. Este processo pode evitar que valores incorretos sejam atribuídos sem qualquer
chance de análise.
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.
A veri�cação do valor a ser atribuído não pode ser realizada quando efetuamos uma atribuição direta:
Aluno a = new Aluno();
a.cr = -5.0;
O uso de um método Setter neste caso evitará que seja atribuído um valor inválido para o CR, no caso -5.0;
Exemplo
public void setCr(double c){
if(c >=0.0 && c <= 10.0) {
cr = c;
}
}
// na aplicação:
a.setCr( -5.0 );
//
Note que o parâmetro c recebe o valor a ser atribuído ao CR (-5.0), mas antes de atribuir é realizada uma veri�cação do
valor para averiguar se o mesmo é válido. No caso, o valor do parâmetro é menor do que zero.
Como sabemos que um CR não pode ser negativo, a atribuição não será realizada, assim como a tentativa de realizar a
atribuição de um CR maior do que 10 (dez) também não permitirá que a atribuição ocorra.
Apenas atribuições com valores válidos poderão ser realizadas neste caso.
Métodos Getters
São métodos especiais que retornam o valor armazenado no atributo, evitando acesso direto a ele 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 a ele, 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.
Exemplo
public double getCr( ){
return cr;
}
Note que não existe parâmetro, o método apenas deve retornar o valor armazenado e por isso não pode ser void, sendo o tipo
de retorno do mesmo tipo do atributo que será retornado, e a ação é a de retorno (return).
// na aplicação:
double conceito = a.getCr();
No futuro, os atributos das nossas classes serão protegidos contra acesso direto (privado), impedindo que a aplicação possa
acessar diretamente um atributo. Dessa forma, é necessário que usemos os métodos Setters e Getters para atribuir e recuperar
os valores do atributo.
EXEMPLO
Aluno.java (versão com métodos Setters e Getters.)
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());
}
}
AppAluno.java (nova versão)
//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();
}
}
Notas:
1. Os valores dos atributos dos alunos 1 e 2 serão atribuídos normalmente, mas os valores do aluno3 não, porque a
matrícula e o nome estão vazios e o CR não é válido;
2. Os valores foram atribuídos utilizando os métodos Setters, que veri�caram se os valores eram válidos para só então
realizar as atribuições;
3. Os métodos Getters foram usados na própria classe Aluno para buscar os valores armazenados nos atributos do objeto
no método imprimir.
Exemplo prático
A classe Carro possui os atributos e métodos a seguir, crie a classe Carro e a aplicação AppCarro, realize a entrada de dados na
aplicação através do teclado, e ao �nal imprima os dados dos respectivos carros (através do método imprimir()).
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Classe: Carro.
Atributos Métodos
Fabricante : texto
Modelo : texto
Cor : texto
Placa : texto
Valor : real
NumeroPortas : inteiro
AnoFabricacao : inteiro
AnoModelo : inteiro
- Setters para todos os atributos
- Getters para todos os atributos
- Imprimir () // imprime todos os dados do carro
Solução do exercício prático
Arquivo da classe Carro
Carro.java
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 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 () {
//String fabricante, modelo, cor, placa;
//double valor;
//int numeroPortas, anoFabricacao, anoModelo;
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() );
}
}
Arquivo da Aplicação (AppCarro.java).
AppCarro.java
import java.util.Scanner;
 
public class AppCarro {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner entrada = new Scanner( System.in );
Carro car1 = new Carro();
System.out.println("--- Entrada de Dados - Primeiro Carro ---:");
System.out.println("Digite o Fabricante do carro:");
car1.setFabricante( entrada.nextLine() );
System.out.println("Digite o Modelo do carro:");
car1.setModelo( entrada.nextLine() );
System.out.println("Digite a Cor do carro:");
car1.setCor( entrada.nextLine() );
System.out.println("Digite a Placa do carro:");
car1.setPlaca( entrada.nextLine() );
System.out.println("Digite o Valor do carro:");
car1.setValor( Double.parseDouble( entrada.nextLine()) );
System.out.println("Digite o Número de Portas do carro:");
car1.setNumeroPortas( Integer.parseInt( entrada.nextLine()) );
System.out.println("Digite o Ano de fabricação do carro:");
car1.setAnoFabricacao( Integer.parseInt( entrada.nextLine()) );
System.out.println("Digite o Ano do Modelo do carro:");
car1.setAnoModelo( Integer.parseInt( entrada.nextLine()) );
 
Carro car2 = new Carro();
System.out.println("--- Entrada de Dados - Segundo Carro ---:");
System.out.println("Digite o Fabricante do carro:");
car2.setFabricante( entrada.nextLine() );
System.out.println("Digite o Modelo do carro:");
car2.setModelo( entrada.nextLine() );
System.out.println("Digite a Cor do carro:");
car2.setCor( entrada.nextLine() );
System.out.println("Digite a Placa do carro:");
car2.setPlaca( entrada.nextLine() );
System.out.println("Digite o Valor do carro:");
car2.setValor( Double.parseDouble( entrada.nextLine()) );
System.out.println("Digite o Número de Portas do carro:");
car2.setNumeroPortas( Integer.parseInt( entrada.nextLine()) );
System.out.println("Digite o Ano de fabricação do carro:");
car2.setAnoFabricacao( Integer.parseInt( entrada.nextLine()) );
System.out.println("Digite o Ano do Modelo do carro:");
car2.setAnoModelo( Integer.parseInt( entrada.nextLine()) );
 
// Saída de dados
System.out.println("--- Entrada de Dados - Primeiro Carro ---:");
car1.imprimir();
System.out.println("--- Entrada de Dados - Segundo Carro ---:");
System.out.println("----- Dados do Segundo Carro -----");
car2.imprimir();
}
}
 
Notas:
Você pode ver que temos algumas repetições de código para realizar a entrada de dados de cada objeto. Se aumentarmos o
número de objetos, aumentaremos consideravelmente o tamanho do código.
Teste realizado:
--- Entrada de Dados - Primeiro Carro ---
Digite o Fabricante do carro :
Ford
Digite o Modelo do carro :
Ecosport
Digite a Cor do carro :
Branca
Digite a Placa do carro :
RIO1A00
Digite o Valor do carro :
98000
Digite o Número de Portas do carro :
4
Digite o Ano de fabricação do carro :
2018
Digite o Ano do Modelo do carro :
2019
Digite o Fabricante do carro :
Fiat
Digite o Modelo do carro :
Argo
Digite a Cor do carro :
Preta
Digite a Placa do carro :
RIO2A00
Digite o Valor do carro :
60000
Digite o Número de Portas do carro :
4
Digite o Ano de fabricação do carro :
2019
Digite o Ano do Modelo do carro :
2019
--------- Dados do Primeiro Carro -----------------------------
Fabricante : Ford
Modelo : Ecosport
Cor : Branca
Placa : RIO1A00
Valor : 98000.0
Número de Portas : 4
Ano de fabricação: 2018
Ano do Modelo : 2019
--------- Dados do Segundo Carro ------------------------------
Fabricante : Fiat
Modelo : Argo
Cor : Preta
Placa : RIO2A00
Valor : 60000.0
Número de Portas : 4
Ano de fabricação: 2019
Ano do Modelo : 2019
Para resolver este problema e evitarmos a redundância de códigos, vamos incluir um novo método na classe Carro, um método
para a entrada de dados. Desta forma, evitamos a redundância dos códigos de entrada de dados.
Classe: Carro.
Atributos Métodos
Fabricante : texto
Modelo : texto
Cor : texto
Placa : texto
Valor : real
NumeroPortas : inteiro
AnoFabricacao : inteiro
AnoModelo : inteiro
- Setters para todos os atributos
- Getters para todos os atributos
- Imprimir () // imprime todos os dados do carro
- EntradaDados () // realiza a entrada de dados do carro
Nova solução do exercício prático, com a inclusão do método entradaDados na classe
Carro:
Arquivo da classe Carro atualizado.
Carro.java
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 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( "------------------------------------");
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()) );
}
}
Arquivo da Aplicação.
AppCarro.java
public class AppCarro {
public static void main(String[] args) {
// TODO Auto-generated method stub
Carro car1 = new Carro();
car1.entradaDados();
car1.imprimir();
Carro car2 = new Carro();
car2.entradaDados();
car2.imprimir();
Carro car3 = new Carro();
car3.entradaDados();
car3.imprimir();
}
}
Nota:
Você pode perceber agora que existe um método para a entrada de dados na classe Carro, e que ele está sendo usado por cada
carro para realizar a entrada de dados pelo teclado, evitando que os códigos das entradas de dados �quem redundantes.
Além disso, a aplicação �cou muito mais simples. Caso você tenha vários objetos carros, você não terá redundância, portanto
sua aplicação �cará mais simples.
Faça um teste executando a nova aplicação e analise o resultado. Inclua mais dois objetos carros e teste novamente: você verá
que a aplicação terá uma pequena mudança, mas a classe Carro �cará inalterada.
A partir deste momento, todas as classes deverão sempre conter o método entradaDados().
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Teste realizado:
------------------------------------
Digite o Fabricante do carro :
Ford
Digite o Modelo do carro :
Ecosport
Digite a Cor do carro :
Branca
Digite a Placa do carro :
RIO1A00
Digite o Valor do carro :
98000
Digite o Número de Portas do carro :
4
Digite o Ano de fabricação do carro :
2018
Digite o Ano do Modelo do carro :
2019
------------------------------------
Fabricante : Ford
Modelo : Ecosport
Cor : Branca
Placa : RIO1A00
Valor : 98000.0
Número de Portas : 4
Ano de fabricação: 2018
Ano do Modelo : 2019
------------------------------------
Digite o Fabricante do carro :
Fiat
Digite o Modelo do carro :
Argo
Digite a Cor do carro :
Preta
Digite a Placa do carro :
RIO2A00
Digite o Valor do carro :
60000
Digite o Número de Portas do carro :
4
Digite o Ano de fabricação do carro :
2019
Digite o Ano do Modelo do carro :
2019
------------------------------------
Fabricante : Fiat
Modelo : Argo
Cor : Preta
Placa : RIO2A00
Valor : 60000.0
Número de Portas : 4
Ano de fabricação: 2019
Ano do Modelo : 2019
------------------------------------
Digite o Fabricante do carro :
Ford
Digite o Modelo do carro :
Fiesta
Digite a Cor do carro :
Prata
Digite a Placa do carro :
RIO3A00
Digite o Valor do carro :
52000
Digite o Número de Portas do carro :
4
Digite o Ano de fabricação do carro :
2018
Digite o Ano do Modelo do carro :
2018
------------------------------------
Fabricante : Ford
Modelo : Fiesta
Cor : Prata
Placa : RIO3A00
Valor : 52000.0
Número de Portas : 4
Ano de fabricação: 2018
Ano do Modelo : 2018
 Atividade
1) [Prova FAURGS - 2014 - TJ-RS – Programador] Considere a a�rmação abaixo no que se refere a Linguagens Orientadas a
Objetos.
Um programa em execução em uma linguagem orientada a objetos pode ser descrito como uma coleção de ______________ que
se ______________ entre si através de _______________.
Assinale a alternativa que preenche correta e respectivamente as lacunas do parágrafo acima:
a) mensagens – comunicam – objetos
b) objetos – comunicam – mensagens
c) classes – excluem – objetos
d) métodos – excluem – objetos
e) métodos – comunicam – herança
2) Dada a classe abaixo, implemente o método que permite a recuperação do valor armazenado no atributo peso do objeto
atleta1.
public class Atleta {
String nome;
double peso, altura, imc;
}
Notas
Referências
Próxima aula
Métodos Construtores e Polimor�smo de Sobrecarga.
Explore mais
Pesquise na internet, sites, vídeos e artigos relacionados ao conteúdo visto.
Em caso de dúvidas, converse com seu professor online por meio dos recursos disponíveis no ambiente de aprendizagem.
__MACOSX/._Aula 03 - Programacao I.pdf
Aula 04 - Programacao I.pdf
Programação I
Aula 4: Métodos construtores e polimor�smo de sobrecarga
Apresentação
Trabalharemos com os métodos construtores que são executados exclusivamente durante o processo de criação e
instanciação do objeto.
Exploraremos também o conceito de polimor�smo de sobrecarga, aplicado sobre operadores e métodos. Ao �nal,
desenvolveremos novas classes e aplicações utilizando os novos conceitos vistos.
Objetivos
Identi�car o conceito de métodos construtores;
Examinar os conceitos de polimor�smo de sobrecarga.
Primeiras palavras
 Fonte: Freepik
A programação orientada a objetos permite que possamos controlar a criação de um objeto através dos chamados métodos
construtores. Tal característica permite que um método especial, o método construtor, seja executado no momento em que
ocorre a criação do objeto (objeto é instanciado) e um conjunto de ações (instruções) podem ser programadas para serem
realizadas neste momento.
Entre essas ações, pode-se destacar o recebimento de dados iniciais para serem atribuídos e/ou preparar o objeto para que
este esteja apto a atender às necessidades para qual foi criado.
Um método construtor pode ainda ser usado para determinar o tamanho de
um vetor que será usado pelo objeto, assim como pré-con�gurar estruturas
de dados de suporte ao objeto que está sendo criado.
javascript:void(0);
Métodos construtores
São métodos especiais executados apenas uma vez por cada objeto criado, pois somente são executados no momento da
instanciação / criação do objeto, sendo responsáveis por realizar as ações necessárias para a sua criação (controlar a
criação
do objeto).
Características dos métodos construtores:
1
São sempre públicos (public, característica de
encapsulamento – veremos mais adiante), não podendo ter
nenhum tipo de restrição;
2
Não existe de�nição de tipo de retorno, pois métodos
construtores não podem retornar valores com a instrução
“return”, são sem tipo;
3
Devem ser identi�cados sempre com o mesmo nome da
classe;
4
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.
 Classe: Pessoa
 Clique no botão acima.
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();
}
}
Saída: Console
Pessoa:
Nome = Marcela
Identidade = 0123456-7
Idade = 23
Notas:
public Pessoa(String nome, String identidade, int idade)
O processo de compilação de uma classe cria um método construtor vazio quando não for encontrado nenhum
método construtor. Desta forma, nos exemplos anteriores, as classes Aluno e Carro não tinham métodos construtores,
então o compilador criou respectivamente os métodos a seguir para as classes Aluno e Carro:
public Aluno ( ) { }
e
public Carro ( ) { }
Na classe Pessoa, o método construtor:01
O método é público, não possui tipo de retorno antes no nome identificador do método, seu identificador é igual ao
nome da classe, por isso começou por letra maiúscula e só será usado para criar o objeto (instanciar);
A partir do momento em que um método construtor é criado, a classe só poderá ser instanciada se usarmos um método
construtor existente. Por isso, o objeto Pessoa p1 não pode ser criado e sua criação foi comentada na aplicação, pois
este método tenta utilizar um método construtor que não existe na classe;
02
O objeto p2 usa um método construtor existente e por isso pode ser criado;03
Com o uso do método construtor, os dados recebidos como parâmetros puderam ser utilizados para realizar as
atribuições nos atributos do objeto, determinando os valores de suas propriedades no momento da criação do objeto;04
Os métodos setIdentidade (String id) e setIdade (id) podem ter o mesmo identificador para o parâmetro porque o
parâmetro id é declarado em diferentes métodos e, sendo assim, ele é válido internamente em cada um dos métodos
separadamente.
05 int
Quando não temos um construtor em uma classe, um construtor VAZIO é
criado no processo de compilação.
Polimor�smo de sobrecarga
Polimor�smo quer dizer muitas formas. O polimor�smo de sobrecarga permite o emprego de operadores e identi�cadores 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, método etc., de acordo com uma situação.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Clique nos botões para ver as informações.
int b=5, c=3;
int a = b + c; // o símbolo de + neste contexto está realizando uma operação
// de soma entre valores inteiros, no caso b + c (inteiros)
double x=3.5, y = 2.2;
double z = x + y; // temos um novo contexto, pois a operação agora será
// realizada entre dois valores reais, no caso x + y
A mudança de contexto faz com que as operações a serem realizadas sejam diferentes, pois toda linguagem de
programação possui diferentes formas de realizar as operações de soma inteira e real. Desta forma, a expressão
aritmética a seguir utiliza as duas operações conjuntamente:
double z = ( 2 + 5) / (3.5 + 1.5);
Na primeira operação de soma, os operandos são inteiros, então a operação a ser realizada será de uma soma inteira,
para somente depois ser realizada a operação de soma real. Desta forma, teremos em um instante a seguinte situação:
double z = ( 7) / (5.0);
Assim, a operação de divisão será real e não inteira porque existe um operando real.
O operador + é um dos mais usados, sendo um bom exemplo de sobrecarga de operadores, pois pode ser utilizado 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());
Agora imagine a seguinte instrução:
System.out.println("Valor =" + (( 3 + 4) + (1.3 + 2.7) + (++x)));
A sobrecarga de operadores está sendo usada de diferentes formas em uma mesma instrução. Cada contexto será
avaliado para que seja executada a operação adequada em cada caso.
Polimor�smo de sobrecarga de operadores 
Comentário
Em Java, todas as operações aritméticas serão realizadas em função dos tipos dos operandos, e a operação será inteira
apenas se ambos os operandos foram inteiros. Caso contrário (um operando inteiro e outro real ou dois operandos reais), a
operação será real.
Toda expressão é avaliada sintaticamente, assim como cada contexto será avaliado individualmente no momento da
execução.
A sobrecarga de métodos permite que possamos ter mais de um método com o mesmo identi�cador em uma mesma
classe. Isso só é possível em razão da avaliação do contexto no momento da execução. Vamos levar em consideração
que eu desejo realizar o cálculo da área de um quadrado e de um retângulo em uma mesma classe.
Para realizar o cálculo da área do quadrado, eu preciso apenas do valor da base do quadrado. Assim, o método área �caria
da seguinte forma:
public int area ( int base ){
return ((int) Math.pow(base,2)); // Math.Pow calcula a base elevada a 2
}
Já para realizar o cálculo da área do retângulo, eu preciso do valor da base e da altura do quadrado. Assim, o método área
�caria da seguinte forma:
public int area ( int base, int altura ){
return ( base * altura );
}
Polimor�smo de sobrecarga de métodos 
Assinaturas
Esses dois métodos podem conviver na mesma classe, uma vez que eles possuem diferentes assinaturas. A assinatura de um
método é determinada pelo tipo de parâmetros e pela ordem em que estes foram declarados. Desta forma, a assinatura do
primeiro método é:
area ( int );
e do segundo:
area ( int , int );
Diante da diferença de assinaturas, podemos ter dois diferentes contextos para o uso do método de cálculo da área:
1
System.out.println("Área = " + area( 5 ));
No primeiro contexto, é chamado para executar o método
área com um único parâmetro e neste caso a avaliação em
tempo de execução irá determinar que deve ser usado o
cálculo da área do quadrado. Ou seja, aquele que recebe um
valor inteiro como parâmetro, e a resposta será: 25.
2
System.out.println("Área = " + area( 5, 6 ));
No segundo contexto, é chamado para executar o método
área com um dos parâmetros e, neste caso, a avaliação em
tempo de execução irá determinar que deve ser usado o
cálculo da área do retângulo. Ou seja, aquele que recebe
dois valores inteiros como parâmetro, e a resposta será: 30.
Atenção
Com o uso da sobrecarga de métodos você poderá criar quantos métodos com o mesmo identi�cador (nome) quiser

Teste o Premium para desbloquear

Aproveite todos os benefícios por 3 dias sem pagar! 😉
Já tem cadastro?

Materiais relacionados

Perguntas relacionadas

Perguntas Recentes