Curso de POO Java

Prévia do material em texto

Kerollayne Santos de Matos 
 
Curso de POO Java (Programação Orientada a Objetos) 
Curso em Vídeo 
Curso POO Teoria #01a - O que é Programação Orientada a Objetos 
No primeiro vídeo ele se refere há origem da orientação a objeto. 
Começando com a sigla POO que passou a ser utilizada com mais 
frequência os dias de hoje, está é a sigla para em português para 
programação orientada a objeto, o principal objetivo da POO é aproximar o 
mundo digital do mundo real. 
Mas antes de se aprofundar na POO, ele lembra como era a programação 
anteriormente, sendo por volta da década de 40 à programação era de baixo 
nível, ou seja, todas as instruções eram dadas aos computadores da maneira 
que ele compreendia, exemplo: se o computador era em binário as 
instruções deveriam ser dadas em binário e quem programa não eram os 
programadores e sim os engenheiros. Logo após começou a surgir de forma 
modesta à programação que foi considerada de alto nível, também chamada 
de programação linear, que é uma programação já compreensível para os 
programadores apesar de não haver tanta liberdade de fazer as coisas, 
sendo linear sem nenhum desvio, por exemplo: uma lista de compra, “você 
vai comprar arroz, feijão e só.” Não tinha uma rotina, mas ainda foi 
considerado melhor. A evolução da programação linear deu origem a 
programação estruturada, esta programação permitia pequenos pedaços de 
programação linear organizados de maneira em pudessem ser executados 
fora de ordem natural, os fazendo pararem de ser pequenos programas e 
dando origem aos sistemas, com o crescimento dos sistemas a programação 
estruturada passou a falhar em alguns conceitos, criando a necessidade de 
criar outro tipo de programação. A partir desta necessidade veio então a 
programação modular, ela permitia que se criasse pequenos módulos 
estruturados valorizando dados e funcionalidades, os colocando em 
pequenas capsulas protegidas, que poderia compor sistemas cada vez 
maiores. Mas esse tipo de programação durou pouco tempo pois logo 
surgiu outro que ampliava ainda mais os conceitos de programação, a 
programação orientada a objeto. 
Apesar de a POO crescer de forma evolutiva, ainda pode ser considerado 
que ela teve um criador que foi Alan Kay, ele era formado em matemática, 
o que lhe deu um ótimo raciocínio logico, e também era formado em 
biologia, que deu origem a grande maioria dos conceitos relacionados a 
programação orientada a objeto, ele formulou isto quando ainda não havia 
o conceito de graduação em informática, no ano de 1970. Ele também criou 
muitos projetos voltados a educação das crianças, mesmo apor entrar na 
empresa Xerox. Lá ele criou o Dynabook que deveria ser algo dinâmico 
para as crianças poderem interagir e aprender, mas para isso ele teve que 
criar uma nova linguagem de programação, com conceitos voltados a 
objetos, para isso ele liderou sua equipe na criação do que hoje é 
considerada a primeira linguagem de programação orientada a objeto o 
Smalltalk. 
Antes da POO, tanto a programação estruturada quando a modular era 
divididas os dados são tratados todos juntos, havia uma grande massa de 
dados que eram tratados por procedimentos, esses procedimentos vão ter 
acesso à massa de dados, filtrar os dados pertinentes, processa-la e gerar 
resultados, nessa estrutura os procedimentos não irão fazer uso de roda a 
massa de dados, eles irão fazer uso dos dados que lhes convém, o que o 
torna “bagunçado”. Alan Kay então quis trabalhar com coisas bem menores 
que ele batizou de objeto, sendo assim, se teria dados de objetos e métodos 
que fariam aquisições dos dados e processamento, os métodos fazem uso 
dos dados pertinente a aquele objeto, sem precisar filtrar o que facilita a 
programação, também é possível ter mais de um objeto em um projeto 
orientado a objeto, além de poder comunicar os objetos entre eles, havendo 
troca de dados. Existem varias linguagens orientadas a objeto, como C++, 
Java, PHP, Python, Ruby e Visual Basic, entre outras. 
As principais vantagens da POO são: 
Ser Confiável: o isolamento entre as partes gera software seguro. Ao alterar 
uma parte, nenhuma outra é afetada. 
Ser Oportuno: ao dividir tudo em partes, varias delas podem ser 
desenvolvida em paralelo. 
Ser Manutenível: atualizar um software é mais fácil. Uma pequena 
modificação vai beneficiar todas as partes que usarem o objeto. 
Ser Extensível: o software não é estático. Ele deve crescer para permanecer 
útil. 
Ser Reutilizável: podemos usar objetos de um sistema que criamos em 
outro sistema no futuro. 
Ser Natural: uma coisa natural é mais fácil de entender. Você se preocupa 
mais na funcionalidade do que nos detalhes de implementação. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Java #01b - Instalando o JDK e NetBeans 
Esse vídeo se refere à instalação e configuração do ambiente Java. 
Para fazer a instalação e configuração do ambiente Java é necessário duas 
coisas principais: se precisa do JDK ( Quite de desenvolvimento para Java) 
que é fornecido pela Oracle, também é necessário um editor de código, ele 
recomenda o NetBeans que tem uma facilidade maior, ele fixa que o 
NetBeans deve ser especifico para Java. 
Usando as palavras chave de JDK e NetBeans como pesquisa no google, 
logo o primeiro site que aparecera será o site da Oracle 
(http://www.oracle.com/technetwork/pt/java/javase/downloads/jdk-
netbeans-jsp-3413153-ptb.html), não se recomenda se baixar de outro site 
sem ser o da Oracle, pois este é o site oficial e o download é gratuito, na 
pagina você clica em “Accept License Agreement” ( Aceitar acordo de 
licença), depois se clica no download próprio para o sistema de seu 
computador, o download se inicia automaticamente. Após isso é simples, se 
procura aonde se encontra o instalador e começa a instalação normal, assim 
que concluir o ambiente já estará configurado. 
Não é necessário nada, além disto, então já se pode abrir o programa 
clicando nele (NetBeans), o NetBeans é igual em todos os sistemas, no 
inicio ira aparecer apenas a tela de apresentação, logo se seguiu uma serie 
de passos para demonstração de como se funciona o programa: 
Ele clica na folha amarela com um “+” verde em cima (Novo Projeto), 
aparecera uma tela menor, nela se escolhe “Java” e do lado em “aplicação 
Java”, aperta próximo, ele então da um nome para o projeto “OlaMundo”, 
se mantem tudo da forma que está, e depois clica em finalizar. Após tudo 
isso se teve o inicio do código dele, após se apagar os comentários se 
obteve este código inicial: 
package olamundo; 
public class OlaMundo { 
 public static void main(String[ ] args) { 
 } 
} 
Em baixo da frase “public static void main(String[ ] args) { ” se escreve 
“sout” e aperta a tecla tab, ira aparecer : “System.out.println("");” entre os 
parênteses ele escreveu “Olá, Mundo”, então ele salva e apertou o play 
verde para executar sem erro. Na parte de baixo da tela aparecera “Olá, 
Mundo” e tudo estará funcionando corretamente. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Teoria #02a - O que é um Objeto? 
Uma definição de objeto que esta em livros de programação orientada a 
objeto é: 
“Coisa material ou abstrata que pode ser percebida pelos sentidos e descrita 
por meio de suas características, comportamento e estado atual.” 
Sendo assim um objeto pode ser uma coisa concreta que é o que 
normalmente conseguimos identificar como objeto, mas um objeto é tudo 
que tem característica, comportamento e estado é considerado um objeto. 
Existe o objeto e omolde que seria para classificar e como o nome já diz 
essa é a classe do objeto, pelo conceito de POO uma classe tem sempre que 
responder três perguntas: 
Que coisas eu tenho? 
Que coisas eu faço? 
Como eu estou agora? 
Essas perguntas dentro de POO têm nomes específicos, que são: 
Que coisas eu tenho? 
São atributos; 
Que coisas eu faço? 
São métodos; 
Como eu estou agora? 
São Estados. 
Isso é algo necessário para todos os objetos, e todo objeto obrigatoriamente 
tem atributo, método e estado que está na descrição. Todo objeto também 
vem há partir de um molde, ou seja, uma classe, pois para se fazer um 
objeto, industrialmente falando, primeiro deve se criar um molde e para se 
criar esse objeto é preciso “Instanciar” a classe para que a partir dela se crie 
um objeto. 
A definição oficial de classe é a definição de atributos e métodos comuns 
que serão compartilhados por um objeto. 
Também há a abstração que por muitos é considerada o primeiro pilar da 
POO já que é o conceito que separa o que é necessário para uma 
determinada situação, o que é relevante daquele objeto para aquela 
situação. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Java #02b - Criando Classes e Objetos em Java 
Neste vídeo ele vai criar o objeto caneta com um novo projeto que ele 
chamou de “Aula02”, dentro ele criou outra classe “Caneta”, sendo este o 
rascunho: 
Classe Caneta 
Modelo: caractere 
Cor: caractere 
Ponta: real 
Carga: inteiro 
Tampa: logico 
Método rabiscar() 
Se (tampada) então 
 Escreva (“Erro”) 
Senão 
 Escreva (“Rabisco”) 
 FimMetodo 
Metodo tampar() 
Tampada = verdadeiro 
FimMetodo 
 FimClasse 
 
 Lembrando que no Java toda classe começa com a letra maiúscula, la ele 
colocou os atributos de Caneta, que ficou assim: 
 
package aula02; 
public class Caneta { 
 String modelo; 
 String cor; 
 float ponta; 
 int carga; 
 boolean tampada; 
} 
 
Criando os cinco atributos de Caneta, então ele criou os métodos, que ficou 
assim: 
 
 
package aula02; 
 
public class Caneta { 
 String modelo; 
 String cor; 
 float ponta; 
 int carga; 
 boolean tampada; 
 
 void rabiscar( ){ 
 
 } 
 
 void tampar( ){ 
 
 } 
 
 void destampar( ){ 
 
 } 
} 
 
Ficando com cinco atributos e três métodos, da mesma forma que se referiu 
anteriormente, e é possível utilizar a classe caneta dentro de qualquer 
pacote, na situação ele usou dentro do pacote “Aula02”, e uma vez que há a 
classe é possível instanciar a classe e criar um objeto: 
package aula02; 
 
public class Aula02 { 
 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta(); 
 } 
} 
 
