Considere as classes referentes a uma versão simplificada do problema da gestão de auditórios de um centro

de congressos.
a) A variável de instância agendaDeConferencias de Auditorio, private AgendaAnual
agendaDeConferencias é :um objecto
b) A variável de instância agenda de AgendaAnual, private Agenda[,] agenda é :uma matriz de
objectos
c) Quem tem agenda anual? Os Auditórios

d) O método de GereAuditorios que indica o número total de

conferências marcadas em dia em todos os auditórios é
public int numeroConferencias(int dia){
}

e) O método de GereAuditorios que indica o número total de horas

vagas no dia num em todos os auditórios é
public int numeroHorasVagas(int dia){

conta = 0;
for(int i=1; i< listaAuditorios.Lenght;i++)
{
for(int h=8; h<=20;h++)
{
If(listaAuditorios[i].verificaSeOcupado(dia, h, h+1)) conta++;
}
}
return conta;
}

public int numeroAuditoriosLivres(int dia){

conta = 0;
for(int i=1; i< listaAuditorios.Lenght;i++)
{
If(listaAuditorios[i].verificaSeOcupado(dia, 8, 20)) conta++;
}
return conta;
}
f) O método de Auditorio que indica o valor já cobrado pelas
conferências realizadas nesse auditório
public int valorCobrado(){
int valor = 0;
for(int d=1; i<= 365;d++)
{
for(int h=8; h<=20;h++)
{
If(this.daConferencia(d, h)!=null)
{
If(this.daConferencia(d, h).Realizada) valor = valor + custo;
}
}
}
}

public int valorCobrado(){

int valor = 0;
for(int d=1; i<= 365;d++)
{
for(int h=8; h<=20;h++)
{
Conferencia obj = this.daConferencia(d, h);
If(obj!=null)
{
If(obj.Realizada) valor = valor + custo;
//erro -- valor = valor + custo*obj.Duracao …. Caso a propriedaee estivesse definida;
 }
}
}

}
}
g) O método de AgendaAnual que indica o dia com menor numero de
horas marcadas é:
public int diaMaisLivre (){
}
3- Considere as classes referentes ao projecto Banco.
a) Em Banco, o método NovaConta permite acrescentar uma nova conta ao Banco. O seu corpo é:
Contas.Add(objConta.Numero,objConta);

b) O método DaConta de Banco retorna a conta que tem o número num. O seu corpo é: return
Contas[num];

d) Na classe Banco construa o método Saldo, que retorna o

saldo da conta num:
public int Saldo(int num)
{
Int res = 0;
if(Contas.ContainsKey(num)) res = Contas[num].Saldo;
return res
}

public int Saldo(int num)

{
if(Contas.ContainsKey(num)) return Contas[num].Saldo;
return 0;
}

public int Saldo(int num)

{
Int res = 0;
Conta obj = this.DaConta(num);
if(obj!=null) res = obj.Saldo;

return res
}
e) Na classe Banco construa o método SaldoTotal, que retorna a
soma dos saldos das contas:
public int SaldoTotal()
{
Int saldo=0;
foreach(KeyValuePair< int,Conta> par in Contas)
{
Saldo = saldo + par.Value.Saldo;
}
Return saldo;
}

public int SaldoTotal()

{
Int saldo=0;
foreach(Conta obj in Contas.Values)
{
Saldo = saldo + obj.Saldo;
}
Return saldo;
}
f) Na classe Banco construa o método ClienteMaisRico, retorna
o cliente cuja soma dos saldos das suas contas é a maior:
public Cliente ClienteMaisRico()
{
Cliiente objRes = null;
Int saldoMaior =0;
foreach(Cliente objCli in Clientes.Values)
{
Int saldoCliente = 0;
foreach(Conta objConta in objCli.Contas())
{
saldoCliente = saldoCliente + objConta.Saldo;
}
If(saldoMaior < saldoCliente)
{
saldoMaior = saldoCliente;
objRes = objCli;
}
}
Return objRes;
}
f) Na classe Banco construa o método ClienteComMaisContas,
que retorna o cliente titular num maior número de contas:
public Cliente ClienteComMaisContas()
{

private List< Conta> ContasLista = new List<Conta>();

private ArrayList ContasArrayList = new ArrayList();
private Dictionary<int,Conta> Contas =
new Dictionary<int, Conta >();
private HashTable ContasTabela = new HashTable();
foreach(Conta objConta in ContasLista)
{
objConta.Deposita(10);
}
foreach(Conta objConta in ContasArrayList)
{
objConta.Deposita(10);
}
foreach(KeyValuePair< int,Conta> par in Contas)
{
par.Value.Deposita(10);
}
Contas.Keys --- lista de chaves
foreach(Conta objConta in ContasTabela.Values)
{
objConta.Deposita(10);
}
foreach(KeyValuePair< int,Conta> par in ContasTabela)
{
par.Value.Deposita(10);
}
Contas.Keys --- lista de chaves
foreach(Conta objConta in ContasTabela.Values)
{
objConta.Deposita(10);
}

b) O método DaConta de Banco retorna a conta que tem o número num. O seu corpo é: return
Contas[num];

