Programação em Java

Objetivos da sessão
Heranças
● Definição de Herança
● Classes Abstratas e Interfaces

Recursos necessários para a sessão

Software
● Java Development Kit: http://www.oracle.com/
● Eclipse: https://eclipse.org/.../eclipse-ide-java-ee-developers/lunasr2

Documentos
● (Este guião)
● Manual do Eclipse, Manual de Java

Bibliografia Suplementar
https://docs.oracle.com/javase/tutorial/
http://www.di.ubi.pt/~pprata/poo.htm

1 de 35
 Programação em Java

Herança

Conceito de herança
Uma classe que pode herdar operações de uma superclasse e as suas operações podem ser
herdadas por subclasses.
O mecanismo de herança permite definir uma nova classe em termos de classe existente, com
modificações e/ou extensões de comportamento.
As subclasses herdam os atributos e métodos das superclasses. Os métodos herdados
podem ser alterados. Novos atributos e métodos podem ser adicionados às subclasses.
Na Herança Simples, cada subclasse tem apenas uma superclasse. Na herança múltipla
uma subclasse pode ter mais do que uma superclasse.

No processo de Herança, o Java funciona da seguinte forma:

‒ Só há herança simples de classes.
‒ Todas as classes são subclasses de Object (explícita ou implícita);
‒ As subclasses herdam todos os atributos e métodos das superclasses

Se a subclasse declarar um método com o mesmo identificador e parâmetros (número e tipo)

que uma das superclasses, então a subclasse redefine esse método.
Se a subclasse declarar um atributo com o mesmo identificador que uma das superclasses,
então o atributo da subclasse esconde o atributo da superclasse (mas continua a existir!).

A herança é um mecanismo em que a subclasse constitui uma especialização da superclasse.

A superclasse pode ser vista como generalização das subclasses.
As subclasses herdam os atributos e métodos das superclasses. Os métodos herdados podem
ser modificados. Novos atributos e métodos podem ser adicionados às subclasses.
Na herança simples cada subclasse tem apenas uma superclasse (direta).
Na herança múltipla uma subclasse pode ter mais do que uma superclasse (direta).

2 de 35
 Programação em Java

Temos então que analisar algumas regras do Java para as heranças:

● Só há heranças simples de classes;
● A subclasse herda todos os atributos e métodos da superclasse
○ Os construtores não são métodos, logo não podem ser herdados
● Os atributos private não são visíveis na subclasse, os atributos protected e public
mantém a mesma visibilidade.
Para que todos os atributos de uma superclasse não sejam herdados, não seja m
visíveis nas subclasses teremos que os definir como private.

Vamos fazer um exemplo para perceber como funciona as heranças no Java.

ACTIVIDADE 1 - EXEMPLO!
public class Pessoa {
public int peso;
public float altura;

public void estado(){

System.out.println("A Estudar!!");
}
}

public class Aluno extends Pessoa {

}
public class Teste {

public static void main(String[] args) {

Aluno Manel = new Aluno ();

Manel.estado();
}
}
Que tal o resultado? Reparem que não escrevemos uma linha de instrução na class Aluno.
E se criarmos o mesmo método estado(), na class Aluno? O que acontece? O estado é
atualizado? Claro que sim !!

3 de 35
 Programação em Java

E nas restantes variáveis? Como podem ser alteradas?

Vamos experimentar e tirar conclusões.

Esquema de herança

Empregado

Administrativo Diretor

Presidente

A classe Empregado é considerada a classe base do Administrativo e do Diretor. Então a

classe Administrativo passa a ter todos os atributos e métodos não privados da classe
Empregado.
Por sua vez, classe Presidente tem como base a classe Diretor, que tem como base a classe
Empregado. Presidente herda todos os atributos e métodos da classe Diretor e Empregado que
não sejam privados.
Modifier Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N
Fonte: Controlling Access to Members of a Class

4 de 35
 Programação em Java

Mas como é que sabemos que estamos a criar de forma correta a Herança?
O Desenho da Herança segue a regra:

“É UM….”
Questionamos se a subclasse pode ser uma superclasse, isto é, com base no nosso exemplo,
perguntamos, “A carrinha é um veículo?” Sim é. Neste caso em particular, a nossa herança
está corretamente criada. Vejamos os seguintes exemplos de heranças.