E após criar o objeto é possível mexer nos atributos, por exemplo: 
 
 
 
 
package aula02; 
 
public class Aula02 { 
 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta(); 
 c1.cor = "Azul"; 
 c1.ponta = 0.5f; 
 c1.tampada = false; 
 } 
} 
 
Mas ainda não ira mostra escrito na hora que executar, mostrando apenas 
a frase, “run: 
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)”, 
Para que o que se foi feito apareça durante a execução se deve criar um 
método para poder mostrar o estado do objeto, para que isso aconteça a 
classe “Caneta” ficara assim: 
package aula02; 
 
public class Caneta { 
 String modelo; 
 String cor; 
 float ponta; 
 int carga; 
 boolean tampada; 
 void status() { 
 System.out.println("Uma caneta " + this.cor); 
 System.out.println("está tampada? " + this.tampada); 
} 
 void rabiscar(){ 
 } 
 
 void tampar(){ 
 } 
 
 void destampar(){ 
 } 
} 
 
E a classe “Caneta” fica assim: 
package aula02; 
 
public class Aula02 { 
 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta(); 
 c1.cor = "Azul"; 
 c1.ponta = 0.5f; 
 c1.tampada = false; 
 c1.status(); 
 } 
} 
 
Logo após ele cria os métodos restantes, que faltam para os outros 
atributos: 
package aula02; 
 
