Portfólio Linguagem Orientada a Objetos

Prévia do material em texto

ENGENHARIA DE SOFTWARE 
UNOPAR – Cidade 
Nome RA: 
 
 
 
 
 
PORTIFÓLIO – RELATÓRIO DE AULA PRÁTICA 
LINGUAGEM ORIENTADA A OBJETOS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Cidade/UF 
2023 
 
Nome RA: 
 
 
 
 
 
 
 
 
PORTIFÓLIO – RELATÓRIO DE AULA PRÁTICA 
LINGUAGEM ORIENTADA A OBJETOS 
 
 
 
 
Trabalho apresentado à Universidade UNOPAR, 
como requisito parcial para a obtenção de média 
semestral nas disciplinas norteadoras do semestre 
letivo. 
 
Tutor (a): Jessica Fernandes Lopes 
 
 
 
 
 
 
 
 
 
 
 
Cidade/UF 
2023 
 
Introdução .................................................................................................................................. 4 
Instalação do ambiente de desenvolvimento ................................................................... 6 
Criando o projeto gerenciaBanco ........................................................................................ 6 
Criação do código gerenciaBanco ...................................................................................... 8 
Código Fonte Completo........................................................................................................ 11 
Testando a aplicação pronta ............................................................................................... 15 
Conclusão ................................................................................................................................ 18 
Referências .............................................................................................................................. 20 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução 
 
Neste projeto emocionante de Gerenciamento Bancário em Java, 
estaremos mergulhando fundo no mundo da programação orientada a objetos. 
Vamos explorar como criar uma aplicação prática que simula um ambiente 
bancário, onde os clientes podem interagir com suas contas, realizar transações 
e consultar saldos, tudo isso com a linguagem de programação Java. 
À medida que avançamos neste projeto, teremos a oportunidade de 
aplicar uma variedade de conceitos essenciais de programação orientada a 
objetos, como a criação de classes e objetos, encapsulamento, herança, 
polimorfismo e uso de estruturas de controle de fluxo. 
Aqui estão alguns dos principais objetivos que iremos alcançar: 
1. Criação de Classes: Vamos criar classes que representam objetos do 
mundo real, como clientes e contas bancárias. Essas classes nos 
permitirão modelar o sistema bancário. 
2. Métodos e Atributos: Implementaremos métodos para realizar 
operações bancárias, como depósitos, saques e consultas de saldo. Além 
disso, aprenderemos a definir atributos para armazenar informações 
relevantes. 
3. Interatividade: Vamos tornar nossa aplicação interativa, permitindo que 
os usuários forneçam informações, façam escolhas e vejam os resultados 
de suas ações. 
4. Tratamento de Erros: Aprenderemos a tratar erros, como a tentativa de 
saque de um valor superior ao saldo disponível. 
5. Experiência Prática em Java: Ganharemos experiência prática em 
programação Java, incluindo entrada e saída de dados do usuário. 
Este projeto é uma oportunidade emocionante para aplicarmos nossos 
conhecimentos de programação orientada a objetos em um cenário do mundo 
real. Ao final, teremos uma aplicação completa de gerenciamento bancário que 
demonstra nossa capacidade de criar programas Java funcionais e sólidos. 
Vamos mergulhar fundo neste projeto e expandir nossas habilidades em 
programação Java. Vamos começar a explorar e construir nossa aplicação de 
gerenciamento bancário! 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Instalação do ambiente de desenvolvimento 
 
Figura1: Instalação do Java e do NetBeans – Fonte Autor do projeto 
 
Neste primeiro momento fizemos as instalações dos programas necessários 
para elaboração da aula prática. 
 
 
Criando o projeto gerenciaBanco 
 
Figura2: Nome do projeto – Fonte Autor do projeto 
 
Nessa tela foi iniciado um novo projeto com o nome gerenciaBanco. 
 
 
 
 
Figura3: Ambiente pronto para o projeto – Fonte Autor do projeto 
 
Ambiente pronto para desenvolvimento da aula prática. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Criação do código gerenciaBanco 
 