Veículo

Carro Carrinha Camião

Carro

Carrinha

5 de 35
 Programação em Java

ACTIVIDADE 2 - EXEMPLO
1. Com base na classe EMPREGADO apresentada abaixo, vamos ver como vai
funcionar o nosso programa e se serve para criar subclasses.
Conseguimos criar Chefes?
● E se os chefes além do ordenado, receberem bónus?
● Será que serve a classe Empregado para criar Chefes?
2. Vamos fazer então as perguntas para saber qual vai ser a
superclasse e a subclasse:
● Um Chefe é sempre Empregado?
● Um Empregado é sempre um Chefe?
3. Depois de responder à pergunta. Vamos criar um método que
permita atribuir um bónus aos Chefes.
4. Crie uma classe de Empresa, criando os respectivos objetos.
Instancie cada um deles com dados ao seu critério.
5. Aplique um aumento aos empregados de 7% de produtividade.
6. Aplique um bónus aos chefes de 250€, por serem bons líderes.
7. Apresente na consola os valores de um empregado e de um chefe.
O output ficará ao seu critério.

1.e 2. Diagrama de classes

Empregado
Superclasse

Chefe Subclasse

6 de 35
 Programação em Java

1.e 2. Vamos criar a classe Empregado e definir os seguintes

atributos e métodos referentes a todos os empregados da empresa. A
Classe Empregado é uma superclasse.

public class Empregado {

//Atributos da classe
private String nome;
private double salario;
private int codEmpregado;

//Métodos construtor e getters e setters

//Método construtor que serve para criar os objectos e definir

//os valores dos meus atributos:nome, salario e código de
// empregado

public Empregado(String nome, double salario, int codEmpregado)

{
this.nome = nome;
this.salario = salario;
this.codEmpregado = codEmpregado;
}

//Métodos Getters e Setters de cada atributo

public String getNome() {
return nome;
}

public void setNome(String nome) {

this.nome = nome;
}

public double getSalario() {

return salario;
}

7 de 35
 Programação em Java

public void setSalario(double salario) {

this.salario = salario;
}

public int getCodEmpregado() {

return codEmpregado;
}

public void setCodEmpregado(int codEmpregado) {

this.codEmpregado = codEmpregado;
}

//3.Método que aumenta o ordenado ou salário a todos os

//empregados com base na Percentagem
public void aumentaOrdenado(double percAumento){

double aumento = this.salario * (percAumento/100);

this.salario = this.salario + aumento;
}
}

1.e 2. Vamos criar a classe Chefe e definir os seguintes atributos e

métodos. A Classe Chefe e uma subclasse da classe Empregado
(superclasse).A classe Chefe vai herdar todas as
características(atributos, construtores e métodos) da superclasse
Empregado.

3. Vamos criar um método que permita atribuir um bónus aos chefes.

public class Chefe extends Empregado {

//Construtor herdado da classe Empregado

public Chefe(String nome, double salario, int codEmpregado) {
super(nome, salario, codEmpregado);
}

8 de 35
 Programação em Java

//Método que atribui o bónus

public double bonusChefe(double bonus){
return super.getSalario()+bonus;
} }