public class Caneta { 
 String modelo; 
 String cor; 
 float ponta; 
 int carga; 
 boolean tampada; 
 void status() { 
 System.out.println("Modelo: " + this.modelo); 
 System.out.println("Uma caneta: " + this.cor); 
 System.out.println("Ponta: " + this.ponta); 
 System.out.println("Carga: " + this.carga); 
 System.out.println("está tampada? " + this.tampada); 
} 
 void rabiscar(){ 
 
 } 
 
 void tampar(){ 
 
 } 
 
 void destampar(){ 
 
 } 
} 
 
Então ele começou a trabalhar o método “tampada”: 
package aula02; 
 
public class Caneta { 
 String modelo; 
 String cor; 
 float ponta; 
 int carga; 
 boolean tampada; 
 void status() { 
 System.out.println("Modelo: " + this.modelo); 
 System.out.println("Uma caneta: " + this.cor); 
 System.out.println("Ponta: " + this.ponta); 
 System.out.println("Carga: " + this.carga); 
 System.out.println("está tampada? " + this.tampada); 
} 
 void rabiscar(){ 
 
 } 
 
 void tampar(){ 
 this.tampada = true; 
 } 
 
 void destampar(){ 
 this.tampada = false; 
 } 
} 
 
E modifica a forma de chamar o método: 
package aula02; 
 