c) As chaves do dictionary Clientes em Banco podem apenas ser do tipo: Int

d) Em Banco, para percorrer todas as contas podemos usar: foreach(Conta obj in

Contas.Values)

e) Na classe Banco construa o método Saldo, que retorna o saldo da conta num:
public int Saldo(int num)
{
return Contas[num].Saldo;
}
f) Na classe Banco construa o método SaldoTotal, que retorna a
soma dos saldos de todas as contas:
public int SaldoTotal()
{
Int soma=0;
foreach(Conta obj in Contas.Values)
{
Soma = soma + obj.Saldo
}
Return soma;
}
g) Na classe Banco construa o método ClienteMaisRico, retorna
o cliente cuja soma dos saldos das suas contas é a maior:
public Cliente ClienteMaisRico()
{
Int maiorSaldo=0;
Cliente maisRico = null;
foreach(Cliente objCliente in Clientes.Values)
{
Int soma = 0;
foreach(Conta objConta in objCliente.Contas())
{
Soma = soma + objConta.Saldo
}
If(soma>maiorSaldo)
{
maiorSaldo = soma;
maisRico = objCliente
}
}
Return maisRico
}
h) Na classe Banco construa o método ClienteComMaisContas,
que retorna o cliente titular num maior número de contas:
public Cliente ClienteComMaisContas()
{
Int maisContas=0;
Cliente maisRico = null;
foreach(Cliente objCliente in Clientes.Values)
{
Int num = objCliente.Contas().Count;
If(num> maisContas)
{
maisContas = num;
maisRico = objCliente
}
}
Return maisRico
}

h) Na classe Banco construa o método ClientesComVariasContas, que

retorna o número de clientes que são titular de pelo menos x contas:
public int ClientesComVariasContas(int x)
{
Int resultado=0;
foreach(Cliente objCliente in Clientes.Values)
{
Int num = objCliente.Contas().Count;
If(num>= x)
{
Resultado = resultado + 1;
}
}
Return return

}
a) O método DaConta de Banco retorna a conta que tem o número num. O seu corpo é: return
Contas[num];
b) Nos métodos da classe Banco para percorrer todos os Clientes podemos usar: foreach(Cliente
obj in Clientes.Values)

c) Na classe Banco complete o método NovaConta, que permite

acrescentar uma nova conta ao Banco. Retorna true se a conta
for criada ou false se a conta não for criada porque já existe uma
com o mesmo número:
public bool NovaConta(Conta objConta)
{
bool res = false;
...
if(!Contas.containsKey(objConta.DaNum()))
{ Contas.Add(objConta.DaNum(),objConta);
res = true;
}
return res;

d) Na classe Conta complete o construtor de modo a que a conta

a conta e o cliente fiquem totalmente associados (ver variável
de instância Contas de Cliente)
public Conta(int num, Cliente objCli)
{
num = num;
saldo =;
titular = objCli;
(objCli.ListaObjContas()).Add(this); //não está correcto

}
public Conta(int num, Cliente objCli)
{
num = num;
saldo =;
titular = objCli;
objCli.Contas().Add(num,this);

}
public Conta(int num, Cliente objCli)
{
num = num;
saldo =;
titular = objCli;
objCli.NovaConta(this);

e) Na classe Banco construa o método SaldoTotal, que retorna a

soma dos saldos de todas as contas:
public int SaldoTotal()
{

int saldototal = 0;
foreach(Conta objConta in Contas.Values)
{
saldototal = saldototal+objConta.DaSaldo();
}
return saldototal;
}
f) Na classe Cliente construa o método SaldoGlobal, que retorna
a soma dos saldos de todas as contas do cliente:
public int SaldoGlobal()
{

int saldoglobal = 0;
foreach(Conta objConta in Contas.Values)
{
saldoglobal = saldoglobal +objConta.DaSaldo();
}
return saldoglobal;
}
g) Na classe Banco construa o método MelhorCliente, que
retorna o cliente com o maior SaldoGlobal:
public Cliente MelhorCliente()
{
Cliente objRes = null;
int maiorsaldoglobal = 0;
foreach(Cliente objCliente int Clientes.Values)
{
if(maiorsaldoglobal < objCliente. SaldoGlobal())
{
objRes = objCliente;
maiorsaldoglobal = objCliente. SaldoGlobal();
}
}

Com excepção da questão f da questão 5 (2 valores), todas as

restantes perguntas têm igual cotação (0,9 valores). Das respostas em
cada pergunta apenas uma delas está correcta. Respostas incorrectas
não implicam qualquer tipo de desconto.

1- Considere o seguinte programa

class Program
 {
static void Main(string[] args)
{ int num = 0;
int conta = 0;
int[] lista = { 1, 2, 3, 4, 5, 6 };
for (int i = 0; i < lista.Length - 1; i++)
{
if (lista[i]>i) num = num + lista[i];
conta++;
}
}
}
a) No final da execução do programa o valor de num é: 15

