Implementações de Classes

Prévia do material em texto

FUNDAÇÃO EDSON QUEIROZ
UNIVERSIDADE DE FORTALEZA - UNIFOR
CENTRO DE CIÊNCIAS TECNOLÓGICAS
CURSO DE ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
TÍTULO: IMPLEMENTAÇÕES
GRUPO 68
Carla Thuany Ribeiro Alves - 2415547
Carlos Eduardo Campos Santos - 2415659
Gian Gabriel Valentim do Nascimento - 2326158
Raphaela Maria Batista Barbosa de Oliveira - 2415563
Jorgirerison Leite Peixoto - 2415465
Fortaleza-CE
2024
Implementações:
Figura 1: diagrama de classes UML
Após mapeado as questões, foi feita o diagrama de classes com o site:
https://www.plantuml.com/
- No diagrama as setas com preenchimento branco apontam para “class Mãe”;
- As setas preenchidas e com subscrito 1 indicam que há uma associação de um para
um entre as classes envolvidas, já com o subscrito 0 indica uma relação de 1 para
muitos.
QUESTÃO 1
Classes e Objetos: Crie uma classe abstrata chamada “Pessoa” que represente um ser
humano. Pessoa deve ter atributos como “cpf”, “nome” e “idade”. Implemente os
métodos para definir e obter esses atributos. Crie uma classe “Disciplina” com os
atributos como “codigo”, “nome” e “semestre”.
- Criado de maneira usual e segura os atributos, cpf, nome, e idade como modo “private”,
seguindo as boas práticas de programação onde apenas os métodos podem mexer
com os atributos. Além dos métodos para manipular cada um dos atributos da class
Pessoa. Em seguida um corte retirado do VSCODE, IDE escolhida para realizarmos
nosso projeto.
Classe pessoa, atributos, e métodos:
public abstract class Pessoa {
private String cpf;
private String nome;
private int idade;
public Pessoa(String cpf, String nome, int idade) {
this.cpf = cpf;
this.nome = nome;
https://www.plantuml.com/
this.idade = idade;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getIdade() {
return idade;
}
public void setIdade(int idade) {
this.idade = idade;
}
}
De mesmo modo, apesar de não ser pedido nos decidimos fazer métodos que retornassem e
definissem os atributos da class disciplina.
Classe Disciplina, atributos, e métodos:
public class Disciplina {
private String codigo;
private String nome;
private int semestre;
public Disciplina(String codigo, String nome, int semestre) {
this.codigo = codigo;
this.nome = nome;
this.semestre = semestre;
}
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getSemestre() {
return semestre;
}
public void setSemestre(int semestre) {
this.semestre = semestre;
}
}
QUESTÃO 2
Encapsulamento e Métodos: Evolua a classe “Pessoa” adicionando um método público
para incrementar a idade da pessoa. Crie um método público chamado
“fazerAniversario”.
- A sintaxe dentro do método apenas chama a idade do objeto e através do “++” soma
mais 1, assim quando invocado.
Método fazerAniversário():
public void fazerAniversario() {
this.idade++;
}
QUESTÃO 3
Herança e Polimorfismo: Crie 3 classes derivadas de “Pessoa”, são elas:
“Visitante”, “Aluno” e “Professor”. Adicione um atributo “matrícula” para a classe
“Aluno” e um método “pagarMensalidade”. Adicione um atributo “centro” para a
classe “Professor” e um método “darAula”. Crie 2 classes derivadas de “Aluno”, são
elas: “Bolsista” e “Regular” e faça uma sobreposição no método “pagarMensalidade”
para ambas as classes.
- De mesma maneira, foi criado a class Aluno e seu métodos. Além disso criamos
também seus respectivos métodos apesar de não pedidos no enunciado;
- Detalhe que como Aluno, assim como professor são herdeiros de Pessoas e também
Bolsistas e Regular são herdeiros de Aluno, todas elas vão apresentar um método
construtor que chama a “SuperClass”(denotada como super no código abaixo) mais
próxima de sua linhagem, a class mãe, e a partir dela definiremos também o novo
atributo de aluno nesse caso que é a matrícula.
- A mesma estrutura irá se repetir para Professor, Visitante, Bolsista e Regular.
Class Aluno e método pagarMensalidade():
public class Aluno extends Pessoa {
private String matricula;
public Aluno(String cpf, String nome, int idade, String
matricula) {
super(cpf, nome, idade);
this.matricula = matricula;
}
public void setMatricula(String matricula) {
this.matricula = matricula;
}
public String getMatricula() {
return matricula;
}
public void pagarMensalidade() {
}
}
- De mesmo modo para a class Professor, seu respectivo atributo e o método darAula()
foi recheado com um print simples só para “flegar” o método caso invocado:
Class Professor e método darAula():
public class Professor extends Pessoa{
private String centro;
public Professor(String cpf, String nome, int idade, String
centro) {
super(cpf, nome, idade);
this.centro = centro;
}
public void setCentro(String centro) {
this.centro = centro;
}
public String getCentro() {
return centro;
}
public void darAula() {
System.out.println("Aula dada!");
}
}
- Class Visitante não possui novidades a não ser o que já falamos da superClass:
Class Visitante
public class Visitante extends Pessoa {
public Visitante(String cpf, String nome, int idade) {
super(cpf, nome, idade);
}
}
- As classes Bolsista e Regular são muito parecidas, para diferenciar na hora de chamar
o método de pagarMensalidade() decidimos colocar um print de “mensalidade paga
com desconto” para bolsistas, e “paga de forma integral” para Regulares.
Class Bolsista e método pagarMensalidade():
public class Bolsista extends Aluno {
public Bolsista(String cpf, String nome, int idade, String
matricula) {
super(cpf, nome, idade, matricula);
}
@Override
public void pagarMensalidade() {
System.out.println("Mensalidade paga com desconto.");
}
}
Class Regular e método pagarMensalidade():
public class Regular extends Aluno {
public Regular(String cpf, String nome, int idade, String
matricula) {
super(cpf, nome, idade, matricula);
}
@Override
public void pagarMensalidade() {
System.out.println("Mensalidade paga integralmente.");
}
}
QUESTÃO 4
Associação e Composição: Crie uma classe, chamada “Turma”. Adicione em turma os
atributos “código”, “disciplina”, “professor” e “alunos”, crie os métodos
“adicionarAluno”, “removerAluno” e “listarAlunos” e os implemente utilizando
ArrayList. Cada atributo será do tipo da classe de mesmo nome, exceto alunos que terá
uma lista de objetos do tipo “Aluno”.
- Na criação da classe Turma queriamos destacar especificamente que a criação do
atributo código como sendo do tipo Disciplina (“Cada atributo será do tipo da classe de
mesmo nome”) não foi bem aceitado por nós, pois:
1. Não é muito lógico o código de uma turma ter o mesmo código de uma
disciplina, logo nos separamos. Pois as disciplinas são fixas em todos os
períodos do ano, mas as turmas não. São dinâmicas e mudam a cada
ano(“T101”, “T202”, …);
2. Seria redundante criar o atributo “Disciplina codigo”, visto que no atributo em
seguida “Disciplina disciplina” nós já contemplamos todos os atributos na Class
Disciplina, podendo inclusive chamar código sem criar atributo algum, então por
causa dessa redundância e também tentando trazer as coisas para realidade
separamos o atributo código da turma do atributo do código da disciplina.
- Para criar os atributos com os tipos respectivos basta criar os atributos com os tipos
das classes necessárias;
- Para usarmos o ArrayList foi necessário importar uma biblioteca do java;
Class Turma, métodos adicionarAluno(Aluno aluno), removerAluno(Aluno aluno)
import java.util.ArrayList;
public class Turma {
private String codigo;
private Disciplina disciplina;
private Professor professor;
private ArrayList<Aluno> alunos;
public Turma(String codigo, Disciplina disciplina,
Professor professor) {
this.codigo = codigo;
this.disciplina = disciplina;
this.professor = professor;
this.alunos = new ArrayList<>();
}
public voidadicionarAluno(Aluno aluno) {
alunos.add(aluno);
}
public void removerAluno(Aluno aluno) {
alunos.remove(aluno);
}
- Sentimos a falta de um método de adicionarProfessor() a turma específica, então
fizemos esse método sem prejudicar as demais exigências da questão, apenas para
facilitar a organização do código.
Class Turma, método adicionarProfessor(Professor professor)
public void adicionarProfessor(Professor professor) {
this.professor = professor;
}
- Em listarAlunos() além de mostrar todos os alunos com auxílio de um for, assim como
pedido. Também fizemos o print das demais informações relevantes, da turma, da
disciplina, do professor. Tudo que foi pedido no arquivo main.java, afim de facilitar a
visualização no arquivo main.java;
Class Turma, método listarAlunos():
public void listarAlunos() {
System.out.println("Alunos na turma de código:" +
codigo + " (" + disciplina.getNome() + "-" +
disciplina.getCodigo() +"):");
for (Aluno aluno : alunos) {
System.out.println("Nome: " + aluno.getNome() + ",
Idade: " + aluno.getIdade());
}
System.out.println("Professor:" + professor.getNome());
System.out.println("===========================================
=====================");
}
Por fim, assim como pedido nos outputs:
public class Main {
public static void main(String[] args) {
// 3 objetos de disciplina
Disciplina d1 = new Disciplina("N685", "Programação Orientada
a Objetos", 1);
Disciplina d2 = new Disciplina("N683", "Raciocíno Lógico e
Algorítmos", 1);
Disciplina d3 = new Disciplina("N680", "Matemática para a
computação", 1);
// 3 objetos aluno (2 regulares e 1 bolsista)
Aluno r1 = new Regular("12456789", "Leticia Diogenes", 22,
"475555");
Aluno r2 = new Regular("987654321", "Jorgirerison Leite", 23,
"475556");
Aluno b1 = new Bolsista("678912345", "Raphaela Maria", 17,
"475542");
// 1 objeto professor
Professor p1 = new Professor("123456889", "André Wescley",
30, "Tecnologia da Informação");
// 2 objetos visitante
Pessoa v1 = new Visitante("8934272", "Gian Gabriel", 19);
Pessoa v2 = new Visitante("9784200", "Carla Thuany", 19);
// 3 objetos Turma
Turma t1 = new Turma("T101", d1, p1);
Turma t2 = new Turma("T102", d2, p1);
Turma t3 = new Turma("T103", d3, p1);
// imprimindo turma, código da turma, professor da turma,
disciplina e lista
t1.adicionarProfessor(p1);
t2.adicionarProfessor(p1);
t3.adicionarProfessor(p1);
t1.adicionarAluno(r1);
t1.adicionarAluno(r2);
t1.adicionarAluno(b1);
t2.adicionarAluno(r1);
t2.adicionarAluno(r2);
t2.adicionarAluno(b1);
t3.adicionarAluno(r1);
t3.adicionarAluno(r2);
t1.listarAlunos();
t2.listarAlunos();
t3.listarAlunos();
System.out.println("Visitante 1: " + v1.getNome());
System.out.println("Visitante 2: " + v2.getNome());
}
}
Executando primeiramente no terminal do VSCODE o comando:
javac Disciplina.java Main.java Pessoa.java Aluno.java Professor.java Visitante.java
Bolsista.java Regular.java Turma.java
Em seguida o comando:
java Main
Obtemos os seguintes Outputs:
Figura 2: Outputs do arquivo main.java acima
REFERÊNCIAS
- Unifor | Universidade de Fortaleza. Disponível em:
<https://ead.unifor.br/ava/course/view.php?id=67157>. Acesso em: 3 jun. 2024.
- CURSO EM VÍDEO. Curso POO Teoria #01a - O que é Programação Orientada a
Objetos. Disponível em:
<https://www.youtube.com/watch?v=KlIL63MeyMY&list=PLHz_AreHm4dkqe2aR0t
QK74m8SFe-aGsY&pp=iAQB>. Acesso em: 3 jun. 2024.