public class Aula02 { 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta(); 
 c1.cor = "Azul"; 
 c1.ponta = 0.5f; 
 c1.tampar(); 
 c1.status(); 
 } 
} 
 
Ele então termina a programação deixando o código final da classe 
“Caneta”: 
package aula02; 
 
public class Caneta { 
 String modelo; 
 String cor; 
 float ponta; 
 int carga; 
 boolean tampada; 
 void status() { 
 System.out.println("Modelo: " + this.modelo); 
 System.out.println("Uma caneta: " + this.cor); 
 System.out.println("Ponta: " + this.ponta); 
 System.out.println("Carga: " + this.carga); 
 System.out.println("está tampada? " + this.tampada); 
} 
 void rabiscar(){ 
 if (this.tampada == true) { 
 System.out.println("ERRO, não posso rabiscar."); 
 } else{ 
 System.out.println("Estou Rabiscando"); 
 } 
 } 
 
 void tampar(){ 
 this.tampada = true; 
 } 
 
 void destampar(){ 
 this.tampada = false; 
 } 
} 
 
Na programação não é obrigatório ter apenas um objeto, então ele cria 
outro objeto deixando o código da classe “Aula02” assim: 
 
 
 
package aula02; 
 
public class Aula02 { 
 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta(); 
 c1.cor = "Azul"; 
 c1.ponta = 0.5f; 
 c1.tampar(); 
 c1.status(); 
 c1.rabiscar(); 
 
 Caneta c2 = new Caneta(); 
 c2.modelo = "Hostnet"; 
 c2.cor = "Preta"; 
 c2.destampar(); 
 c2.status(); 
 c2.rabiscar(); 
 } 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Teoria #03a - O que é Visibilidade em um Objeto? 
 
Segundo ele se não se entender o que é a visibilidade não se entendera a 
essência da POO, mas antes de entrar neste assunto ele se refere a 
Linguagem de Modelagem Unificada, ele usa as iniciais de cada palavra 
para descrever algo que muitos já ouviram LMU, mas se você ver de trás 
para frente fica as verdadeiras iniciais que é UML, apesarde não ser o foco 
do vídeo, UML é muito importante para a POO, ele ira se referir aos 
conceitos e principalmente ao Diagrama de Classes. 
A UML leva a simplicidade ao extremo, pois para o Diagrama de Classes 
toda classe é um retângulo independente há que se refere à forma de fazer é 
neste retângulo na parte superior com a primeira letra maiúscula se coloca 
o nome da classe e após trace uma linha em baixo da classe e outra linha no 
meio do retângulo, separando assim a parte de cima que é o cabeçalho que 
é aonde esta o nome da classe, o miolo que é o corpo central e a parte de 
baixo, no corpo central se coloca todos os atributos e na parte de baixo se 
coloca os métodos que tem parênteses depois. 
Após isso ele volta ao assunto principal do vídeo que é os modificadores de 
visibilidade, existem três tipos de modificadores de visibilidade, o termo 
técnico de modificadores de visibilidade é, “indicam o nível de acesso os 
componentes internos de uma classe”, no caso os atributos e os métodos, a 
visibilidade vai dizer qual o nível de acesso que se tem a eles. 
Dentro da nomenclatura da UML, que é universal, existem três símbolos 
que se referem à visibilidade: 
O símbolo “+” que significa público. 
O símbolo “-” que significa privado. 
E o símbolo “#” que significa protegido. 
E cada uma dessas visibilidades também tem uma definição: 
Público: a classe atual e todas as outras classes, onde todo mundo vai poder 
ver e usar esse atributo livremente. 
Privado: somente a classe atual, onde somente a classe em que ele esta 
pode mexer nele. 
Protegido: a classe atual e todas as suas subclasses. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Java #03b - Configurando Visibilidade de Atributos e Métodos 
 
