Nome: Mayko Wesley Ribeiro Facci RA: 09010261-7

Lista de Programação Orientada a Objetos.

Ex1:

//Prato.java

public class Prato{

//Copo.java

public class Copo{

private int capacidade;

//Gets and Setters

public int getCapacidade(){

return capacidade;

public void setCapacidade(int cap){

capacidade = cap;

//Faca.java

public class Faca{

private int tamanho;

//Talher.java

public class Talher{

private String tipo;

//Garfo.java

public class Garfo{

Ex 2:
A classe que melhor representa o conceito de encapsulamento é a classe Copo. Nela os atributos estão
declarados como private e ela possui métodos públicos para que outras classes acessem seus atributos,
assim seus atributos não são alterados diretamente pelas outras classes, é a própria classe Copo que faz a
alteração de acordo com seus métodos.

Ex 3:
É possível simplificar uma parte deste diagrama utilizando o conceito de herança, pois como as classes
Faca e Garfo são uma especialização da classe Talher (São talheres com características específicas). Isso
indica que esses classes herdam também as características da classe Talher.

Ex 4:
//Copo.java

public class Copo{

private int capacidade;

//Gets and Setters

public int getCapacidade(){

return capacidade;

public void setCapacidade(int cap){

capacidade = cap;

//Construtor default

public Copo(){

//Não contem nada

//Construtor alternativo

public Copo(int c){

capacidade = c;

Ex 5:
//Enciclopedia.java

import java.util.*;

public class Enciclopedia{

private int qtdVolumes;

private ArrayList<Volume> listaVolumes = new ArrayList<Volume>();

//Gets and Sets

 public int getQtdVolumes(){

return qtdVolumes;

public void setQtdVolumes(int qtd){

qtdVolumes = qtd;

//Volume.java

public class Volume{

private String nome;

private int numero;

//Carro.java

import java.util.*;

public class Carro{

private int qtdRodas;

private ArrayList<Roda> listaRodas = new ArrayList<Roda>();

//Roda.java

public class Roda{

private String tipo;

Ex 6:
Foi usado agregação no relacionamento entre carro e roda. No código não há diferença entre agregação e
composição, porém, conceitualmente não poderia usar composição pois ela é usada quando tem um
relacionamento “todo-parte” onde se a “parte” for removida o “todo” deixa de fazer sentido, ao contrário da
agregação que também é um relacionamento “todo-parte” porém se a “parte” for removida o “todo” ainda
continua fazendo sentido. No exemplo se a roda for removida do carro ele não deixa de ser carro.

Ex 7:
Foi usado composição no relacionamento entre as classes Enciclopedia e Volume. Não poderia usar
agregação pois no caso a enciclopédia não faz sentido sem ter um volume. No caso da agregação é
utilizada onde mesmo sem a parte o todo ainda continua a fazer sentido, como no exemplo não existe
enciclopédia sem volume o relacionamento utilizado é o de composição.

Ex 8:
//Carro.java

import java.util.*;

public class Carro{

private int qtdRodas;

private ArrayList<Roda> listaRodas = new ArrayList<Roda>();

public void incRodas(){

qtdRodas = qtdRodas + 1;

Ex 9:
//Carro.java

import java.util.*;

public class Carro{

private int qtdRodas;

private ArrayList<Roda> listaRodas = new ArrayList<Roda>();

public void incRodas(){

qtdRodas = qtdRodas + 1;

public void incRodas(int qtd){

qtdRodas = qtd;

Ex 10:
O princípio da orientação ao objeto que permite criar mais de um método com o mesmo nome na mesma
classe é o principio de “overload” (sobrecarga de operadores). Eles podem ter o mesmo nome porém seus
parâmetros devem ser diferentes.

Ex 11:
//Movel.java

public class Movel{

private String nome;

}
//Sofa.java

public class Sofa extends Movel{

private int qtdLugares;

//Estante.java

public class Estante extends Movel{

private int qtdPratileiras;

//ContaCorrente.java

public class ContaCorrente{

private double saldo=50;

public double getSaldo(){

return saldo;

public void setSaldo(double s){

saldo = s;

public void retirada(double valor){

saldo = saldo - valor;

//ContaSimples.java

public class ContaSimples extends ContaCorrente{

public void retirada(double valor){

if((super.getSaldo() - valor) >= 0){

super.retirada(valor);

else{

System.out.println("Não há crédito suficiente!");

}
 }

//ContaEspecial.java

public class ContaEspecial extends ContaCorrente{

private double limite;

//Gets and Sets
public double getLimite(){
return limite;
}
public void setLimite(double l){
limite = l;
}
public void retirada(double valor){

if((super.getSaldo() - valor) >= 0){

super.retirada(valor);

else{

System.out.println("Não há crédito suficiente!");

Ex 12:
//ContaEspecial.java

public class ContaEspecial extends ContaCorrente{

private double limite;

//Gets and Sets
public double getLimite(){
return limite;
}
public void setLimite(double l){
limite = l;
}
public void retirada(double valor){

if((super.getSaldo() - valor) >= limite){

super.retirada(valor);

else{

System.out.println("Valor ultrapassa o limite!");

 }

}
Ex 13:
O princípio que nos permite criar métodos com o mesmo nome e parâmetros na classe “Mãe” e na classe
“Filha” é o polimorfismo. Eles podem ter o mesmo nome, os parâmetros iguais porém seus corpos são
diferentes e devem estar em classes diferentes usando o conceito de herança.

Ex 14:
//Pessoa.java

public class Pessoa{

private String nome;

//Gets and Sets

public String getNome(){

return nome;

public void setNome(String n){

nome = n;

//Método para mostar o nome da classe Pessoa

public void mostraAtributos(){

System.out.print(getNome()+": ");

//Cliente.java

public class Cliente extends Pessoa{

private double saldo;

//Gets and Sets

public double getSaldo(){

return saldo;

public void setSaldo(double s){

saldo = s;

}
 //Metodo para mostrar os atributos

public void mostraAtributos(){

super.mostraAtributos();

System.out.println(getSaldo());

//Loja.java

import java.util.*;

public class Loja{

private ArrayList<Cliente> listaClientes = new ArrayList<Cliente>();

//Método main

public static void main(String args[]){

Loja l = new Loja();

l.movimento();

//Método movimento

public void movimento(){

Cliente c1 = new Cliente();

c1.setNome("Mayko");

c1.setSaldo(1002);

listaClientes.add(c1);

Cliente c2 = new Cliente();

c2.setNome("Matheus");

c2.setSaldo(1000);

listaClientes.add(c2);

Cliente c3 = new Cliente();

c3.setNome("Thiago");

c3.setSaldo(1500);

listaClientes.add(c3);

Cliente c4 = new Cliente();

c4.setNome("Jorge");
 c4.setSaldo(2000);

listaClientes.add(c4);

Cliente c5 = new Cliente();

c5.setNome("Magali");

c5.setSaldo(2500);

listaClientes.add(c5);

Iterator<Cliente> it = listaClientes.iterator();

Cliente c = null;

while(it.hasNext()){

c = new Cliente();

c = it.next();

c.mostraAtributos();

Ex 15:
//Cliente.java

public class Cliente extends Pessoa{

private double saldo;

//Gets and Sets

public double getSaldo(){

return saldo;

public void setSaldo(double s){

saldo = s;

//Metodo construtor default

public Cliente(){

//Nada mesmo

//Metodo construtor alternativo

 public Cliente(String n, double s){

super.setNome(n);

saldo = s;

//Metodo para mostrar os atributos

public void mostraAtributos(){

super.mostraAtributos();

System.out.println(getSaldo());