Apostila de Programação II Por Pedro Monforte (Monitor)

Prévia do material em texto

Apostila de Programação II 
Programação Orientada a Objetos 
(JAVA/Netbeans) 
 
 
Programação II 
Orientação a Objetos 
 
 
 
 
PEDRO HENRIQUE B.MONFORTE 
MONITOR DE PROGRAMAÇÃO II – CEFET-RJ Uned NI 
 
0 
 
Sumário 
Capitulo 1 – Revisão: 
COMANDOS BÁSICOS DE INTERAÇÃO COM O USUÁRIO: ........................................... 1 
Operadores Básicos: .............................................................................................................................. 1 
Operadores de Incremento e Decremento: ............................................................................................ 1 
Comandos de Impressão em Tela: ......................................................................................................... 2 
Comando de Leitura (Scanner): .............................................................................................................. 3 
ESTRUTURAS DE DECISÃO (CONTROLADORES DE FLUXO): .................................... 4 
Estruturas de Decisão “If”: ..................................................................................................................... 4 
Estrutura de decisão “Switch”: .............................................................................................................. 4 
ESTRUTURAS DE REPETIÇÃO: ............................................................................................ 6 
Estrutura de repetição “While”: ............................................................................................................. 6 
Estrutura de Repetição “For”: ................................................................................................................ 6 
TIPOS DE VARIÁVEIS: ............................................................................................................ 7 
Dados compostos: ................................................................................................................................. 7 
Capitulo 2 – O Netbeans(IDE): 
O QUE SÃO IDE’S: ..................................................................................................................... 8 
BARRA DE FERRAMENTAS – ABA SUPERIOR: ............................................................... 9 
Barra de Ferramentas propriamente dita: ............................................................................................. 9 
Barra de Ferramentas de Acesso Rápido: ............................................................................................... 9 
LISTAGEM DE RECURSOS - ABA LATERAL-ESQUERDA: ............................................. 9 
Árvore de Projetos: ................................................................................................................................ 9 
Árvore de Arquivos: ............................................................................................................................. 10 
Árvore de Serviços: .............................................................................................................................. 10 
EDITOR – ABA DIREITA OU CENTRAL: ......................................................................... 10 
CONSOLE – ABA INFERIOR (NEM SEMPRE VISÍVEL): ............................................... 10 
Capitulo 3 – Orientação a Objetos: 
DEFINIÇÃO DO PARADIGMA DE PROGRAMAÇÃO: .................................................... 11 
A CLASSE: ................................................................................................................................ 11 
Conceito: ............................................................................................................................................. 11 
Atributos: ............................................................................................................................................ 11 
Métodos: ............................................................................................................................................. 11 
O OBJETO: ............................................................................................................................... 11 
Conceito: ............................................................................................................................................. 11 
Instanciar: ............................................................................................................................................ 12 
COMPOSIÇÃO: ....................................................................................................................... 12 
MODIFICADORES DE ACESSO: ......................................................................................... 12 
MÉTODOS: .............................................................................................................................. 12 
O Construtor: ....................................................................................................................................... 13 
O método toString: .............................................................................................................................. 13 
Metodos Get e Set: .............................................................................................................................. 14 
HERANÇA: ............................................................................................................................... 14 
CLASSES ABSTRATAS: ........................................................................................................ 15 
Capitulo 4 – Interface e UI 
INTERFACE: ............................................................................................................................ 16 
INTERFACE COM O USUÁRIO: .......................................................................................... 17 
Caixas de Mensagens: .......................................................................................................................... 18 
Formulários: ........................................................................................................................................ 18 
1 
 
 
Revisão	(Programação	I)	
Comandos Básicos de Interação com o Usuário: 
Operadores Básicos: 
Operação Operador 
Adição + 
Subtração - 
Multiplicação * 
Divisão / 
Resto % 
Atribuição = 
Igualdade = = 
Desigualdade != 
Maior que > 
Menor que < 
Maior ou igual a >= 
Menor ou igual a <= 
a = a + b a += b 
a = a – b a -= b 
a = a * b a *=b 
a = a / b a /= b 
a = a%b a %= b 
 
Operadores de Incremento e Decremento: 
Operador Exemplo de Expressão Explicação 
++ ++a Incrementa em 1 unidade o valor de “a”, e usa o novo 
valor na expressão. 
++ a++ Utiliza o valor atual de “a” na expressão, então 
incrementa seu valor em 1 unidade. 
-- --a Decrementa em 1 unidade o valor de “a”, e usa o novo 
valor na expressão. 
-- a-- Utiliza o valor atual de “a” na expressão, então 
decrementa seu valor em 1 unidade. 
 
 
2 
 
Comandos de Impressão em Tela: 
Para imprimir um texto ou o valor de uma variável em Java podemos usar vários comandos, 
aqui temos os exemplos mais familiares e práticos para se imprimir em um Console: 
Função ”printf”: 
O comando printf vem com uma estrutura semelhante a sua estrutura na linguagem de 
programação C, para uso do comando utilizamos o seguinte formato: 
“System.out.printf( String, Argumentos);”. 
Dentro do parênteses da função utilizamos uma String com “argumentos” semelhante ao C por 
exemplo para imprimir o valor de um inteiro “a=3” utilizamos: 
“System.out.printf("O valor de a e %d unidades",a)” 
“O valor de a e 3 unidades” 
Função “print”: 
O comando print em Java é anterior ao comando printf e utiliza uma estruturasemelhante a 
linguagem de programação Pascal, concatenando pedaços de String e valores de variáveis 
diversas por exemplo: 
“System.out.print("O valor de a e "+ a +” unidades”);” 
“O valor de a e 3 unidades” 
Função “println”: 
O comando println segue o mesmo estilo do comando print porem ao finalizar a impressão do 
conteúdo dentro dos parênteses uma linha é pulada. 
Quebra de linha: 
A quebra de linha dentro de uma String é dado por um símbolo “\n” (barra invertida n) por 
exemplo: 
“System.out.print("O valor de a e: \n "+ a +” unidades”);” 
Que devera imprimir: 
“O valor de a e: 
3 unidades” 
 