b) No final da execução do programa o valor de conta é: 5

2- Considere o seguinte programa

class Program
{ static void Main(string[] args)
{ int num = 0;
int soma = 0;
int[] sequencia = { 1, 2, 3, 4};
for (int i=0; i<sequencia.Length-1; i++)
{ for (int j = sequencia.Length - 1; j > i; j--)
{ num = num + sequencia[i] + sequencia[j];
soma = i + j;}
}
}
}
a) No final da execução do programa o valor de soma é: 5

b) No final da execução do programa o valor de num é: 30

3- Considere a classe Ponto2D e o programa seguinte:
class Ponto2D
{ private int x;
private int y;
public Ponto2D(int a, int b)
{ x = a;
y = b;
}
public int maior()
{ int m = x;
if (y > m) m = y;
return m;
}
public int getX() { return x; }
public int getY() { return y; }
public void desloca(int h)
{ x = x + h;
y = y + h;
}
public override string ToString(){ return "<P2D> " + x + " - " + y; }
}
class Program
{ static void Main(string[] args)
{ int soma = 0;
Ponto2D[] array = new Ponto2D[10];
for(int i=0; i < array.Length-1; i++)
{ array[i] = new Ponto2D(i+1,i-1);
soma = array[i].maior();
}
int res = array[5].getX();
}

a) No final da execução do programa o valor de soma é: 3

b) No final da execução do programa o valor de res é: 6

 a)No método TotalHorasLivres, que indica o total de horas livres no
mês, indique a/as instruções a colocar em <<a>>:
public int TotalHorasLivres()
{ int res = 0;
for (int col = 0; col < 31; col++)
{
for (int lin = 0; lin < 15; lin++)
{
if (horario[lin,col]==null) res++;
}
}
return res;
}

b) Construa o método DiasLivres, que indica o número de dias livres

no mês:
public int DiasLivres()
{
int res = 0;
for (int dia = 1; dia < 31; col++)
{
if (this.Livre(dia,8,15)) res++;
}
return res;
}

public int DiasLivres()

{ int diasLivres = 0;
for (int col = 0; col < 31; col++)
{
int contaOcupadosNoDia = 0;
for (int lin = 0; lin < 15; lin++)
{
if (horario[lin,col]!=null) contaOcupadosNoDia ++;
}
if (contaOcupadosNoDia==0) diasLivres++;
}
return diasLivres;
}

//atenção contaOcupadosNoDia fica com o numero total de horas

ocupadas no mês

public int DiasLivres()

{
int diasLivres = 0;
int contaOcupadosNoDia = 0;
for (int col = 0; col < 31; col++)
{
//int contaOcupadosNoDia = 0;
for (int lin = 0; lin < 15; lin++)
{
if (horario[lin,col]!=null)
contaOcupadosNoDia ++;
}
if (contaOcupadosNoDia==0) diasLivres++;
}
return diasLivres;
}
c) Construa o método Desmarca, que desmarca um evento que ocorra
em dia e hora:
public bool Desmarca(int dia,int hora)
{
bool res = false;
int col = this.DaColuna(dia);
int lin = this.DaLinha(hora);
Evento objAux = null;
objAux = horario[lin,col];
if (objAux= null) { res = true;}
else
{
int hinicio = this.DaLinha(objAux.GetHora());
for(int i= hinicio;i< hinicio + objAux.GetDuracao();i++)
{
horario[i,col] = null
}
res = true;
}
}

d) Declare a class HorárioSemestral cujos objectos implementam