O código que vamos criar é uma aplicação simples de gerenciamento bancário 
em Java. Ele consiste em três classes: Cliente, ContaBancaria, e a classe 
principal GerenciaBanco. 
Figura4: Classe Cliente – Fonte Autor do Projeto 
 
Esta classe representa os dados pessoais do cliente, incluindo nome, 
sobrenome e CPF. 
Ela possui um construtor que permite criar um objeto Cliente com esses dados. 
Além disso, possui métodos get para acessar os atributos do cliente. 
 
 
 
 
 
 
 
 
 
 
 
Figura5: Classe ContaBancaria – Fonte Autor do projeto 
 
A classe ContaBancaria representa uma conta bancária com saldo e número de 
conta. 
Ela também possui um construtor que permite criar uma conta com um número 
de conta específico e saldo inicial zero. 
Métodos deposito e saque permitem adicionar ou retirar dinheiro da conta, 
respeitando o saldo disponível. 
O método consultarSaldo retorna o saldo atual da conta. 
 
 
 
 
 
 
 
 
Figura5: Classe principal GerenciaBanco – Fonte Autor do projeto 
 
A classe principal GerenciaBanco contém o método main, que é o ponto de 
entrada da aplicação. 
Ela cria um objeto Cliente com base nas informações fornecidas pelo usuário e 
uma conta bancária fictícia com um número de conta fictício. 
Em seguida, exibe um menu de opções para o usuário, onde ele pode consultar 
o saldo, realizar depósitos, realizar saques ou encerrar a aplicação. 
Um loop do...while é usado para permitir que o usuário faça várias operações 
até escolher encerrar. 
 
 
Código Fonte Completo 
 
Dessa maneira o código fonte ficou da seguinte forma: 
package com.mycompany.gerenciabanco; 
import java.util.Scanner; 
 
// Classe para dados pessoais do cliente 
class Cliente { 
 private String nome; 
 private String sobrenome; 
 private String CPF; 
 
 // Construtor 
 public Cliente(String nome, String sobrenome, String CPF) { 
 this.nome = nome; 
 this.sobrenome = sobrenome; 
 this.CPF = CPF; 
 } 
 
 // Getters e Setters 
 public String getNome() { 
 return nome; 
 } 
 
 public String getSobrenome() { 
 return sobrenome; 
 } 
 
 public String getCPF() { 
 return CPF; 
 } 
} 
 
// Classe para conta bancária 
class ContaBancaria { 
 private double saldo; 
 private int numeroConta; 
 
 // Construtor 
 public ContaBancaria(int numeroConta) { 
 this.numeroConta = numeroConta; 
 this.saldo = 0.0; 
 } 
 
 // Métodos para operações bancárias 
 public void deposito(double valor) { 
 saldo += valor; 
 } 
 
 // public void saque(double valor) { 
 if (valor <= saldo) { 
 saldo -= valor; 
 } else { 
 System.out.println("Saldo insuficiente para saque."); 
 } 
 } 
 
 public double consultarSaldo() { 
 return saldo; 
 } 
} 
 
// Classe principal para a aplicação 
public class GerenciaBanco { 
 public static void main(String[] args) { 
 Scanner input = new Scanner(System.in); 
 
 System.out.println("Bem-vindo ao Gerenciador Bancário!"); 
 System.out.print("Informe seu nome: "); 
 String nome = input.nextLine(); 
 System.out.print("Informe seu sobrenome: "); 
 String sobrenome = input.nextLine(); 
 System.out.print("Informe seu CPF: "); 
 String CPF = input.nextLine(); 
 
 Cliente cliente = new Cliente(nome, sobrenome, CPF); 
 ContaBancaria conta = new ContaBancaria(12345); // Número da conta fictícioint escolha; 
 do { 
 System.out.println("\nEscolha uma opção:"); 
 System.out.println("1. Consultar Saldo"); 
 System.out.println("2. Realizar Depósito"); 
 System.out.println("3. Realizar Saque"); 
 System.out.println("4. Encerrar"); 
 System.out.print("Opção: "); 
 escolha = input.nextInt(); 
 
 switch (escolha) { 
 case 1: 
 System.out.println("Saldo atual: R$" + conta.consultarSaldo()); 
 break; 
 case 2: 
 System.out.print("Informe o valor do depósito: R$"); 
 double valorDeposito = input.nextDouble(); 
 conta.deposito(valorDeposito); 
 System.out.println("Depósito realizado com sucesso!"); 
 break; 
 case 3: 
 System.out.print("Informe o valor do saque: R$"); 
 double valorSaque = input.nextDouble(); 
 conta.saque(valorSaque); 
 break; 
 case 4: 
 System.out.println("Encerrando a aplicação."); 
 break; 
 default: 
 System.out.println("Opção inválida. Tente novamente."); 
 } 
 } while (escolha != 4); 
 
 input.close(); 
 } 
} 
 
 
 
 
Testando a aplicação pronta 
 