3 
 
Comando de Leitura (Scanner): 
O comando de leitura no java é muito rudimentar e difícil de se trabalhar, por isso utilizaremos 
um comando feito, para isso precisamos fazer um importação e o entendimento completo 
desse comando só pode ser lado a partir do conceito de Classe, cujo ainda não foi abordado no 
curso: 
Prestem atenção no exemplo comentado a seguir: 
import java.util.Scanner; //importamos a classe Scanner a ser utilizada, antes de declararmos a 
classe principal no arquivo 
public class Principal { 
 public static void main(String[] args) { 
 int a; //criamos um inteiro “a” 
 Scanner entrada = new Scanner(System.in); // Criamos um Objeto “entrada” que vai 
funcionar como “os olhos” do programa para ler aquilo que o usuário inserir 
 System.out.println("De um valor para \"a\" "); // usamos um println para notificar o 
usuário do que queremos 
 a = entrada.nextInt(); //Essa é a estrutura essencial Variavel = entrada.nextInt(); 
 } 
} 
A estrutura “a = entrada.nextInt();” significa o seguinte “Atribua a variável ‘a’ o próximo valor 
inteiro inserido pelo usuário. Ou seja, mesmo que a variável a já tenha um valor o valor novo 
estará sendo atribuído. 
Temos ainda outros métodos na classe Scanner, por exemplo para capitar qualquer coisa que o 
usuário inserir a seguir usaríamos “entrada.next()”; 
Observação: Organização em Pacotes. 
Quando um programador utiliza as classes feitas por outro, surge um problema clássico: como 
escrever duas classes com o mesmo nome? 
Por exemplo: pode ser que a minha classe de Data funcione de um certo jeito, e a classe Data 
de um colega, de outro jeito. Pode ser que a classe de Data de uma biblioteca funcione ainda 
de uma terceira maneira diferente. 
Como permitir que tudo isso realmente funcione? Como controlar quem quer usar qual classe 
de Data? 
Pensando um pouco mais, notamos a existência de um outro problema e da própria solução: o 
sistema operacional não permite a existência de dois arquivos com o mesmo nome sob o 
mesmo diretório, portanto precisamos organizar nossas classes em diretórios diferentes. 
Os diretórios estão diretamente relacionados aos chamados pacotes e costumam agrupar 
classes de funcionalidades similares ou relacionadas. 
Por exemplo, no pacote java.util temos as classes Date, SimpleDateFormat e 
GregorianCalendar; todas elas trabalham com datas de formas diferentes. 
É por isso que utilizamos “System.out” antes do printf,println,etc. 
4 
 
Estruturas de Decisão (Controladores de Fluxo): 
As estruturas de decisão ou controladores de fluxo são estruturas de lógica que “decidem o 
caminho” de cada programa, controlando para “que lado” o dado obtido nos leva. 
Estruturas de Decisão “If”: 
“If Simples”: 
O if simples faz um teste lógico básico verificando, de acordo com “desejo” do programador, 
se um bloco de comando deve ou não ser executado, por exemplo: 
“ int a= 3; 
 if (a == 4) { 
 System.out.print("O valor de a e " + a + "unidades" ); 
 }” 
Nesse caso não será executado o comando “System.out.print();” pois o texto lógico resulta em 
uma afirmação falsa “a” não é igual a “4”. 
“If...else” 
“ int a= 3; 
 if (a >= 4) { 
 System.out.print("O valor de a e de 4 unidades ou mais" ); 
 }else{ 
 System.out.print("O valor de a e inferior a 4 unidades" ); 
 }” 