Ele clica com o botão direito em cima da programação anterior e há copia 
modificando o nome para “Aula03”, ele então apaga as chamadas de 
métodos, deixando apenas o “status” e então executa o que aparece é 
apenas o padrão: 
run: 
Modelo: null 
Uma caneta: null 
Ponta: 0.0 
Carga: 0 
está tampada? false 
CONSTRUÍDO COM SUCESSO (tempo total: 3 segundos) 
 
 Ele então ira acrescentar os fatores de publico, protegido e privado que foi 
citado no vídeo anterior, e também criou um modelo baseado na caneta que 
ele criou anteriormente só que ele acrescentou a visibilidade: 
Classe Caneta 
Público Modelo: caractere 
Público Cor: caractere 
Privado Ponta: real 
Protegido Carga: inteiro 
Protegido Tampa: logico 
Público Método rabiscar( ) 
 Se (tampada) então 
 Escreva (“Erro”) 
 Senão 
 Escreva (“Rabisco”) 
 FimMetodo 
Privado Metodo tampar( ) 
 Tampada = verdadeiro 
 FimMetodo 
 FimClasse 
 
Então ele passou este rascunho para o programa copiado anteriormente, e 
executou provando que estava funcionado perfeitamente, após ele tenta 
definir os dados de um objeto que ele está criando, no caso uma caneta, os 
dois primeiros ele consegue fazer normalmente mas o terceiro por estar 
com a visibilidade protegida so pode ser mexido dentro da classe “Caneta” 
o NetBeans mostra que está com erro, ele muda para publico mostrando 
que poderia mudar mas então volta para privado como esta no exemplo que 
ele deu, então ele colocou a linha como comentário já que ela deu erro, ele 
testa a visibilidade em outro lugar, no caso em “rabiscar( )”. 
Ele também mostra que mesmo que o código privado esteja sendo usado 
dentro de um público ele ainda vai executar no final o código de “Caneta” 
ficou assim: 
package aula02; 
 
public class Caneta { 
 public String modelo; 
 public String cor; 
 private float ponta; 
 protected int carga; 
 private boolean tampada; 
 public void status() { 
 System.out.println("Modelo: " + this.modelo); 
 System.out.println("Uma caneta: " + this.cor); 
 System.out.println("Ponta: " + this.ponta); 
 System.out.println("Carga: " + this.carga); 
 System.out.println("está tampada? " + this.tampada); 
} 
 public void rabiscar(){ 
 if (this.tampada == true) { 
 System.out.println("ERRO, não posso rabiscar."); 
 } else{ 
 System.out.println("Estou Rabiscando"); 
 } 
 } 
 
 public void tampar(){ 
 this.tampada = true; 
 } 
 
 public void destampar(){ 
 this.tampada = false; 
 } 
} 
 
 
E a classe “Aula02” ficou assim: 
package aula02; 
 
public class Aula02 { 
 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta(); 
 c1.modelo = "BIC Cristal"; 
 c1.cor = "Azul"; 
 //c1.ponta = 0.5f; 
 c1.carga = 80; 
 //c1.tampada = true; 
 c1.tampar(); 
 c1.status(); 
 c1.rabiscar(); 
 
 } 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Teoria #04a - Métodos Especiais 
 