horários semestrais de eventos (considere que um semestre tem 20
semanas) – declare apenas a definição das variáveis de instância e o
construtor:
class HorarioSemestral
{
private HorarioMensal[] horariosSemestre;
public HorarioSemestral ()
{ horariosSemestre = new HorarioMensal[6];} //6 meses
}
2- Um Curso guarda uma lista de Disciplinas numa Hashtable. Uma Disciplina guarda uma lista dos
Alunos inscritos.
class Disciplina class Aluno
{ private int codigo; {
private Hashtable Alunos = new Hashtable(); private int numero;
private int idade;
public Disciplina(int cod) { } ...;
public DaCodigo(int cod) { } public int
Num() { ... } public Aluno(int num)
public Aluno DaAluno(int num) { ... } { ... }
public void InscreveAluno(Aluno obj) ...
{...} public int DaNum(){ return numero; }
public bool RemoveAluno(int num) { ...} public int DaIdade(int num)
public ICollection ListaCodAlunos() { return idade; }
{ return Alunos.Keys; } }
public ICollection ListaObjAlunos()
{ return Alunos.Values; }
}
class Curso
{ private Hashtable Disciplinas = new Hashtable();
private string nome;

public Curso(string nome) { }

public void NovaDisciplina(Disciplina obj) { ... }
public Disciplina DaDisciplina(int cod) { ... }
public void RemoveDisciplina(int cod) { Disciplinas.Remove(cod); }
public ICollection ListaCodDisciplinas() { return Disciplinas.Keys; }
public ICollection ListaObjDisciplinas() { return Disciplinas.Values; }
public void InscreveAluno(Aluno obj, int codDisciplina) { ... }
public void RemoveAluno(int codAluno, int codDisciplina) { ... }
}
a) O corpo do método de Curso, NovaDisciplina permite acrescentar uma nova disciplina ao Curso.:
Disciplinas.Add(obj.Num(),obj);

b) O corpo do método de Curso, DaDisciplina que retorna a disciplina que tem o código cod é: return
(Disciplina) Disciplinas[cod];
 c) O método de Curso que retorna o código da disciplina com mais alunos é:
public int MaisAlunos(){
int maior = 0;
Disciplina objMaior = null;
foreach(Disciplina obj in Disciplinas.Values)
{
int numAlunos = obj.ListaCodAlunos().Count;
if (numAlunos > maior)
{maior = numAlunos;
objMaior = obj;
}
}
return objMaior.Num();
}
Qual das seguintes sequências de instruções corresponde a <<a>>

if (numAlunos > maior) if (numAlunos > maior)

{maior = numAlunos; {maior =
objMaior = obj;} obj.ListaCodAlunos().Count;
res = true;}
if (numAlunos > maior)
if (numAlunos > maior)
{maior =
{obj.Count = maior;}
obj.ListaCodAlunos().Count;}
res = true;
res = false;

d) O método de Curso que retorna a idade do aluno mais velho é:

public int MaiorIdade()
{

int maior = 0;
//Disciplina objMaior = null;
foreach(Disciplina objDisciplina in Disciplinas.Values)
{
foreach(Aluno objAluno in objDisciplina.ListaObjAlunos())
{
if (objAluno. DaIdade() > maior)
{maior = objAluno. DaIdade();
}
}
return maior;
}
}

3- A classe ParXY<T,V> utiliza o conceito de genéricos para construir classes ParXY

parametrizadas.
class ParXY<T,V>
{
private T x;
private V y;
public ParXY(T param1,V param2)
{ x = param1;
y = param2;
}
public void setX(T a){ x = a; }
public void setY(V a){ y = a; }
public T getX(){ return x; }
public V getY(){ return y;}
}

a) Criar um objecto ParXY com (int, Aluno). Na variável objAluno encontra-se um Aluno:
ParXY<int,Aluno> par = new ParXY<int,Aluno>(objAluno.DaNum(),objAluno);
b) Criar um objecto ParXY com (int,int) - ParXY<int,int> par = new ParXY<int,int>(1,2);

c) Criar uma colecção Dictionary (int,Turma) - a chave int é o numero da Turma e o valor é um objecto da
classe Turma
ParXY<int,int> par = new ParXY<int,int>(1,2);
d) Considere as declarações das seguintes colecções:
private Dictionary<int,Aluno> listaAlunos;
private Hashtable listaDisciplinas;
private Aluno objAluno; private Disciplina objDisciplina;
Assinale a instrução correcta:
Aluno obj = listaAlunos[objAluno.DaNum()];
4- Assinale as opções correctas:

a) Uma Windows Form definida pelo utilizador, quando surge no écran é: Um Objecto

b) Os métodos public static de uma qualquer classe, são respondidos: Pela Classe

c) As variáveis de instância de um objecto, quando declaradas privadas podem ser acedidas por: O Objecto

d) Que tipo de Windows Forms podem ter métodos static definidos pelo utilizador - Todas
e) Uma classe abstracta – Não pode ter objectos instancia