Figura6: Informar nome, sobrenome e CPF – Fonte Autor do projeto. 
 
Nessa primeira tela o usuário deve informar seu nome, depois o sobrenome e 
por ultimo o CPF, dessa maneira o programa entrará na aplicação 
gerenciaBanco. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura7: Principais funcionalidades do programa – Fonte Autor do projeto 
 
 
Nesta tela testamos executamos e testamos todos os recursos do programa, 
sendo executado com sucesso sem apresentar nenhum erro. 
Assim finalizamos nossa experiência de aula prática com sucesso. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Conclusão 
 
Chegamos ao fim deste projeto empolgante de Gerenciamento Bancário 
em Java, e gostaria de compartilhar algumas reflexões e conquistas que 
obtivemos ao longo dessa jornada. 
Primeiramente, mergulhamos profundamente no universo da 
programação orientada a objetos. Exploramos conceitos essenciais, como 
classes, objetos, encapsulamento, herança e polimorfismo, e aplicamos esses 
princípios na construção de nosso sistema de gerenciamento bancário. 
Durante o desenvolvimento do projeto, conseguimos: 
1. Criar Classes e Objetos: Aprendemos a criar classes que representam 
entidades do mundo real, como clientes e contas bancárias. Essas 
classes nos permitiram modelar o sistema de forma organizada e 
eficiente. 
2. Implementar Métodos e Atributos: Definimos métodos que 
possibilitaram aos clientes realizar operações bancárias, como depósitos 
e saques. Também utilizamos atributos para armazenar informações 
importantes. 
3. Interagir com os Usuários: Tornamos nossa aplicação interativa, 
permitindo que os usuários fornecessem informações, tomassem 
decisões e visualizassem os resultados de suas ações por meio de um 
menu simples. 
4. Garantir a Integridade dos Dados: Implementamos verificações para 
garantir que as operações bancárias fossem realizadas de forma segura, 
evitando, por exemplo, saques que excedessem o saldo disponível. 
5. Desenvolver Experiência em Java: Ganhamos experiência prática em 
programação Java, incluindo entrada e saída de dados do usuário, 
construção de menus e tratamento de erros. 
Este projeto serviu como uma base sólida para o desenvolvimento de nossas 
habilidades de programação e para a compreensão dos princípios da orientação 
a objetos em Java. É importante ressaltar que, à medida que avançamos em 
nossa jornada como programadores, a aplicação prática desses conceitos 
continuará sendo crucial. 
À medida que concluímos este projeto, temos em mãos uma aplicação de 
gerenciamento bancário totalmente funcional e uma compreensão mais profunda 
de como criar programas Java robustos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Referências 
 
SANCHES, R. Como Instalar o Java JDK e NetBeans IDE : Windows. Disponível 
em: <https://www.webmundi.com/desenvolvimento-de-
sistemas/java/como-instalar-o-java-jdk-e-netbeans-ide-windows/>. Acesso 
em: 9 set. 2023. 
Download the Latest Java LTS Free. Disponível em: 
<https://www.oracle.com/java/technologies/downloads/>. 
Apache NetBeans Releases. Disponível em: 
<https://netbeans.apache.org/download/index.html>.