Ele lembra que dentro de POO é possível o programador fazer vários 
métodos, mas existem métodos específicos que são padronizados, esses 
métodos são chamados de Getter, Setter e método Construtor, ao longo 
desta vídeo aula ele explica cada um desses métodos: 
Getter: mais conhecido como método get, esse método é um método 
assessor, que pega uma informação, ele deu exemplo de uma estante em 
que tem documentos em cima, então vem um homem é pesquisa por esses 
documentos quais desses documentos é dele, e ele vê que há 5 documento, 
logo vem uma mulher e faz a mesma coisa e vê que há 12 documentos dela 
lá. Mas ele então lembra que cada pessoa realmente daria livre acesso a um 
lugar com documentos, então que entra o método Getter, ele serve como 
um interceptador, aonde ele faz o mesmo trabalho que um recepcionista, 
intercepta a que você quer, realiza a consulta e só então passa a resposta 
para você. Apesar de mais longo, ele é mais seguro. 
Setter: neste ele diz que o homem ira colocar mais um documento na mesa, 
algo simples, mas então vem outra pessoa e que fazer a mesma coisa, a 
segurança e organização deste método podem ser garantidos? Este método 
além de mais curto deixaria tudo de forma muito mais simples. Assim 
como no método Setter este método tem um interceptador que funciona da 
mesma forma que um recepcionista, ele ira ver que o homem que colocar 
um documento na estante, então esse documento iria para o método e o 
próprio método iria direcionar e organizar estes documentos na estante. 
Construtor: serve para que possa se definir parâmetros fixos em cada 
objeto, fazendo com que todos os objetos criados a partir dai tenha este 
parâmetro em comum, por exemplo a cor, o modelo, o tamanho, etc. 
Esses são os métodos especiais explicado no vídeo, são como já foi dito 
anteriormente métodos já pre definidos dentro da programação Java, e que 
são essenciais para o desenvolvimento do programa. 
 
 
 
Curso POO Java #04b - Métodos Getter, Setter e Construtor 
 
Como ele fez anteriormente ele utilizou a classe caneta, ele utilizou este 
rascunho: 
 
Classe Caneta 
 
Público Modelo: caractere 
Privado Ponta: real 
 
Público Método getModelo( ) 
 retorne modelo 
 FimMetodo 
 
Publico Metodo setModelo 
 (m: cactere) 
 Modelo = m 
 FimMetodo 
 
Público Método getPonta( ) 
 retorne ponta 
 FimMetodo 
 
Publico Metodo setPonta 
 (p: cactere) 
 Modelo = p 
 FimMetodo 
 
 FimClasse 
 
Ao contrario do anterior ele criou a programação do zero, ele também 
enfatiza que os métodos Get e Set sempre serão públicos. Também graças 
ao método construtor a forma de se colocar a informação se tornou muito 
maissimples, apesar de tudo usar estes métodos valem a pena apesar da 
subclasse ficar maior, mas só será necessário escreve-la uma única n=vez e 
após você poderá usar ela para criar quantos objetos quiser há usando como 
molde. 
No final a classe Aula04 ficou assim: 
 
 
package aula04; 
public class Aula04 { 
 
 public static void main(String[] args) { 
 Caneta c1 = new Caneta("NIC", 0.4f, "Amarela"); 
 
 c1.setModelo("BIC"); 
 //c1.modelo = "BIC"; 
 
 c1.setPonta(0.5f); 
 //c1.ponta = 0.5f; 
 
 c1.status(); 
 
 } 
 
} 
 
E a classe Caneta ficou assim: 
package aula04; 
 
public final class Caneta { 
 private String modelo; 
 private float ponta; 
 private String cor; 
 private boolean tampada; 
 
 public Caneta(String m, float p, String c) { 
 this.setCor(c); 
 this.setModelo(m); 
 this.setPonta(p); 
 this.tampar(); 
 } 
 
 public String getModelo() { 
 return modelo; 
 } 
 
 public void setModelo(String modelo) { 
 this.modelo = modelo; 
 } 
 
 public float getPonta() { 
 return ponta; 
 } 
 
 public void setPonta(float ponta) { 
 this.ponta = ponta; 
 } 
 