“If...else...if...else...” If’s Aninhados: 
Podemos usar vários if’s entrelaçados para garantir as condições ideais por exemplo: 
“int b = 0 
if (b = 0){ 
System.out.print("Valor nulo” ); 
}else{ if (b>0) { 
System.out.print("Valor positivo" ); 
}else { 
System.out.print("Negativo" ); 
} 
Estrutura de decisão “Switch”: 
Uma estrutura muito utilizada em programação é o switch. A estrutura switch verifica uma 
variável e age de acordo com seus cases. Os cases são as possibilidades de resultados que são 
obtidos por switch. 
Basicamente, o switch serve para controlar várias ações diferentes de acordo com o case 
definido dentro dele. 
A estrutura do Switch é: 
switch (variável) { 
case valor : 
Código a ser executado caso o valor de case seja o mesmo da variável de switch 
} 
5 
 
Então, detalhadamente, switch recebe uma variável e abre um bloco de dados ( { } ), dentro 
desse bloco de dados há os cases. Cada case recebe um valor único, ou seja, que não pode ser 
repetido no mesmo bloco de dados. Então, marcamos cada case com dois pontos ( : ). Após os 
dois pontos colocamos todo código que deverá ser executado que pode conter quantas linhas 
nós quisermos. 
Dica importante: É um bom costume sempre terminar um código após o case com um 
comando break. Assim, nós evitamos que o resto do código seja executado por acidente. E vale 
também ressaltar que case não gera resultados booleanos, portanto, não há a possibilidade de 
fazer comparações (Ex. Isso está totalmente errado-> case var1 > var2:). 
Default 
Como switch pode receber várias possibilidades, pode ocorrer de algum caso estar fora do 
alcance ou não definido. Nesse momento, default faz seu papel. Default pega qualquer 
resultado que não esteja definido no case. Ou seja, ele é o bloco de código padrão que deve 
ser executado quando nenhum case for satisfeito. Podemos coloca-lo onde quisermos dentro 
de switch , mas, geralmente, o colocamos no final. 
Para exemplificar, vamos ver o código abaixo: 
switch (diaDaSemana) { 
case 1: 
System.out.println("Domingo"); 
break; 
case 2: 
System.out.println("Segunda-feira"); 
break; 
case 3: 
System.out.println("Terça-feira"); 
break; 
case 4: 
System.out.println("Quarta-feira"); 
break; 
case 5: 
System.out.println("Quinta-feira"); 
break; 
case 6: 
System.out.println("Sexta-feira"); 
break; 
case 7: 
System.out.println("Sábado"); 
break; 
default: 
System.out.println("Este não é um dia válido!"); 
} 
 
6 
 
Estruturas de Repetição: 
As estruturas de repetição facilitam nossa vida ao trabalhar com códigos repetitivos e 
manusear vetores e matrizes com mais versatilidade. 
Estrutura de repetição “While”: 
O while repete seu bloco de comando até que um requisito seja preenchido, por exemplo até 
que o usuário entre com um mês válido (de 1 a 12) o programa continuara perguntando o mês. 
Basta lembrar que a palavra “while” em inglês significa “enquanto”, então enquanto algo for 
verdadeiro ele vai repetir o bloco de comando. 
Exemplo: 
 int mes = 0; 
 Scanner entrada = new Scanner(System.in); 
 while ((mes < 1) || (mes > 12)){ 
 System.out.println("Qual é o mês?"); 
 mes = entrada.nextInt(); 
 } 
Estrutura de Repetição “For”: 
O for é estrutura de repetição mais básica, e também a mais usada, na programação. Ela 
funciona como um “contador” e garante a repetição de um código em uma quantidade 
determinada de vezes: 
A estrutura é dada por “for( int Contador = “Valor Inicial”; Contandor <= “Valor Final”; 
Contador++)”, que consiste na declaração do contador e determinação do seu valor inicial;uma 
determinaçãológica para determinar quando parar; e uma expressão de incremento(ou 
decremento); 
Exemplo: 
for (int i=0;i<10;i++){ 
 System.out.println(i); 
} 
Conta de 0 a 9. 
 
7 
 
Tipos de Variáveis: 
 
Tipo de Dados Comando Exemplo 
Inteiro int int quantidade_de_alunos; 
Real double double preco; 
Texto String String nome; 
Vetores “tipo”[] int[] vetor = new int[10]; 
Objeto Nome da Classe Classe1 Objeto1 = new Classe1(); 
 
Dados compostos: 
Dados compostos são basicamente classes utilizadas como variáveis, por exemplo, para fazer 
um tipo de dado “Data” precisamos de um tipo de dados com três inteiros, criamos então uma 
classe com três atributos (dia,mês e ano) e a utilizamos comovariavel. Exemplo: 
 
private class Data { 
 int dia; 
 int mes; 
 int ano; 
 Data(int D, int M, int A){ 
 dia = D; 
 mes = M; 
 if ( A < 2014) { 
 ano = A; 
 } else { 
 ano=2014;} 
 } 
 public String toString(){ 
 return " " + dia + "/" + mes + "/" + ano; 
 } 
 } 
Como classe privada essa classe pode se encontrar no mesmo arquivo que uma classe publica, 
então não é necessário criar um novo arquivo para ela, embora isso seja recomendado, pois 
caso contrario ela não poderá ser utilizada diretamente em outras partes do programa. 
8 
 
O	Netbeans	(IDE):	
O que são IDE’s: 
O Netbeans é um IDE(Integrated Development Environment – Ambiente Integrado de 
Desenvolvimento), um programa de computador que reúne características e ferramentas de 
apoio ao desenvolvimento de software com o objetivo de agilizar este processo. 
 
Geralmente os IDEs facilitam a técnica de RAD (de Rapid Application Development, ou 
"Desenvolvimento Rápido de Aplicativos"), que visa a maior produtividade dos 
desenvolvedores. 
As características e ferramentas mais comuns encontradas nos IDEs são: 
Editor - edita o código-fonte do programa escrito na(s) linguagem(ns) suportada(s) pela IDE; 
Compilador (compiler) - compila o código-fonte do programa, editado em uma linguagem 
específica e a transforma em linguagem de máquina; 
Linker - liga (linka) os vários "pedaços" de código-fonte, compilados em linguagem de 
máquina, em um programa executável que pode ser executado em um computador ou outro 
dispositivo computacional. 
Depurador (debugger) - auxilia no processo de encontrar e corrigir defeitos no código-fonte do 
programa, na tentativa de aprimorar a qualidade de software; 
Modelagem (modeling) - criação do modelo de classes, objetos, interfaces, associações e 
interações dos artefatos envolvidos no software com o objetivo de solucionar as necessidades-
alvo do software final. 
Geração de código - característica mais explorada em Ferramentas CASE, a geração de código 
também é encontrada em IDEs, contudo com um escopo mais direcionado a templates de 
código comumente utilizados para solucionar problemas rotineiros. Todavia, em conjunto com 
ferramentas de modelagem, a geração pode gerar praticamente todo o código-fonte do 
programa com base no modelo proposto, tornando muito mais rápido o processo de 
desenvolvimento e distribuição do software; 
Distribuição (deploy) - auxilia no processo de criação do instalador do software, ou outra 
forma de distribuição, seja discos ou via internet. 
Testes Automatizados (automated tests) - realiza testes no software de forma automatizada, 
com base em scripts ou programas de testes previamente especificados, gerando um relatório, 
assim auxiliando na análise do impacto das alterações no código-fonte. Ferramentas deste tipo 
mais comuns no mercado são chamadas robôs de testes. 
Refatoração (refactoring) - consiste na melhoria constante do código-fonte do software, seja 
na construção de código mais otimizado, mais limpo e/ou com melhor entendimento pelos 
envolvidos no desenvolvimento do software. A refatoração, em conjunto com os testes 
automatizados, é uma poderosa ferramenta no processo de erradicação de "bugs", tendo em 
vista que os testes "garantem" o mesmo comportamento externo do software ou da 
característica sendo reconstruída. 
9 
 
Barra de Ferramentas – Aba Superior: 
Barra de Ferramentas propriamente dita: 
Contem alguns botões simples (apenas a palavra) e da acesso a todas as funções da IDE, os 
botões mais utilizados serão: 
Botão Arquivo: 
Contem ferramentas para criar, abrir e fechar projetos e arquivos além de configurações de 
impressão e exportação de arquivos e projetos. 
Botão Editar: 
Contem ferramentas de edição de código, entre eles os comandos de copiar e colar, 
substituição e localização de palavras e ferramentas para produção e macros. 
Botão Exibir: 
Contem configurações de barras e abas a serem exibidas além do modo de tela cheia e o modo 
“só editor”. 
Botão Executar: 
Contem os comandos de execução de projetos para teste. 
Botão Ferramentas: 
Contem ferramentas diversas e o botão “Opções” onde diversas preferencias podem ser 
definidas inclusive o tamanho da fonte. 
Barra de Ferramentas de Acesso Rápido: 
São os botões mais “bonitinhos” com ícones(desenhos), e seus ícones indicam suas funções de 
forma bem intuitiva, o botão mais utilizado por nós sera o “Executar” que tem o ícone de um 
“play” verde. 
Listagem de Recursos - Aba Lateral-Esquerda: 
Contem ferramentas para navegação rápida e troca de projetos. 
Pode ser Minimizada (escondida na barra lateral) a partir de um botão com o símbolo “-“ 
localizado na extrema direita superior da aba. 
Árvore de Projetos: 
Nessa aba você encontra todos os projetos atualmente abertos no IDE, é uma boa prática 
fechar todos os projetos que não vão ser utilizados no momento para evitar confusão ao lidar 
com os projetos e para melhor desempenho do IDE. 
Os projetos são dispostos em forma de árvore de arquivos e geralmente separados em quatro 
“pastas”, mas a única que nos importa agora é a primeira delas: 
Pacotes de Código-fonte: São os pacotes de código que estão no projeto, todo projeto tem um 
pacote default (visível ou não) e pacotes diversos, os pacotes são formas de organizar as 
classes, em projetos complexos se torna um bom hábito separar os códigos em pacotes porem 
em programas mais simples isso não se faz necessário. Dentro de um dos pacotes você pode 
criar classes apertando o botão direito do mouse e selecionando Novo → Classe Java. 
10 
 
Árvore de Arquivos: 
Nessa aba você encontra todos os arquivos que estão dentro da pasta padrão do netbeans. 
Também disposta em forma de árvore da fácil acesso ao arquivos dentro das pastas do projeto 
porem é geralmente utilizada para verificar o endereço de imagens e arquivos de código fonte. 
Árvore de Serviços: 
Nessa aba você encontra todos os serviços disponíveis para o IDE, bancos de dados, servidores, 
etc. Como no curso de Programação Orientada a Objetos não vamos lidar com o uso de Banco 
de dados essa aba provavelmente não será utilizada. 
Editor – Aba Direita ou Central: 
O Editor é onde nós trabalhamos, funciona como um editor de textos onde inserimos o código. 
O Editor tem ferramentas automáticas para completar palavras e códigos e geralmente nos 
cria o hábito de deixa-lo fazer boa parte do código por nós, aconselha-se desativar a função de 
completar código em Opções. 
O Editor tem várias abas nomeadas e cada uma delas corresponde a um arquivo no projeto, no 
caso de classes públicas (maioria das classes será desse tipo até a segunda parte do curso) 
cada classe tem um arquivo que tem o mesmo nome da classe. 
Antes do nome de cada arquivo existe um ícone de uma pagina com uma dobra e com o 
desenho de 3 formas geométricas coloridas. 
O ícone que estiver com um “play verde” no canto éa classe principal. 
O ícone que estiver com uma bola vermelha com exclamação no canto indica que o código no 
arquivo contem um erro grave. 
O ícone que estiver com um bola ou triangulo amarelo com exclamação no canto indica que 
existem notificações no código que podem ser erros de lógica ou simplesmente notificações 
para avisar que uma variável ou importação não foi utilizada. 
O Editor também tem botões de atalho a funções do menu “Editar” na barra de ferramentas, 
coloque o mouse acima do botão para ver o seu nome e o controle de teclado associado a ele. 
Console – Aba Inferior (Nem sempre visível): 
É o console de execução do compilador, ele deve substituir a “tela preta” que aparecia no Dev 
C++ além de notificar erros e exceções não tratadas. 
No console há no seu final uma caixa de texto onde inserimos dados quando o programa esta 
lendo dados através do Scanner ou outro tipo de entrada de texto. 
 
11 
 
Capitulo	3	-	Orientação	a	Objetos:	
Definição do Paradigma de Programação: 
Teoricamente em uma linguagem de Orientação a Objetos tudo deve ser feito através de 
objetos. 
 A orientação a objetos utiliza de relações entre objetos para cumprir alguma função, 
semelhante ao mundo real cada objeto vem de um “projeto” um texto que descreve aquele 
objeto como aquilo, por exemplo, uma bicicleta é definida como um objeto com duas rodas, 
um quadro, um guidom, um pedal, uma coroa e um peão, além de outros acessórios. A 
bicicleta em si é considerada um objeto e o conceito do que a define é chamado de classe. 
A Classe: 
Exemplo: 
“public class Bicicleta { 
 public String guidom; 
 public String quadro; 
 public String freio; 
 public String roda_frontal; 
 public String roda_traseira; 
 public String mesa; 
} 
Conceito: 
Classe é uma definição de algo que pode ser criado como um objeto, como se fosse um projeto 
para um objeto. Cada classe tem seus atributos e seus métodos. 
Atributos: 
Os Atributos são as características das classes, por exemplo, uma bicicleta tem duas rodas, um 
quadro, uma mesa e um guidom. São basicamente variáveis internas da classe. 
Métodos: 
Os métodos são a forma a qual o objeto da classe interage com os outros objetos. Em geral são 
funções definidas para realizar alguma tarefa interna no objeto ou para mostrar dados. 
O Objeto: 
 
Conceito: 
O objeto é a parte tangível da classe, é quando “o projeto sai do papel”, com objetos de uma 
classe você trabalhar. Todos os objetos de uma classe têm todos os atributos e métodos por 
ela definidos, sejam esses públicos ou privados. 
12 
 
Instanciar: 
Instanciar é construir o objeto em si, o colocando para uso, semelhante à declaração de uma 
variável. Exemplo: 
“Bicicletas bicicleta_do_marquinhos = new Bicicleta();” 
Composição: 
Podemos utilizar objetos de classes como tipo de dados para facilitar a nossa vida como 
fizemos na classe privada “Data” no capitulo 1, porem utilizando como uma classe publica essa 
classe pode ser utilizada em diversas partes do projeto. 
Modificadores de acesso: 
Os modificadores de acesso modificam o nível de permissão de cada atributo, classe ou 
método. 
Modificador de acesso “public”: 
O modificador public torna a classe, objeto, variável ou método em algo publico, ou seja, que 
pode ser acessado de qualquer parte do programa. 
Modificador de acesso “private”: 
O modificador de acesso private torna algo privado, ou seja, só pode ser acessado dentro do 
arquivo em que se encontra. 
Classes Publicas e Privadas: 
As classes publicas devem estar definidas em um arquivo de classe com o seu nome, separada 
de qualquer outra classe publica, porem a classe privada pode estar em qualquer arquivo e só 
poderá ser utilizada por outras classes dentro do mesmo arquivo. 
Métodos: 
Métodos são funções de interação utilizadas por classes e objetos. Os métodos são declarados 
da forma: 
“Modificador_de_Acesso Tipo nomeDoMetodoComecandoComLetraMinuscula(Tipo 
parametro1, Tipo parametro2,...,Tipo parametroN){ 
Bloco de comandos ou corpo do método. 
} 
Os parâmetros são passados para dentro do método, basicamente como as funções em C 
tendo parâmetros para passar e serem analisados, “return” para retornar dados do tipo do 
método ou no caso de métodos voids que não retornam nada ao programa que o chamou. 
 
Métodos com o mesmo nome são diferenciados pelo compilador pelos parâmetros dentro 
deles. 
 
 
13 
 
Exemplo de Classe com os métodos principais: 
 
public class Pessoa { 
 private String nome; 
 public int idade; 
 Pessoa(){ //Construtor vazio 
 nome = “Sem Nome”; 
 idade = 0; 
} 
 Pessoa(String nomeNovo,Int idadeNova){ 
 nome = nomeNovo; 
 idade = idadeNova; 
} 
 Pessoa(String nome){ 
 this.nome = nome;// Observe aqui que o parâmetro do método tem o mesmo nome do 
//atributo da classe, nesse caso usamos “this.” antes do atributo para indicar que esse é o 
//atributo, “this” significa “este” e é usado para indicar tudo que esta diretamente associado a 
//classe atual. 
} 
 public String retornaNome(){ // método get 
 return nome; 
} 
 public void modoficaNome(String nome){ //método set, observe que ele é do tipo void, ou seja 
não retorna dados 
this.nome = nome; 
} 
public String toString(){ 
return (“O nome e “ + nome + “ e a idade e “+ idade); 
} 
 
O Construtor: 
O método construtor é um método que inicializa a classe, dando valores iniciais aos atributos, 
toda classe tem um Construtor Vazio que esta invisível até que outro construtor seja criado. 
Um construtor vazio é aquele que não recebe nenhum parâmetro. 
O construtor é um método especial e sempre tem o mesmo nome da classe além de não ter 
nenhum modificador de acesso, pois sempre deve ser publico. 
O método toString: 
O método toString é um método padrão para se “escrever o objeto”, ele retorna tudo que se 
deve saber sobre o objeto, seria “a descrição ideal” de que objeto é aquele por exemplo ao ver 
uma pessoa você pergunta a ela algo para identifica-la para saber quem ela é “O nome” e não 
é necessário por exemplo que ela diga que é uma pessoa. 
Veja o exemplo de uso, usando como base o exemplo principal da seção: 
“ Pessoa pessoa1 = new Pessoa(“Joao”,12); //usando o construtor completo 
System.out.println(pessoa1); // imprimindo literalmente o objeto “pessoa1” 
14 
 
Ao imprimir o objeto pessoa1 o programa deve exibir: 
“O nome e Joao e a idade e 12” 
Metodos Get e Set: 
Os métodos get e set são métodos utilizados para manipular os atributos de uma classe e são 
obrigatórios para qualquer atributo privado que pode ser modificado. 
É possível modificar os atributos diretamente por atribuição quando esses são públicos por 
exemplo: “pessoa1.idade = 13” porem quando são privados é necessário utilizar um método 
de set para modificar ou get para ler. 
Uma utilidade muito fácil de se entender é o caso de modificar data e hora, não podemos 
deixar que a modificação seja dada por atribuição pois qualquer valor poderá ser atribuído ao 
campo de dia ou de mês, com um método set é possível antes de modificar o dia verificar se 
ele esta entre 1 e 31 dias. 
Herança: 
Herança é um dos principais conceitos de orientação a objetos. Quando por exemplo vamos 
lidar com um programa para manuseio de banco de dados, precisamos cadastrar Clientes e 
Funcionários além de um Chefe de Setor e um Cliente Vip: Ambos são pessoas portanto 
herdam atributos da classe pessoa. 
O Chefe de Setoré um funcionário portanto ele herda atributos de funcionários, o mesmo 
acontece com Cliente Vip e Clientes. 
A Herança nos permite pegar uma classe mais simples e utiliza-la como base para uma classe 
mais complexa. Exemplo: 
(Obs: para cada public class deve-se criar um arquivo de classe novo, o exemplo de Pessoa da 
seção anterior esta sendo utilizado) 
public class Funcionario extends Pessoa{ 
 public Data admissao; 
 public double salario; 
 Funcionario (){// Construtor vazio 
 super(); 
 admissao = new Data(1,1,1990); 
 salario = 700; 
} 
 Funcionario(String nome,int idade,Data admissao,double salario){ //construtor completo 
 super(nome,idade); 
 this.admissao = admissao; 
 this.salario = salario; 
} 
public String toString(){ 
return (super.toString() + “, admissão” + admissão + “ e salario: R$” + salario); 
} 
 
15 
 
Toda classe que herda de uma classe com construtor declarado deve ter um construtor. 
Todos os métodos da classe anterior são imediatamente “copiados” para a classe nova. 
Para o uso de qualquer atributo da classe anterior no arquivo de classe usamos “super”. 
Para validar os novos construtores como substitutos dos construtores antigos devemos usar 
“super()” dentro do construtor novo. 
Classes Abstratas: 
Pensemos em algo que sabemos que pode existir porem não sabemos como, temos apenas o 
conceito e não como fazer, esse é um bom conceito para uma classe abstrata mas não seu 
único uso. 
Classe abstrata é toda classe que contem um método abstrato. 
Uma classe abstrata não pode ser instanciada, apenas herdada. 
Exemplo: 
public abstract class Gerador_Quantico{ 
public int energia; 
public abstract void geraEnergia (); 
} 
 
Uma classe que contenha um método abstrato deve ser uma classe abstrata. 
Um método abstrato não tem “corpo” ou bloco de comando, pois não se sabe como vai ser 
feito o procedimento que gera o método. 
No exemplo anterior, no mundo da física sabemos que se pode fazer um gerador quântico, 
agora como ele vai funcionar como vai gerar energia não. 
 
Uma classe que herda de uma classe abstrata deve substituir o método abstrato por um novo 
método de mesmo nome, mesmo tipo e mesmos parâmetros. 
16 
 
Capitulo	4	–	Interface	e	UI	
Interface: 
A interface é um instrumento de organização de projetos complexos, para facilitar a 
construção de classes parecidas. 
Basicamente funciona como uma lista de métodos a serem implementados em um conjunto 
de classes. Assim como classes publicas as interfaces tem arquivos próprios. 
Diferentemente da herança, onde cada classe herda diretamente de uma única classe, uma 
classe pode implementar várias interfaces separando-as por virgulas. 
Exemplo: 
public interface Escalavel { 
 void amplia(double escala); 
 void espelha(); 
} 
public interface ObjetoGeometrico { 
 Ponto2D centro(); 
 double calculaÁrea(); 
 double calculaPerímetro(); 
} 
public class Ponto2D { 
 double x; 
 double y; 
 Ponto2D(){ 
 } 
 Ponto2D(double x,double y){ 
 this.x=x; 
 this.y=y; 
 } 
 @Override 
 public String toString(){ 
 return "("+x+","+y+")"; 
 } 
} 
public class RetanguloEscalavel implements ObjetoGeometrico,Escalavel { 
Ponto2D v1; 
Ponto2D v2; 
RetanguloEscalavel(Ponto2D v1,Ponto2D v2){ 
 this.v1=v1; 
 this.v2=v2; 
} 
 
 
 
17 
 
@Override 
 public Ponto2D centro() { 
 Ponto2D centro = new Ponto2D((v1.x+v2.x)/2.0,(v1.y+v2.y)/2.0); 
 return centro; 
 } 
 @Override 
 public double calculaÁrea() { 
 return (Math.abs(v2.x)-Math.abs(v1.x))*(Math.abs(v2.y)-Math.abs(v1.y)); 
 } 
 @Override 
 public double calculaPerímetro() { 
 return ((Math.abs(v2.x))-Math.abs((v1.x))*2)+(Math.abs((v2.y-v1.y))*2); 
 } 
 @Override 
 public void amplia(double escala) { 
 v2.x = ((v2.x-v1.x)*escala)+v1.x; 
 v2.y = ((v2.y-v1.y)*escala)+v1.y; 
 } 
 @Override 
 public void espelha() { 
 v1.x = -v1.x; 
 v1.y = -v1.y; 
 v2.x = -v2.x; 
 v2.y = -v2.y; 
 } 
 @Override 
 public String toString(){ 
 return "Vertice 1: "+v1+", Vertice 2: "+v2+", Centro em: "+this.centro()+", com Area de: 
"+this.calculaÁrea()+" unidades de area e Perimetro de: "+this.calculaPerímetro()+" unidades 
de comprimento."; 
 } 
} 
Interface com o Usuário: 
A interface com o usuário (UI) é uma das maiores simplificações no mundo da programação e 
esta ligado com o melhor aproveitamento do mouse e popularização por PCs. 
Nem todo mundo tem um curso de informática avançada ou Analise de Sistemas para lidar 
com programas sem UI, e mesmo que tivessem é muito menos prático, toma muito mais 
tempo e tira a eficiência do programa. 
Até então apenas trabalhamos com “Consoles”, nessa seção vamos aprender a criar caixas de 
mensagens e formulários. 
 
18 
 
Caixas de Mensagens: 
Caixas de Mensagens são “caixinhas” que “pulam” na tela para informar algo ou pedir alguma 
confirmação. 
Segue exemplo comentado: (Lendo nome de 5 pessoas e mostrando em uma caixa de 
mensagens) 
public class Pessoa { 
 public String nome; 
 Pessoa(String nome){ 
 this.nome = nome; 
 } 
} 
 
import javax.swing.JOptionPane;//no Cabeçalho Arquivo da classe importamos um pacote java 
public class PrimeiraInterface { 
 public static void main(String[] args) {//metodo principal da classe principal do programa 
 // TODO code application logic here 
 Pessoa[] Pessoas = new Pessoa[5]; //criamos um vetor de 5 pessoas 
 for (int i=0;i<5;i++){ // criamos um for para ler 5 vezes o nome de pessoas 
 String nome = JOptionPane.showInputDialog("Qual seu nome?"); 
// usamos uma caixa de mensagens com caixa de texto para perguntar qual o nome da pessoa 
 Pessoas[i] = new Pessoa(nome); // Construimos dentro do vetor um objeto de pessoa 
//com o nome anteriormente informado. 
 } 
 String nomes = ""; // Criamos uma variável de nomes com uma String vazia 
 for (int i=0;i<5;i++){ // Adicionamos os nomes a variável nomes 
 nomes += Pessoas[i].nome + "; \n"; 
 } 
 JOptionPane.showMessageDialog(null, nomes); // Imprimimos os nomes. 
 } 
 
} 
Ao ler usando JOptionPane.showInputDialog tudo que for lido será considerado uma String e 
para que isso seja passado para um inteiro usamos 
“int a = Integer.parseInt(JOptionPane.showInputDialog())” 
Ou 
“String a = JOptionPane.showInputDialog() 
int b = Integer.parseInt(a)” 
Formulários: 
Formulários são, oras são formulários, tipo aqueles papeis chatos que temos que preencher 
pra pedir o histórico a diferença é que nos formulários java a gente digita com o teclado e 
marca com o mouse, ou digita tbm com o mouse vai que vc ta sem dinheiro pra comprar um 
teclado. 
Vamos então aos nossos recursos, os pedacinhos que temos pra juntar e formar um formulário 
qualquer. 
19 
 
Importações para um formulário Básico: 
import java.awt.BorderLayout; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.awt.event.ItemListener; 
import java.awt.event.ItemEvent; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.JButton; 
import javax.swing.JOptionPane; 
import javax.swing.JTextField; 
import javax.swing.JRadioButton; 
import javax.swing.ButtonGroup; 
import javax.swing.JLabel;import javax.swing.JCheckBox; 
import javax.swing.JComboBox; 
 
Tipos de Entradas e Saídas: 
JLabel: JLabels são as linhas de texto que geralmente usamos pra indicar o que deve ser 
colocado no campo, por exemplo colocamos um JLabel com texto “Nome:” antes de um 
TextBox de nome. 
JTextField: São as caixas de texto onde o usuário digita as informações necessárias. 
Seleções: 
JRadioButton: São as “bolinhas” que marcamos e quando marcamos desmarca as outras. 
JCheckBox: São os “quadradinhos” que marcamos e quando marcamos não desmarca os 
outros. 
JComboBox: São as caixinhas de seleção que tem uma setinha do lado e quando apertamos 
nos da um numero de opções disponíveis para aquele campo, muito utilizado para listar coisas 
como por exemplo estados, países e cidades ou opções de um plano de consumo por exemplo. 
Botões 
JButton: são literalmente os botões que pressionamos para executar alguma ação. 
Organizadores: 
JPanel: São painéis utilizados para separar vários blocos. 
ButtonGroup: Essencial ao uso dos RadioButtons são grupos que garantem o relacionamento 
entre botões, evitando por exemplo que você marque vários RadioButtons onde só se pode 
marcar um. 
 
20 
 
Event’s Handler’s: 
São ferramentas que garantem a funcionalidade de botões, sem eles botões são apenas 
objetos sem função. 
ActionListener(Interface): É a interface que nos guia a fazer EventHandler’s. 
ItemListener(Interface): É a interface que nos guia a fazer um EvenHandler quando não 
estamos manuseando botões. 
Segue Abaixo um exemplo comentado de formulário: 
import java.awt.BorderLayout; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.awt.event.ItemListener; 
import java.awt.event.ItemEvent; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 
import javax.swing.JButton; 
import javax.swing.JOptionPane; 
import javax.swing.JTextField; 
import javax.swing.JRadioButton; 
import javax.swing.ButtonGroup; 
import javax.swing.JLabel; 
 
public class Formulario extends JFrame { 
 //Declaração de Objetos a serem Usados. 
 private JPanel buttonJPanel; 
 private JPanel textJPanel; 
 private JPanel radioJPanel; 
 private JPanel botoesEscolhaPainel; 
 private JPanel textoPainel; 
 private JPanel botoesPainel; 
 private JTextField textoMatricula; 
 private JTextField textoNome; 
 private JTextField textoCurso; 
 private JLabel escreveMatricula; 
 private JLabel escreveNome; 
 private JLabel escreveCurso; 
 private JButton botaoSalvar; 
 private JButton botaoEscreveDados; 
 private JButton botaoSair; 
 private JButton[] buttons; 
 private JRadioButton[] radioEngenheiro= new JRadioButton[5]; 
 private JRadioButton[] radioTecnico= new JRadioButton[5]; 
 private ButtonGroup radioGroup; 
 Engenheiro[] Eng = new Engenheiro[5]; 
 Tecnico[] Tec = new Tecnico[5]; 
21 
 
 int numEng =1; 
 int numTec = 5; 
 private int indice=0; 
 
 public Formulario() { 
 super("Formulario de Cadastro de Engenheiros"); 
 
 botoesEscolhaPainel= new JPanel(); 
 textoPainel= new JPanel(); 
 botoesPainel= new JPanel(); 
 //Inicializando os vetores de Engenheiros e Técnicos 
 for( int i=0; i< numEng; i++ ) { 
 Eng[i]= new Engenheiro(); 
 } 
 for( int i=0; i< numTec; i++ ) { 
 Tec[i]= new Tecnico(); 
 } 
 //Criando RadioButtons para cada Engenheiro e Técnico 
 for(int i =0; i < numEng; i ++) { 
 radioEngenheiro[ i ]= new JRadioButton("Engenheiro " +(i +1), true); 
 botoesEscolhaPainel.add( radioEngenheiro[ i ] ); 
 } 
 for(int i =0; i < numTec; i ++) { 
 radioTecnico[ i ]= new JRadioButton("Tecnico " +(i +1), true); 
 botoesEscolhaPainel.add( radioTecnico[ i ] ); 
 } 
 //Colocando os RadioButtons no mesmo grupo. 
 radioGroup = new ButtonGroup(); 
 for(int i =0; i < numEng; i ++) { 
 radioGroup.add(radioEngenheiro[ i ] ); 
 } 
 for(int i =0; i < numTec; i ++) { 
 radioGroup.add(radioTecnico[ i ] ); 
 } 
 //Adicionando Labels e Caixas de Texto ao Formulario 
 escreveMatricula= new JLabel("Matricula: ");//Instancia o Objeto dando a ele conteudo 
 textoPainel.add(escreveMatricula); // Adiciona-o ao formulario 
 textoMatricula = new JTextField(10); //Instancia o Objeto dando a ele tamanho maximo 
 textoPainel.add(textoMatricula); 
 escreveNome= new JLabel(" Nome: "); 
 textoPainel.add(escreveNome); 
 textoNome = new JTextField(40); 
 textoPainel.add(textoNome); 
 escreveCurso= new JLabel(" Curso: "); 
 escreveCurso.setToolTipText("Apenas para engenheiros"); //Insere anotação de ajuda no 
objeto 
 textoPainel.add(escreveCurso); 
22 
 
 textoCurso = new JTextField(20); 
 textoPainel.add(textoCurso); 
 //Instanciando, adicionando e definindo texto dos botões 
 botaoSalvar= new JButton(" Salvar "); 
 botoesPainel.add(botaoSalvar); 
 botaoEscreveDados = new JButton("Escreve Dados"); 
 botoesPainel.add(botaoEscreveDados); 
 botaoSair= new JButton(" Sair "); 
 botoesPainel.add(botaoSair); 
 //Criando um objeto de administração de eventos relacionados aos botões 
 ButtonHandler handler = new ButtonHandler(); 
 //Atribuindo aos eventos relacionados aos botões os eventos definidos no "handler" 
 botaoSalvar.addActionListener(handler); 
 botaoEscreveDados.addActionListener(handler); 
 botaoSair.addActionListener(handler); 
 //Atribuindo o handler aos radiobuttons 
 for(int i =0; i < numEng; i ++) { 
 radioEngenheiro[ i ].addItemListener( new RadioButtonHandler(i)); 
 } 
 for(int i =0; i < numTec; i ++) { 
 radioTecnico[ i ].addItemListener( new RadioButtonHandler(i + numEng)); 
 } 
 //Adicionando os paineis ao formulario e definindo sua posição 
 add(botoesEscolhaPainel, BorderLayout.NORTH); 
 add(textoPainel, BorderLayout.CENTER); 
 add(botoesPainel, BorderLayout.SOUTH); 
 // desmarcando os dados no radiobutton 
 radioGroup.clearSelection(); 
 } 
 
 private class ButtonHandler implements ActionListener { 
 //classe de administração de eventos relacionados aos botões 
 
 public void actionPerformed(ActionEvent event) { 
 
 if (event.getSource() == botaoSair) { //Definindo procedimento para o botão sair 
 System.exit(0); 
 } 
 
 if (event.getSource() == botaoSalvar) { //Definindo procedimento para o botão salvar 
 if(indice< numEng) { 
 Eng[indice].alteraDados(Integer.parseInt(textoMatricula.getText() ), 
String.format(textoNome.getText() ), String.format(textoCurso.getText() )); 
 } else { 
 Tec[indice - numEng].alteraDados(Integer.parseInt(textoMatricula.getText() ), 
String.format(textoNome.getText() )); 
 } 
23 
 
 
 } 
 
 if( event.getSource() == botaoEscreveDados) { //Definindo procedimento para o botão 
de escrever dados 
 String escreveTexto=""; 
 for(int i=0; i< numEng; i++ ){escreveTexto += "Engenheiro " + i + " Matricula " + Eng[i].matricula + " Nome " + 
Eng[i].nome + " Curso " + Eng[i].curso + "\n"; 
 } 
 for(int i=0; i< numTec; i++ ){ 
 escreveTexto += "Tecnico " + i + " Matricula " + Tec[i].matricula + " Nome " + 
Tec[i].nome + "\n"; 
 } 
 JOptionPane.showMessageDialog(Formulario.this, escreveTexto); 
 } 
 
 } 
 } 
 
 public class RadioButtonHandler implements ItemListener { // Administrador de eventos 
relacionado ao radiobutton 
 private int engnum; 
 
 public RadioButtonHandler(int i){ //construtor 
 engnum= i; 
 indice= engnum; 
 } 
 
 public void itemStateChanged(ItemEvent event) { //Procedimento para trocar o 
radiobutton selecionado e modificar os campos habilitados no formulario 
 indice= engnum; 
 if(engnum < numEng) { 
 textoMatricula.setEditable(true); 
 escreveMatricula.setToolTipText("Habilitado para engenheiros"); 
 textoNome.setEditable(true); 
 escreveNome.setToolTipText("Habilitado para engenheiros"); 
 textoCurso.setEditable(true); 
 escreveCurso.setToolTipText("Habilitado para engenheiros"); 
 }else { 
 textoMatricula.setEditable(true); 
 escreveMatricula.setToolTipText("Habilitado para tecnicos"); 
 textoNome.setEditable(true); 
 escreveNome.setToolTipText("Habilitado para tecnicos"); 
 textoCurso.setEditable(false); 
 escreveCurso.setToolTipText("Desabilitado para tecnicos"); 
 textoCurso.setText("Desabilitado"); 
24 
 
 } 
 escreveDadosNaJanela(); 
 } 
 
 public void escreveDadosNaJanela(){ //Metodo para preencher os dados do formulario 
quando se troca de radiobutton 
 if(indice < numEng) { 
 textoNome.setText( String.format( Eng[indice].nome ) ); 
 textoMatricula.setText( String.format("%d", Eng[indice].matricula) ); 
 textoCurso.setText( String.format(Eng[indice].curso) ); 
 }else { 
 textoNome.setText( String.format( Tec[indice - numEng].nome ) ); 
 textoMatricula.setText( String.format("%d", Tec[indice - numEng].matricula) ); 
 } 
 
 } 
 } 
 
} 
 
public class Engenheiro { 
 //Declaração de Atributos 
 public int matricula=0; 
 public String nome=""; 
 public String curso=""; 
 
 //Declaração de Métodos 
 public void alteraDados(int matricula,String nome,String curso){ 
 this.curso=curso; 
 this.nome=nome; 
 this.matricula=matricula; 
 } 
} 
 
public class Tecnico { 
 //Declaração de Atributos 
 public int matricula=0; 
 public String nome=""; 
 
 //Declaração de Métodos 
 public void alteraDados(int matricula,String nome){ 
 this.nome=nome; 
 this.matricula=matricula; 
 } 
} 
 
25 
 
import javax.swing.JFrame; 
import javax.swing.JOptionPane; 
 
public class TestaEngenheiros { 
 
 public static void main(String[] args) { 
 // TODO code application logic here 
 Formulario panelFrame= new Formulario(); 
 panelFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE); 
 panelFrame.setSize(700, 300); 
 panelFrame.setVisible( true ); 
 } 
 
} 
	Capa
	Apostila de Programação II