public class Empresa {

public static void main(String[] args) {

//Criar um empregado
Empregado emp = new Empregado("Carlos",500,1);
//Criar um chefe
Chefe patrao = new Chefe("Jose", 5000,0);

//Antes dos aumentos

System.out.println(emp.getSalario());
System.out.println(patrao.getSalario());

//Após o aumento
emp.aumentarSalario(0.07);
patrao.aumentarSalario(0.07);
System.out.println("Após Aumento de 7%");
System.out.println(emp.getSalario());
System.out.println(patrao.getSalario());

//Atribuir os Bónus ao Chefe

System.out.println(patrao.bonusChefe(250));

9 de 35
 Programação em Java

Outra versão do programa

1.e 2. Vamos criar a classe Empregado e definir os seguintes

atributos e métodos referentes a todos os empregados da empresa. A
Classe Empregado é uma superclasse.

public class Empregado {

//Atributos da classe
private String nome;
private double salario;
private int codEmp;

//Métodos construtor e getters e setters

//método Construtor que serve para criar os objetos e definição

de valores
public Empregado(String nome, double salario, int codEmp) {
super();
this.nome = nome;
this.salario = salario;
this.codEmp = codEmp;
}

//Getters e setters
public String getNome() {
return nome;
}

public void setNome(String nome) {

this.nome = nome;
}

public double getSalario() {

return salario;
}

10 de 35
 Programação em Java

public void setSalario(double salario) {

this.salario = salario;
}

public int getCodEmp() {

return codEmp;
}

public void setCodEmp(int codEmp) {

this.codEmp = codEmp;
}

//Método que permite aumentar o salário a todos

//os empregado com base na percentagem
public void aumentarSalario(double percAumento)
{
this.salario += (this.salario* percAumento);
}

1.e 2. Vamos criar a classe Chefe e definir os seguintes atributos e

métodos. A Classe Chefe é uma subclasse da classe Empregado
(superclasse). A classe Chefe vai herdar todas as características
(atributos, construtores e métodos) da superclasse Empregado.

3. Vamos criar um método que permita atribuir um bónus aos chefes.

//A classe Chefe é uma subclasse da superclasse Empregado

public class Chefe extends Empregado {

//A subclasse Chefe vai herdar todas as características da

superclasse Empregado
//logo a classe Chefe vai herdar ou seja ter as mesmas
características do construtor da superclasse Empregado

11 de 35
 Programação em Java

//Construtor herdado da classe Empregado que serve criar os

objetos e definir valores.
public Chefe(String nome, double salario, int codEmp) {
super(nome, salario, codEmp);

//Método que atribui o bónus de 250€ ao chefes

public double bonusChefe(double bonus){

//chamar o metodo getSalario definida na
superclasse usando a palavra reservada super
return super.getSalario()+bonus;
}

//ou outra forma de fazer

public void actualizasalario(double bonus){
super.setSalario(super.getSalario()+bonus);
}

public class Empresa {

public static void main(String[] args) {

//Criar um empregado
Empregado emp = new Empregado("Carlos",500,1);
//Criar um chefe
Chefe patrao = new Chefe("Jose", 5000,0);

//Antes dos aumentos

System.out.println("O Empregado " + emp.getNome()+" com
código " + emp.getCodEmp()+ " tem salário de " + emp.getSalario());

12 de 35
 Programação em Java

System.out.println("O Chefe " + patrao.getNome() +" com

código " + emp.getCodEmp()+ " tem salário de " +patrao.getSalario());

//Após o aumento´
//Aumento do salário de 7%
emp.aumentarSalario(0.07);
patrao.aumentarSalario(0.07);

System.out.println("\nApós Aumento de 7%");

System.out.println("O Empregado " + emp.getNome() + " tem

salário de " + emp.getSalario());

System.out.println("O Chefe " + patrao.getNome() + " tem

salário de " + patrao.getSalario());

//Atribuir os Bónus ao Chefe

System.out.println("\nO Chefe " + patrao.getNome() + " tem
um bónus de 250 € por ser um Bom Líder. " + "O ordenado deste mês é
" + patrao.bonusChefe(250));

//ou outra forma de fazer

//atualiza salário
patrao.actualizasalario(250);
System.out.println("\nO Chefe " + patrao.getNome() + " tem
um bónus de 250 € por ser um Bom Líder. " + "O ordenado deste mês é
"+patrao.getSalario());}}

Output é:

13 de 35
 Programação em Java

CLASSES E MÉTODOS ABSTRATOS

Muitas vezes temos conceitos que se aplicam a todo um conjunto de classes,
determinando comportamentos que gostaríamos de herdar de uma superclasse, mas não
faria sentido instanciar objetos desta superclasse.
Definimos então esta superclasse como sendo abstrata, de modo que possa fornecer
propriedades e funções a classes derivadas, ou utilizá-la como tipo de dados para
referências, mas não seja permitido criar instâncias. Ou seja, os programadores podem
definir classes abstratas com a única função de definir comportamentos e características
genéricas para as suas subclasses. (fonte: manual java, pág.19).
Os métodos abstratos numa classe, não são implementados nela, apenas nas
suas subclasses. Normalmente são criados para se definir um meio de acesso comum a uma
ação que pode ser diferente para cada tipo de objeto. Se uma classe tem um método
abstrato, é obrigatório que ela também seja marcada como abstrata.
As classes abstratas, não podem ser instanciadas de forma direta, uma vez que não
possuem contrutor, e iremos ver essa situação, a classe não irá ter um método construtor.
O Principal objectivo de uma classe abstracta é ser estendida.
As classes concretas podem originar objectos, ou seja, são estruturas definidas
para serem instanciadas através de um construtor.

EXEMPLO 1

Estrutura Hierárquica de Classes

Carro
Superclasse

Renault Subclasse

14 de 35
 Programação em Java

Na estrutura Hierárquica apresentada na figura acima, A SUPERCLASSE “Carro”, por si só,

não apresenta nenhum tipo de Carro. Representa apenas um carro genérico e existe
somente para ser estendida dando origem a carro de facto.

1. Assim sendo vamos criar a classe “Carro” como Abstracta, utilizando a palavra reservada
abstract : public abstract class Carro

Uma classe abstracta não contem atributos, construtores com atributos, mas pode conter:
 métodos concretos (assinatura do método + corpo) e
 métodos abstractos (apenas a assinatura do método).
A existência de métodos abstractos garante que estes serão, obrigatoriamente,
implementados nas subclasses da classe abstracta.

2. Na classe ABSTRATA “Carro”, vamos definir/declarar:

 um construtor que apresenta apenas uma mensagem,
 um método concreto (assinatura do método + corpo) com o nome consumo que
calcula o nº de litros/km de combustível que um carro gasta por cada 100kms e
 um método abstracto (assinatura do método) com o nome DadosCarro.
O método DadosCarro como foi declarado como abstracto, a classe “Renault” terá
obrigatoriamente de o implementar.

Existe, contudo, uma exceção ao que anteriormente foi referido. Se a classe que estende a
classe abstracta for abstracta, não é obrigada a implementar os métodos abstractos da
classe estendeu.

15 de 35
 Programação em Java

EXEMPLO 1
package Exemplo1;

public abstract class Carro {

//O construtor, não está instanciar atributos mas sim apresentar uma
//mensagem

public Carro(){
System.out.println("Apresenta Carro");
}
//Método devolve o consumo por litros por kilometros
public double consumo(double km, double litros){
return (litros/km)*100;
}

//Método abstrato é herdado nas subclasses, e tem que ser utilizado

//nas subclasses. A existência deste método abstracto garante que este
// será obrigatoriamente implementado nas subclasses.

//Assinatura do método abstrato

public abstract void DadosCarro(int ano, String modelo);
}

package Exemplo1;

public class Renault extends Carro {

//@Override - método de substituíção/reeescrita obrigatória na

//na subclasse Renault do método definido na super classe Carro
@Override
public void DadosCarro(int ano, String modelo) {

System.out.println("Último "+modelo+" construído em "+ano);

}
}

16 de 35
 Programação em Java

3. Criar uma classe executável Stand para testar a hierarquia de classes.

Instancie um objecto com o nome clio da Renault. Apresente os dados do
carro e o valor em litros de quanto o carro gasta ao percorrer 100ks.

public class Stand {

public static void main(String[] args) {

Renault clio = new Renault();

clio.DadosCarro(2017, "Multi-sense");
System.out.println(clio.consumo(6.3,150));
}

O output é na consola:

17 de 35
 Programação em Java

Outra versão do programa:

package Exemplo1;
public abstract class Carro {
//O construtor, não está instanciar atributos mas sim apresentar uma
//mensagem

public Carro(){
System.out.println("Apresenta Carro");
}
//Método devolve o consumo por litros por kilometros
public double consumo(double km, double litros){
return (litros/km)*100;
}
//Método abstrato tem que ser utilizado nas subclasses
//Assinatura do método abstrato
public abstract void DadosCarro(int ano, String modelo);
}

package Exemplo1;

public class Renault extends Carro {

public Renault() {
double consumo = consumo(1000,50);
System.out.println(consumo);
}

@Override
public void DadosCarro(int ano, String modelo) {

System.out.println("Último "+modelo+" construído em "+ano);

}
}

18 de 35
 Programação em Java

public class Renault extends Carro {

//@Override - método de substituíção/reeescrita obrigatória

//na subclasse Renault do método definido na super classe Carro

public void DadosCarro(int ano, String modelo) {

System.out.println("O modelo é "

+modelo+" do ano "+ano);

}
}

public class Stand {

public static void main(String[] args) {

Renault clio = new Renault();

clio.DadosCarro(2017, "Multi-sense");
System.out.println(clio.consumo(6.3,150));
}

O output na consola é:

19 de 35
 Programação em Java

ACTIVIDADE 3
CLASSES ABSTRATAS
1. Considere uma superclasse abstrata FIGURA, que representa todas as figuras
geométricas, servindo de modelo para todos os objetos de figuras geométricas que
iremos criar. Esta classe irá ter como métodos abstratos, ÁREA() e PERIMETRO(), não
instanciados. Ambos retornam valores do tipo double.
a. Crie uma classe CIRCULO, que deverá ser subclasse de FIGURA. Esta classe terá
como atributo o RAIO. Crie os gets e sets do atributo. Nos métodos abstratos, retorne o
cálculo da área e o perímetro da classe.
b. Crie uma classe QUADRADO, que deverá ser subclasse de FIGURA. Esta classe terá
como atributo o LADO. Crie os gets e sets do atributo. Nos métodos abstratos, retorne o
cálculo da área e o perímetro da classe.
c. Crie um MENÚ numa classe principal do tipo main, que permita ao utilizador escolher
qual a figura geométrica da qual pretende calcular os dados. Conforme a escolha, assim
deverá surgir o pedido de introdução dos dados do atributo da figura geométrica
respetiva.
d. (desafio)Proceda à atualização necessária do seu programa, de modo a que possa
acrescentar uma nova figura geométrica, por exemplo, o Triângulo (Perímetro:
L1+L2+L3), (Área: (Base * Altura) /2).

Diagrama de classes – hierarquia de classes

Figura Classe Abstracta - Superclasse

Circulo Quadrado Subclasses

20 de 35
 Programação em Java

1. Criar uma superclasse abstrata FIGURA, que representa todas as figuras geométricas,
servindo de modelo para todos os objetos de figuras geométricas que iremos criar. Esta
classe irá ter como métodos abstratos, ÁREA() e PERIMETRO(), não instanciados ou não
mplementados. Ambos retornam valores do tipo double.

public abstract class Figura {

//Métodos abstratos da classe Figura
public abstract double area();
public abstract double perimetro();
}

a. Crie uma classe CIRCULO, que deverá ser subclasse de FIGURA. Esta classe terá como
atributo o RAIO. Crie os gets e sets do atributo. Nos métodos abstratos, retorne o cálculo da
área e o perímetro da classe.

public class Circulo extends Figura {

//Atributo encapsulado da classe Circulo

private double raio;

//NÃO É NECESSÁRIO CRIAR

//O Construtor por defeito,
Circulo(){

}
//NÃO É NECESSÁRIO CRIAR
//O Construtor de inicialização do raio
public Circulo(double raio) {
super();
this.raio = raio;
}
//Getters e Setters
public double getRaio() {
return raio;
}

21 de 35
 Programação em Java

public void setRaio(double raio) {

this.raio = raio;
}
//Calculo da Area e perimetro
public double area() {
return Math.PI*Math.pow(getRaio(), 2);
}
@Override
public double perimetro() {
return 2*Math.PI*getRaio();
}
}

b. Crie uma classe QUADRADO, que deverá ser subclasse de FIGURA. Esta classe terá
como atributo o LADO. Crie os gets e sets do atributo. Nos métodos abstratos, retorne o
cálculo da área e o perímetro da classe.

public class Quadrado extends Figura {

//Atributos
public double lado;

//Getters e Setters
public double getLado() {
return lado;
}

public void setLado(double lado) {

this.lado = lado;
}

//Métodos abstratos Area e Perímetro

//Calcula e devolve a area e perimetro da classe quadrado
@Override
public double area() {
return getLado()*getLado();
}

22 de 35
 Programação em Java

@Override
public double perimetro() {
return 4*getLado();
}
}

c. Crie um MENÚ numa classe principal do tipo main, que permita ao utilizador escolher qual
a figura geométrica da qual pretende calcular os dados. Conforme a escolha, assim deverá
surgir o pedido de introdução dos dados do atributo da figura geométrica respetiva.

public class Menu2 {

public static void main(String[] args) {

int escolha = 0;
Scanner entrada = new Scanner(System.in);
do{
System.out.println("****Menu Figuras Geométricas******");
System.out.println(" 1 - Circulo");
System.out.println(" 2 - Quadrado");
System.out.println(" 0 - Saír");
System.out.println("**********************************");
System.out.println("Escolha a Figura");

escolha = entrada.nextInt();
if(escolha ==1)
{
Circulo c = new Circulo();
System.out.println("Insira o Raio:");
c.setRaio(entrada.nextDouble());
System.out.printf("Area do Círculo:%.2f\n",c.area());
System.out.printf("Perímetro:%.2f\n\n", c.perimetro());
}
else if (escolha ==2) {
Quadrado q = new Quadrado();
System.out.println("Insira o Lado:");
q.setLado(entrada.nextDouble());

23 de 35
 Programação em Java

System.out.printf("Area do Quadrado:%.2f\n" , q.area());

System.out.printf("Perímetro:%.2f\n", q.perimetro());
}
else if(escolha ==0)
System.out.println("SAÍU DO MENU!!!!! Fim do Programa");
else
System.out.println("Opção Invalida!!!!, Escolha nova Figura\n");
}while(escolha!=0);
entrada.close();
}
}

O output é:

d. Proceda à actualização necessária do seu programa, de modo a que possa acrescentar

uma nova figura geométrica, por exemplo, o Triângulo (Perímetro: L1+L2+L3), (Área: (Base *
Altura) /2).

24 de 35
 Programação em Java

INTERFACES

Por exemplo, suponhamos que temos, numa loja, um programa que faz o inventário da
loja. Para fazer o inventário, precisa de recolher determinada informação de cada objeto,
número, tipo e preço. Deste modo, para esse programa poder recolher essa informação,
precisa ter uma interface com esse objeto. Assim, seria implementado em cada objeto da loja,
uma mesma interface que permitisse ao programa interagir com os objetos de modo a recolher
a informação necessária.
Interfaces são classes que não definem a implementação dos métodos, mas apenas as
suas assinaturas (nomes e argumentos). Interfaces não podem ter atributos e todos os seus
métodos são implicitamente abstratos e públicos.
Uma classe pode estender apenas uma única superclasse (para evitar conflitos entre os
comportamentos herdados), mas pode implementar várias interfaces (mesmo que elas definam
métodos com a mesma assinatura).
As interfaces permitem definir funcionalidades baseadas em conceitos que se aplicam a várias
classes distintas (em hierarquias de especialização diferentes):
● Uma classe estende uma outra classe
● Uma classe implementa uma ou várias interfaces
● Uma interface estende uma ou várias interfaces
● Uma classe pode, ao mesmo tempo, estender outra classe e implementar uma ou várias
interfaces
Assim, o JAVA não suporta herança múltipla, ou seja, apenas pode “estender” uma classe. No
entanto, pode implementar (implements) várias Interfaces. Uma interface serve para “obrigar”
uma classe a ter uma determinada estrutura, um determinado conjunto de métodos e/ou
variáveis.
Nesta apenas estão definidas as assinaturas dos métodos.

25 de 35
 Programação em Java

EXEMPLO 2

Diagrama de classes – hierarquia de classes

Viatura Interface - Superclasse

Toyota Opel
Subclasses

package Exemplo2;

public interface Viatura {

String modelo();

double consumo(double km, double litros);

}

package Exemplo2;

public class Toyota implements Viatura {

public String modelo() {

String modelo = "Yaris";
return modelo;
}

public double consumo(double km, double litros) {

double consumo = (litros/km)*100;
return consumo;
}
}

26 de 35
 Programação em Java

package Exemplo2;

public class Opel implements Viatura {

public String modelo() {

String modelo = "Astra";
return modelo;
}

public double consumo(double km, double litros) {

double consumo = (litros/km)*100;
return consumo;
}
}

package Exemplo2;

public class TesteExemplo2 {

public static void main(String[] args) {

Toyota t = new Toyota();

System.out.println(t.modelo()+" com um consumo de "+t.consumo(800, 60));
}}

Outra versão

public interface Viatura {

//método sem parametros - assinatura do método modelo
String modelo();
//método com 2 parametros - assinatura do método consumo
double consumo(double km, double litros);

27 de 35
 Programação em Java

//A classe Toyota é uma subclasse da interface Viatura

//A subclasse Toyota impementa a interface Viatura

public class Toyota implements Viatura {

//Implementar os métodos modelo e consumo

@Override
public String modelo() {
String modelo = "Yaris";
return modelo;
}

@Override
public double consumo(double km, double litros) {
double consumo = (litros/km)*100;
return consumo;
}
}
public class Opel implements Viatura {

@Override
public String modelo() {
String modelo = "Corsa";
return modelo;

@Override
public double consumo(double km, double litros) {
double consumo = (litros/km)*100;
return consumo;

}
public class Stand {

public static void main(String[] args) {

Toyota t = new Toyota();

System.out.println(t.modelo());
System.out.printf("Consumo:%.2f\n", t.consumo(100,5));

}
}

28 de 35
 Programação em Java

INTERFACES

1.
a. Crie uma INTERFACE CONTA, que seja padrão de todos os objetos criados. Deverá
ter dois métodos do tipo VOID, Deposita(double valor) e Levanta(double valor).
b. Crie uma classe ContaCorrente, implementada da interface CONTA, que tenha
como atributo o SALDO. Crie os gets e sets do atributo e implemente os métodos
Deposita e Levanta, que permite aumentar e diminuir o saldo da Conta Corrente.
c. Crie uma classe ContaPoupanca, implementada da interface CONTA, que tenha
como atributo o SALDO. Crie os gets e sets do atributo e implemente os métodos
Deposita e Levanta, que permite aumentar e diminuir o saldo da Conta Poupança.
d. Crie uma classe principal BANCO, que permita gerir as diferentes contas. Crie um
MENÚ,

Escolha a conta a Gerir

1 – Conta Corrente
2 – Conta Poupança

que permita ao utilizador, selecionar que tipo de Conta Pretende Gerir. Em ambas as
escolhas, o utilizador deverá definir um SALDO INICIAL (setSaldo). Em seguida,
deverá surgir um menu personalizado para cada conta, sendo que as opções
deverão ser:

Selecione a sua opção

1 – Deposita Dinheiro
2 – Levanta Dinheiro
3 – Verifica Saldo
4 – Sair

29 de 35
 Programação em Java

Diagrama de classes – hierarquia de classes

Conta Interface - Superclasse

Conta Corrente Conta Poupança

Subclasses

public interface CONTA {

//ASSINATURAS DE 2 MÉTODOS
//método com 1 parametro - assinatura do método Deposita
void Deposita(double valor);

//método com 1 parametro - assinatura do método Levanta

void Levanta(double valor);

void mostramenu();

public class ContaCorrente implements CONTA {

//Atributo da subclasse ContaCorrente que implementa a interface

Conta
private double saldocontaC;

//Getters e Setters do atributo saldo da conta Corrente

public double getSaldocontaC() {
return saldocontaC;
}

public void setSaldocontaC(double saldocontaC) {

this.saldocontaC = saldocontaC;
}

30 de 35
 Programação em Java

//Médodo reescrito
@Override
public void Deposita(double valor) {
this.saldocontaC = this.saldocontaC+= valor;
System.out.println("Depositou: " + valor);
System.out.println("Saldo Atual: " + getSaldocontaC()+
"\n");
}
@Override
public void Levanta(double valor){
System.out.println("Saldo Atual: " + getSaldocontaC());
if (this.saldocontaC>=valor){
this.saldocontaC -= valor;
System.out.println("Levantou: " + valor);
System.out.println("Novo Saldo: " +
getSaldocontaC() + "\n");
}
else

{
System.out.println("O Saldo da Conta Corrente <
VALOR DE levantamento\n");

}
}

public void mostramenu(){

System.out.println("Escolha a conta a Gerir");
System.out.println("1 - Conta Corrente");
System.out.println("2 - Conta Poupança");
System.out.println("0 - Saír");
System.out.println("************************");
}

public void mostrasubmenu(){

System.out.println("Selecione a sua opção");
System.out.println("1 – Deposita Dinheiro");
System.out.println("2 – Levanta Dinheiro");
System.out.println("3 – Verifica Saldo");
System.out.println("4 - Sair");
}

public void verficasaldo(){

System.out.println("Saldo Atual: " + getSaldocontaC()+ "\n");

31 de 35
 Programação em Java

public class ContaPoupança implements CONTA {

//Atributo da subclasse ContaPoupança que implementa a interface
Conta
private double saldocontaP;

//Getters e Setters do atributo saldo da conta Corrente

public double getSaldocontaP() {
return saldocontaP;
}

public void setSaldocontaP(double saldocontaP) {

this.saldocontaP = saldocontaP;
}

//Métodos implementados
@Override
public void Deposita(double valor) {
saldocontaP += valor;
System.out.println("Depositou: " + valor);
System.out.println("Novo saldo: " + saldocontaP + "\n");
}

@Override
public void Levanta(double valor) {
if ((valor >=300)&&(this.saldocontaP>=valor))
{
this.saldocontaP -= valor;
System.out.println("Levantou: " + valor);
System.out.println("Novo Saldo: " + getSaldocontaP() +
"\n");
}
else

System.out.println("Não é permitida levantamento desse

valor");

public void mostramenu(){

System.out.println("Escolha a conta a Gerir");
System.out.println("1 - Conta Corrente");
System.out.println("2 - Conta Poupança");
System.out.println("0 - Saír");
System.out.println("************************");

32 de 35
 Programação em Java

}
public void mostrasubmenu(){
System.out.println("Selecione a sua opção");
System.out.println("1 – Deposita Dinheiro");
System.out.println("2 – Levanta Dinheiro");
System.out.println("3 – Verifica Saldo");
System.out.println("4 - Sair\n");
}

public void verficasaldoP(){

System.out.println("Saldo Atual: " + getSaldocontaP()+ "\n");

import java.util.Scanner;

public class Banco {

public static void main(String[] args) {

//Declaração e inicialização de variáveis
int escolha = 0, escolha1=0;
double saldoinicial=0.0f, saldoinicial1=0.0f, valor1=0.0f,
valor2=0.0f;

//Declaração e criação de objetos

Scanner dados = new Scanner(System.in);
ContaCorrente cc = new ContaCorrente();
ContaPoupança cp = new ContaPoupança();

do{

cc.mostramenu();
escolha = dados.nextInt();

switch(escolha){
case 1:
{
System.out.println("Menu Conta Corrente");
System.out.println("Insira o saldo inicial CONTA
CORRENTE");
saldoinicial = dados.nextInt();
cc.setSaldocontaC(saldoinicial);
do{
cc.mostrasubmenu();
escolha1 = dados.nextInt();

33 de 35
 Programação em Java

if(escolha1==1)
{

System.out.println("Quanto deseja depositar?");

valor1 = dados.nextDouble();
System.out.println("Saldo inicial = " +
cc.getSaldocontaC());
cc.Deposita(valor1);
}
else if (escolha1==2)
{
System.out.println("Quanto deseja levantar?");
valor1 = dados.nextDouble();
cc.Levanta(valor1);
}
else if (escolha1==3)
{
cc.verficasaldo();
}
else
System.out.println("Saíu do menu\n");
}while (escolha1 !=4);

}
break;

case 2:
{
System.out.println("Menu Conta Poupança");
System.out.println("Insira o saldo inicial CONTA
Poupança");
saldoinicial1 = dados.nextInt();
cp.setSaldocontaP(saldoinicial1);
do{
cp.mostrasubmenu();
escolha1 = dados.nextInt();
if(escolha1==1)
{
System.out.println("Quanto deseja depositar?");
valor2 = dados.nextDouble();
System.out.println("Saldo inicial = " +
cp.getSaldocontaP());
cp.Deposita(valor2);

}
else if (escolha1==2)
{
System.out.println("Quanto deseja levantar?");

34 de 35
 Programação em Java

valor2 = dados.nextDouble();
cp.Levanta(valor2);
}
else if (escolha1==3)
{
cp.verficasaldoP();
}
else
System.out.println("Saíu do menu");

}while (escolha1 !=4);

break;

//default: System.out.println("Opção inválida");

}
}
while(escolha!=0);
System.out.println("Fim do programa!!!!! ");
dados.close();
}

35 de 35