 public String getCor() { 
 return cor; 
 } 
 
 public void setCor(String cor) { 
 this.cor = cor; 
 } 
 
 public final void tampar() { 
 this.tampada = true; 
 } 
 
 public void destampada() { 
 this.tampada = false; 
 } 
 
 public void status(){ 
 System.out.println("Sobre a Caneta:"); 
 System.out.println("Modelo: " + getModelo()); 
 System.out.println("Ponta: " + getPonta()); 
 System.out.println("Cor: " + getCor()); 
 System.out.println("Tampada? " + this.tampada); 
 } 
 
 } 
 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Teoria #05a - Exemplo Prático com Objetos 
 
Neste vídeo ele propõe que todos fação um exercício, e é o seguinte: 
Ele propôs a implementação de uma conta de um banco por meio de 
algoritmo em primeiro lugar, imaginando a seguinte situação, se tem duas 
pessoas o Jubileo e a Creuza, cada um deles tem um dinheiro para 
depositar, o primeiro passo que se deve fazer é abrir a conta do banco, mas 
então existem dois tipos de conta a conta corrente e a conta poupança, o 
Jubileo optou por criar uma conta poupança, então ele vai pegar o dinheiro 
dele, que é R$ 300,00, e ira depositar na conta dele e deixara guardado. Já a 
Creuza resolveu criar uma conta corrente já que ela tem um pouco mais de 
dinheiro, R$ 500,00, cada um teve que criar sua conta e depositar seu 
dinheiro, independente da situação ambos pode sacar seu próprio dinheiro, 
a Creuza precisou de cem reais para comprar um sapato novo, logo ela 
sacou e ficou com R$ 400 na conta. A proposta principal desta atividade é 
transforma a conta corrente em um objeto. 
Usando os vídeos anteriores como base se deve pensar no que se é 
necessário e na estrutura desta classe, ele pensou no seguinte diagrama: 
 
ContaBanco 
Numero da conta 
Tipo 
Dono 
Saldo 
Status 
abrirConta( ) 
fecharConta( ) 
depositar( ) 
sacar( ) 
pagarMensal( ) 
 
Ele então criou situações que se deve seguir para se colocar o exemplo em 
pratica: 
1° coisa, tipo da conta: neste ele ira aceitar apena dois tipos de conta, a 
conta corrente (CC) e a conta poupança (CP). 
2° coisa, método abrirConta( ): para este método se muda o atributo status 
para verdadeiro quando se abre a conta. 
Ele também acrescentou que se a pessoa abrir uma conta corrente ele ganha 
um adicional de R$ 50 na conta, já se for uma conta poupança ele já 
começa a conta com R$ 150. 
O programa também não deve permitir que se saque mais do que R$ 1000. 
O método pagarMensal( ) será descontado o valor diretamente do saldo, 
para a conta poupança será cobrado R$ 20 e para a conta corrente será 
cobrado R$ 12 de mensalidade. 
Além dos métodos ali descritos também estão incluídos também os 
métodos get e set. 
Ao longo do vídeo ele analisa e explica cada método que ira ser utilizado 
 
 
 
 
 
 
 
 
 
 
 
Curso POO Java #05b - Exemplo Prático em Java 
 
Neste vídeo ele cria a programação que foi definida no diagrama de classe 
do vídeo anterior, para isso ele criou um novo projeto com o nome de 
“Aula05”, e iniciou a programação. 
As definições dos atributos da casse Conta Banco: 
package aula05; 
public class ContaBanco { 
 public int numConta; 
 private String tipo; 
 private String dono; 
 private float saldo; 
 private boolean status; 
 
} 
 
Então ele começa a formatação do código pré-definido pelo diagrama de 
classe: 
 
 public void abrirConta() { 
 
} 
 public void fecharConta(){ 
 
 } 
 public void depositar() { 
 
 } 
 public void sacar() { 
 
 } 
 public void pagarMensal() { 
 
 } 
public ContaBanco() { 
 } 
public int getNumConta() { 
 return numConta; 
 } 
 public void setNumConta(int numConta) { 
 this.numConta = numConta; 
 } 
 
 public String getTipo() { 
 return tipo; 
 } 
 
 public void setTipo(String tipo) { 
 this.tipo = tipo; 
 } 
 
 public String getDono() { 
 return dono; 
 } 
 
 public void setDono(String dono) { 
 this.dono = dono; 
 } 
 
 public float getSaldo() { 
 return saldo; 
 } 
 
 public void setSaldo(float saldo) { 
 this.saldo = saldo; 
 } 
 
 public boolean isStatus() { 
 return status; 
 } 
 
 public void setStatus(boolean status) { 
 this.status = status; 
 } 
public void abrirConta(String t) { 
 this.setTipo(t); 
 this.setStatus(true); 
 if (t == "CC") { 
 this.setSaldo(50); 
 
 } else if ( t== "CP"){ 
 this.setSaldo(150); 
 } 
 System.out.println("Conta Aberta com sucesso !!!"); 
} 
 public void fecharConta(){ 
 if (this.getSaldo()> 0) { 
 System.out.println("Conta não pode ser fechada por ter saldo"); 
 
 } else if(this.getSaldo() < 0 ) { 
 System.out.println("Conta não pode ser fechada por ter débito"); 
 } else { 
 this.setStatus(false); 
 System.out.println("Conta fechada com sucesso"); 
 } 
 
 } 
 public void depositar(float V) { 
 if(this.getStatus()){ 
 this.setSaldo(this.getSaldo() + V); 
 System.out.println("Deposito realizado com sucesso na conta de " + 
this.getDono()); 
 } else { 
 System.out.println("Impossivel depositar em uma conta fechada"); 
 } 
 
 } 
 public void sacar(float V) { 
 if(this.getStatus()){ 
 if(this.getSaldo()>= V){ 
 this.setSaldo(this.getSaldo()- V); 
 System.out.println("Saque realizado na conta de" + this.getDono()); 
 } else { 
 System.out.println("Saldo insuficiente para saque"); 
 } 
 } else { 
 System.out.println("Impossivel sacar de uma conta fechada !"); 
 } 
 
 
 } 
 public void pagarMensal() { 
 int V = 0; 
 if (this.getTipo() == "CC") { 
 V = 12; 
 
 } else if(this.getTipo() == "CP") { 
 V = 20; 
 } 
 if(this.getStatus()){ 
 this.setSaldo(this.getSaldo() - V); 
 System.out.println("Mensalidade paga com sucesso por" +this.getDono()); 
 } else { 
 System.out.println("Impossivel pagar uma conta fechada !"); 
 } 
 
 } 
 
 public ContaBanco() { 
 this.saldo=0; 
 this.status=false; 
 } 
 
 public int getNumConta() { 
 return numConta; 
 } 
 
 public void setNumConta(int numConta) { 
 this.numConta = numConta; 
 } 
 
 public String getTipo() { 
 return tipo; 
 } 
 
 public void setTipo(String tipo) { 
 this.tipo = tipo; 
 } 
 
 public String getDono() { 
 return dono; 
 } 
 
 public void setDono(String dono) { 
 this.dono = dono; 
 } 
 
 public float getSaldo() { 
 return saldo; 
 } 
 
 public void setSaldo(float saldo) { 
 this.saldo = saldo; 
 } 
 
 public boolean getStatus() { 
 return status; 
 } 
 
 public void setStatus(boolean status) { 
 this.status = status; 
 } 
 
 
Na parte da classe “Aula05” ficaria assim, 
 
package aula05; 
 
 
public class Aula05 { 
 
 public static void main(String[] args) { 
 ContaBanco p1 = new ContaBanco(); 
 p1.setNumConta(1010); 
 p1.setDono("Carlos"); 
 p1.abrirConta("CC") 
 
 ContaBanco p2 = new ContaBanco(); 
 p2.setNumConta(1111); 
 p2.setDono("Ana"); 
 p2.abrirConta("CP"); 
 
 
 p1.depositar(100); 
 p2.depositar(500); 
 
 p1.estadoAtual(); 
 p2.estadoAtual(); 
 }