Fundamentos de Desenvolvimento com C#

Guia didatico com exercicios sobre modelagem de classes, estado, metodos e validacao em console.

Por Fábio Linhares • Instituto Infnet

Apresentacao do TP3

TP3 — Fundamentos de Desenvolvimento com C#

Arquivo de respostas didáticas

Este material foi refeito para cumprir um papel que a role, sozinha, não cumpre: ensinar efetivamente o aluno a entender as perguntas, construir as respostas esperadas e explicar por que elas fazem sentido.

A lógica do TP3 é simples, mas precisa ser dominada com método:

Sequencia Operacional Base

entender regra -> modelar classe -> implementar metodos -> testar no Main -> validar evidencia

Em cada exercicio, mantenha o ciclo de modelagem, execucao e justificativa tecnica da saida.

▼

BASE

TP3 — Fundamentos de Desenvolvimento com C#

Fundação conceitual mínima para ler o enunciado, modelar classes e sustentar a explicação no Main.

Fundação técnica mínima antes dos exercícios

Classe é o molde que descreve como um tipo de objeto será organizado. No TP3, exemplos como Livro, Ingresso, Matricula, Circulo e Esfera são classes.

Objeto é a instância concreta criada a partir desse molde. Quando o código executa new Ingresso() ou new Circulo(), ele sai da definição abstrata e passa a trabalhar com um elemento real em memória.

Atributo guarda estado. Em Ingresso, por exemplo, nomeDoShow identifica o evento, preco informa o valor de venda e quantidadeDisponivel representa o estoque de ingressos.

Método é a ação associada ao objeto. Um método pode alterar o estado, como AlterarPreco(), ou apenas consultar e exibir o que já está armazenado, como ExibirInformacoes().

Main é o ponto de entrada do programa. É nele que o aluno prova que entendeu o exercício: cria objetos, atribui valores, chama métodos e mostra a evidência no console.

Neste TP, o uso de public nos exemplos introdutórios tem função didática: permitir que o Main enxergue os membros da classe sem adicionar camadas que ainda não são o foco principal da avaliação.

Também é essencial separar imprimir de retornar. Console.WriteLine() apenas mostra algo na tela; return devolve um valor para quem chamou o método. Essa diferença aparece com mais força em CalcularArea() e CalcularVolume().

Como estudar este TP

Leia cada enunciado procurando três coisas: qual classe precisa existir, quais dados ela deve guardar e que comportamento precisa ser provado.

Antes de codificar, diga em voz alta o fluxo: quais atributos entram, qual método age sobre eles e o que deve aparecer no console depois.

Sequência mental

1. Entender a regra do enunciado. 2. Modelar a classe. 3. Escolher tipos coerentes. 4. Implementar método ou construtor. 5. Testar no Main. 6. Explicar por que a saída prova que o código funciona.

Critério de qualidade

Resposta boa é a que organiza conceito, código e evidência. Não basta parecer certa; ela precisa compilar, produzir resultado plausível e ser explicada sem lacunas.

▼

EX.01

Classe, objeto, campos e métodos

Explicar os quatro conceitos e apontá-los dentro de um exemplo completo, com instanciação no próprio código exibido.

using System;

class Livro
{
    public string titulo;
    public int numeroPaginas;

    public void ExibirResumo()
    {
        Console.WriteLine("Título: " + titulo);
        Console.WriteLine("Páginas: " + numeroPaginas);
    }
}

class Program
{
    static void Main()
    {
        Livro meuLivro = new Livro();
        meuLivro.titulo = "Clean Code";
        meuLivro.numeroPaginas = 464;
        meuLivro.ExibirResumo();
    }
}

O que a questao pede

A questão quer que o aluno explique os conceitos de classe, objeto, atributos e métodos e mostre isso com um exemplo simples em C#.

Conceito cobrado

Não basta decorar definição. É preciso ligar cada conceito a um trecho real do código.

Estrutura dos dados

titulo, numeroPaginas e meuLivro.

Como pensar

Escolha uma entidade concreta do dia a dia, separe o que é dado daquilo que é ação e, só depois disso, escreva o Main para provar que o objeto realmente existe e usa esses dados.

Como validar

Se o código declara Livro, instancia meuLivro, preenche os campos e exibe os dados com ExibirResumo(), então ele cobriu os quatro conceitos pedidos pelo enunciado no mesmo exemplo.

Tabela de Evidencia

Passo	Trecho do código	Saída esperada	O que isso prova
Declarar a classe	`class Livro`	O código compila com uma estrutura de objeto definida.	Existe um molde para criar livros.
Instanciar o objeto	`Livro meuLivro = new Livro();`	Há um objeto concreto disponível no `Main`.	Classe e objeto não são a mesma coisa.
Usar os campos e o método	`meuLivro.titulo = "Clean Code";` `meuLivro.ExibirResumo();`	`Título: Clean Code` `Páginas: 464`	Os atributos guardam estado e o método usa esse estado.

Variaveis-chave

titulo guarda o nome do livro, numeroPaginas representa uma característica numérica e meuLivro é a referência para o objeto criado no Main.

Como explicar

Livro é a classe, porque define o molde. meuLivro é o objeto, porque foi criado a partir da classe. titulo e numeroPaginas são os atributos, porque armazenam dados do objeto. ExibirResumo() é o método, porque executa uma ação usando esses dados.

Problema & Solucao

Problema: o enunciado não quer só definições soltas; ele quer ver teoria ligada ao código. Solução: usar um exemplo único em que a classe, o objeto, os atributos e o método apareçam juntos e possam ser apontados sem ambiguidade.

Erro comum: Dizer que classe e objeto são a mesma coisa. Criar a classe, mas não instanciar objeto algum. Criar um método que não usa nenhum atributo.

▼

EX.02

Criando a classe Ingresso

Modelar o ingresso com atributos mínimos e justificar por que cada dado é indispensável no contexto de venda.

class Ingresso
{
    public string nomeDoShow;
    public double preco;
    public int quantidadeDisponivel;
}

O que a questao pede

Criar uma classe Ingresso com os atributos nomeDoShow, preco e quantidadeDisponivel, explicando por que cada um deles é importante.

Conceito cobrado

Traduzir a história de usuário em uma estrutura de dados coerente, sem inventar complexidade antes da hora.

Estrutura dos dados

nomeDoShow, preco e quantidadeDisponivel.

Como pensar

Leia o contexto de venda e pergunte: qual dado identifica o produto, qual dado informa o valor da venda e qual dado controla o estoque? Essas três respostas viram exatamente os três atributos da classe.

Como validar

Se a classe declara nomeDoShow como string, preco como double e quantidadeDisponivel como int, ela já representa o mínimo necessário para um sistema de venda de ingressos sem confundir identificação, dinheiro e quantidade.

Tabela de Evidencia

Atributo	Tipo	Exemplo	Por que é importante
`nomeDoShow`	`string`	`"Festival de Verao"`	Identifica qual evento aquele ingresso representa.
`preco`	`double`	`150.0`	Define o valor cobrado na venda e permite futuras alterações de preço.
`quantidadeDisponivel`	`int`	`300`	Controla o estoque para não vender mais ingressos do que existe.

Variaveis-chave

nomeDoShow responde "que show é esse?", preco responde "quanto custa?" e quantidadeDisponivel responde "quantos ainda posso vender?".

Como explicar

A explicação correta aqui não é sobre comportamento ainda; é sobre representação. nomeDoShow é importante porque sem ele o sistema não sabe o que está vendendo. preco é importante porque toda venda depende de um valor monetário. quantidadeDisponivel é importante porque o sistema precisa saber se ainda existe ingresso para comercializar.

Problema & Solucao

Problema: representar um ingresso de show sem perder os dados básicos de identificação, valor e estoque. Solução: criar a classe Ingresso com três atributos de tipos coerentes e justificar o papel de cada um no negócio.

Erro comum: Usar int para preco. Esquecer de explicar por que cada atributo existe. Colocar métodos demais nesta questão, que ainda não pede isso.

▼

EX.03

Métodos básicos da classe Ingresso

Criar comportamento mínimo para atualizar preço, atualizar quantidade e exibir o estado atual do ingresso.

class Ingresso
{
    public string nomeDoShow;
    public double preco;
    public int quantidadeDisponivel;

    public void AlterarPreco(double novoPreco)
    {
        preco = novoPreco;
    }

    public void AlterarQuantidade(int novaQuantidade)
    {
        quantidadeDisponivel = novaQuantidade;
    }

    public void ExibirInformacoes()
    {
        Console.WriteLine("Show: " + nomeDoShow);
        Console.WriteLine("Preço: " + preco);
        Console.WriteLine("Quantidade disponível: " + quantidadeDisponivel);
    }
}

O que a questao pede

Adicionar à classe Ingresso os métodos AlterarPreco, AlterarQuantidade e ExibirInformacoes().

Conceito cobrado

Método é comportamento do objeto. Aqui, dois métodos mudam estado e um método transforma o estado atual em evidência legível.

Estrutura dos dados

nomeDoShow, preco, quantidadeDisponivel, novoPreco e novaQuantidade.

Como pensar

Cada método precisa cumprir um papel bem definido: dois mudam o estado do objeto e um consulta esse estado para mostrar o resultado. Se um método não altera nada ou não mostra nada útil, ele não está cumprindo a função pedida.

Como validar

AlterarPreco(200.0) deve mudar somente preco; AlterarQuantidade(50) deve mudar somente quantidadeDisponivel; ExibirInformacoes() deve revelar o estado atualizado sem exigir que o leitor adivinhe os valores.

Tabela de Evidencia

Método	Entrada	Saída ou estado esperado	Leitura didática
`AlterarPreco`	`200.0`	`preco = 200.0`	O objeto passa a carregar o novo valor de venda.
`AlterarQuantidade`	`50`	`quantidadeDisponivel = 50`	O estoque é atualizado sem mexer no nome do show.
`ExibirInformacoes`	Nenhuma	Console mostra show, preço e quantidade.	O método converte o estado interno em evidência visível.

Variaveis-chave

novoPreco e novaQuantidade são parâmetros de entrada; preco e quantidadeDisponivel são os campos que realmente mudam dentro do objeto.

Como explicar

AlterarPreco recebe um valor e atualiza o atributo preco. AlterarQuantidade recebe um valor e atualiza quantidadeDisponivel. ExibirInformacoes mostra no console o estado atual do objeto.

Problema & Solucao

Problema: depois de modelar os dados, o sistema ainda precisava de comportamento para atualizar e consultar o ingresso. Solução: criar métodos curtos e objetivos, cada um com uma responsabilidade clara sobre o estado do objeto.

Erro comum: Criar o método, mas esquecer de alterar o atributo. Fazer ExibirInformacoes() sem mostrar todos os campos pedidos. Colocar nomes incoerentes ou diferentes do enunciado.

▼

EX.04

Testando a classe Ingresso

Montar um Main que crie o objeto, defina o estado inicial, aplique mudanças e comprove o resultado no console.

using System;

class Ingresso
{
    public string nomeDoShow;
    public double preco;
    public int quantidadeDisponivel;

    public void AlterarPreco(double novoPreco)
    {
        preco = novoPreco;
    }

    public void AlterarQuantidade(int novaQuantidade)
    {
        quantidadeDisponivel = novaQuantidade;
    }

    public void ExibirInformacoes()
    {
        Console.WriteLine("Show: " + nomeDoShow);
        Console.WriteLine("Preço: " + preco);
        Console.WriteLine("Quantidade disponível: " + quantidadeDisponivel);
    }
}

class Program
{
    static void Main()
    {
        Ingresso ingresso = new Ingresso();

        ingresso.nomeDoShow = "Festival de Verao";
        ingresso.preco = 120.0;
        ingresso.quantidadeDisponivel = 300;

        ingresso.AlterarPreco(150.0);
        ingresso.AlterarQuantidade(250);

        ingresso.ExibirInformacoes();
    }
}

O que a questao pede

Criar uma classe de teste com Main, instanciar um objeto Ingresso, dar valores iniciais, chamar os métodos e exibir as informações para provar que tudo funcionou.

Conceito cobrado

Não basta declarar a classe. É preciso provar comportamento com uma execução completa.

Estrutura dos dados

ingresso, nomeDoShow, preco e quantidadeDisponivel.

Como pensar

Monte o teste como uma história curta: o ingresso nasce com um estado inicial, passa por duas alterações e termina exibindo o novo estado. Se essa narrativa aparece no Main, o leitor entende a sequência inteira.

Como validar

O ponto principal aqui é a evidência de mudança. Antes dos métodos, o ingresso vale 120.0 e tem 300 unidades; depois de chamar os dois métodos, ele precisa mostrar 150.0 e 250. Se a saída não refletir isso, o teste falhou.

Tabela de Evidencia

Momento	Estado do objeto	Trecho relevante	O que comprova
Instanciação	Show = Festival de Verao, preço = 120.0, quantidade = 300	`Ingresso ingresso = new Ingresso();` + atribuições iniciais	O `Main` consegue criar e preparar o objeto.
Atualização	preço = 150.0, quantidade = 250	`ingresso.AlterarPreco(150.0);` `ingresso.AlterarQuantidade(250);`	Os métodos alteram o estado interno.
Conferência	Console exibe os valores atualizados	`ingresso.ExibirInformacoes();`	Há prova visível de que a alteração foi aplicada.

Variaveis-chave

ingresso é o objeto sob teste; os campos guardam o estado inicial e final que o console deve confirmar.

Como explicar

Primeiro o Main cria um objeto vazio do tipo Ingresso. Em seguida, ele define o estado inicial. Depois chama os métodos de alteração para trocar preço e quantidade. Por fim, chama ExibirInformacoes() para mostrar que o estado final não é mais o mesmo do início.

Problema & Solucao

Problema: código sem teste em Main não prova nada sobre funcionamento real. Solução: construir uma classe de teste que crie o objeto, altere o estado e mostre no console a mudança esperada.

Erro comum: Esquecer de criar Main. Esquecer de instanciar com new. Alterar preço e quantidade, mas nunca chamar ExibirInformacoes().

▼

EX.05

Getters e setters

Separar leitura e escrita dos atributos e mostrar, no Main, por que essa disciplina ajuda mesmo antes do encapsulamento total.

using System;

class Ingresso
{
    string nomeDoShow;
    double preco;
    int quantidadeDisponivel;

    public string GetNomeDoShow()
    {
        return nomeDoShow;
    }

    public double GetPreco()
    {
        return preco;
    }

    public int GetQuantidadeDisponivel()
    {
        return quantidadeDisponivel;
    }

    public void SetNomeDoShow(string novoNome)
    {
        nomeDoShow = novoNome;
    }

    public void SetPreco(double novoPreco)
    {
        preco = novoPreco;
    }

    public void SetQuantidadeDisponivel(int novaQtd)
    {
        quantidadeDisponivel = novaQtd;
    }
}

class Program
{
    static void Main()
    {
        Ingresso ingresso = new Ingresso();
        ingresso.SetNomeDoShow("Rock Night");
        ingresso.SetPreco(200.0);
        ingresso.SetQuantidadeDisponivel(100);

        Console.WriteLine(ingresso.GetNomeDoShow());
        Console.WriteLine(ingresso.GetPreco());
        Console.WriteLine(ingresso.GetQuantidadeDisponivel());
    }
}

O que a questao pede

Criar métodos para ler e alterar os atributos sem acessar diretamente as variáveis e demonstrar o uso desses métodos no Main.

Conceito cobrado

Getters e setters são métodos de leitura e escrita. O ponto pedagógico aqui é treinar controle de acesso, mesmo antes de estudar encapsulamento em profundidade.

Estrutura dos dados

nomeDoShow, preco, quantidadeDisponivel, novoNome, novoPreco e novaQtd.

Como pensar

O objetivo é treinar a diferença entre ler e alterar. Cada getter deve devolver um valor já armazenado; cada setter deve receber um novo valor e gravar esse valor no atributo correspondente.

Como validar

O teste mais direto é o ciclo "set depois get": se SetPreco(200.0) for chamado e logo depois GetPreco() devolver 200.0, então escrita e leitura estão coerentes.

Tabela de Evidencia

Ação	Chamada	Resultado esperado	Leitura pedagógica
Atualizar nome	`SetNomeDoShow("Rock Night")`	`GetNomeDoShow()` devolve `Rock Night`	O setter escreve e o getter confirma a escrita.
Atualizar preço	`SetPreco(200.0)`	`GetPreco()` devolve `200.0`	O atributo mudou sem acesso direto ao campo.
Atualizar quantidade	`SetQuantidadeDisponivel(100)`	`GetQuantidadeDisponivel()` devolve `100`	Leitura e escrita ficaram separadas em métodos diferentes.

Variaveis-chave

novoNome, novoPreco e novaQtd entram nos setters; os getters devolvem o estado que ficou salvo depois dessas atualizações.

Como explicar

Mesmo sem entrar em encapsulamento total, getters e setters já trazem uma vantagem didática importante: o código deixa explícito quando está lendo e quando está alterando um dado. Isso reduz confusão no Main e prepara a classe para validações futuras, como impedir preço negativo ou quantidade inválida.

Problema & Solucao

Problema: acessar campos diretamente mistura leitura e escrita sem nenhuma disciplina. Solução: criar um conjunto simples de getters e setters para treinar controle de acesso, mesmo antes de estudar encapsulamento de forma completa.

Erro comum: Escrever getter sem return. Escrever setter recebendo parâmetro, mas não atualizar o atributo. Confundir setter com método de exibição.

▼

EX.06

Construtor na classe Ingresso

Inicializar o objeto já na criação e justificar por que isso é melhor do que depender de vários setters separados.

using System;

class Ingresso
{
    public string nomeDoShow;
    public double preco;
    public int quantidadeDisponivel;

    public Ingresso(string nomeDoShow, double preco, int quantidadeDisponivel)
    {
        this.nomeDoShow = nomeDoShow;
        this.preco = preco;
        this.quantidadeDisponivel = quantidadeDisponivel;
    }

    public void ExibirInformacoes()
    {
        Console.WriteLine("Show: " + nomeDoShow);
        Console.WriteLine("Preço: " + preco);
        Console.WriteLine("Quantidade disponível: " + quantidadeDisponivel);
    }
}

class Program
{
    static void Main()
    {
        Ingresso ingresso = new Ingresso("Rock in Rio", 350.0, 500);
        ingresso.ExibirInformacoes();
    }
}

O que a questao pede

Criar um construtor que receba nomeDoShow, preco e quantidadeDisponivel, usá-lo no Main e explicar por que ele facilita a criação de objetos.

Conceito cobrado

Construtor é um método especial usado no momento da criação do objeto. Ele serve para fazer o objeto nascer pronto, e não incompleto.

Estrutura dos dados

nomeDoShow, preco, quantidadeDisponivel e os parâmetros do construtor com os mesmos significados.

Como pensar

Se três dados são obrigatórios para que o ingresso faça sentido desde o nascimento do objeto, então eles devem entrar juntos no construtor. Assim o objeto já nasce completo, em vez de depender de vários passos separados no Main.

Como validar

new Ingresso("Rock in Rio", 350.0, 500) precisa gerar um objeto pronto. Quando ExibirInformacoes() for chamado logo em seguida, os três valores devem aparecer sem necessidade de nenhum Set... intermediário.

Tabela de Evidencia

Ação	Trecho	Resultado esperado	Vantagem didática
Instanciar com construtor	`new Ingresso("Rock in Rio", 350.0, 500)`	Objeto já contém nome, preço e quantidade.	Evita esquecer uma das informações obrigatórias.
Conferir no console	`ingresso.ExibirInformacoes();`	Saída mostra os três valores recebidos no construtor.	Prova que a atribuição ocorreu no momento da criação.
Comparar com vários setters	`new Ingresso(...)` versus três chamadas `Set...`	Menos linhas e menos risco de ordem incompleta.	O construtor centraliza a inicialização obrigatória.

Variaveis-chave

Os parâmetros do construtor representam os valores de entrada; os atributos com this representam o estado final que ficará guardado dentro do objeto.

Como explicar

O construtor facilita porque junta a inicialização obrigatória em um único ponto. Em vez de criar um objeto vazio e depois lembrar de chamar três setters separados, o programador informa tudo no ato da criação. Isso reduz esquecimentos, deixa o Main menor e torna mais claro que um Ingresso só está pronto quando nome, preço e quantidade já foram definidos.

Problema & Solucao

Problema: criar um objeto em vários passos separados aumenta o risco de esquecer dados essenciais. Solução: usar um construtor com parâmetros obrigatórios para que o objeto nasça consistente e imediatamente utilizável.

Erro comum: Dar ao construtor um nome diferente da classe. Receber os parâmetros, mas não atribuí-los aos campos. Esquecer de mostrar o uso no Main.

▼

EX.07

Modelando a classe Matricula

Representar uma matrícula com os dados mínimos que identificam aluno, curso, número, situação e data de início.

class Matricula
{
    public string NomeDoAluno;
    public string Curso;
    public int NumeroMatricula;
    public string Situacao;
    public string DataInicial;
}

O que a questao pede

Criar a classe Matricula com NomeDoAluno, Curso, NumeroMatricula, Situacao e DataInicial.

Conceito cobrado

O aluno precisa mostrar que sabe modelar um novo domínio sem copiar cegamente a classe Ingresso. Mudou o cenário, então mudaram os dados relevantes.

Estrutura dos dados

NomeDoAluno, Curso, NumeroMatricula, Situacao e DataInicial.

Como pensar

Pergunte o que o sistema precisa saber para reconhecer uma matrícula sem executar nenhuma ação ainda. O nome identifica o aluno, o curso informa o vínculo acadêmico, o número distingue uma matrícula da outra, a situação mostra o estado atual e a data registra quando a relação começou.

Como validar

Se a classe reúne esses cinco atributos com tipos coerentes, ela já consegue representar uma matrícula real de faculdade sem depender de métodos avançados ou herança.

Tabela de Evidencia

Atributo	Exemplo	Papel no domínio	Por que não pode faltar
`NomeDoAluno`	`"Ana Souza"`	Identifica a pessoa matriculada.	Sem ele, não se sabe quem está vinculado ao curso.
`Curso`	`"ADS"`	Informa o programa acadêmico.	Sem ele, a matrícula perde contexto.
`NumeroMatricula`	`12345`	Diferencia uma matrícula de outra.	Evita ambiguidade entre alunos ou registros.
`Situacao`	`"Ativa"`	Mostra o estado atual.	Permite saber se a matrícula está válida, trancada ou concluída.
`DataInicial`	`"01/03/2026"`	Registra quando a matrícula começou.	Ajuda a contextualizar o histórico do vínculo.

Variaveis-chave

A dupla NumeroMatricula e Situacao costuma ser a mais cobrada em explicação, porque ela diferencia identidade de estado atual do registro.

Como explicar

Explique que a classe Matricula não descreve a pessoa em si, mas o vínculo acadêmico dela com a faculdade. Por isso, além de nome e curso, ela precisa de um identificador próprio, de uma situação administrativa e de uma data de início.

Problema & Solucao

Problema: representar um vínculo acadêmico com dados suficientes para identificação e acompanhamento. Solução: modelar uma classe específica para matrícula, com atributos de identificação, contexto e estado.

Erro comum: Esquecer NumeroMatricula. Usar nomes incoerentes. Tentar introduzir conceitos não pedidos.

▼

EX.08

Métodos na classe Matricula

Adicionar comportamento que altere a situação da matrícula e exiba as informações essenciais do registro.

using System;

class Matricula
{
    public string NomeDoAluno;
    public string Curso;
    public int NumeroMatricula;
    public string Situacao;
    public string DataInicial;

    public void Trancar()
    {
        Situacao = "Trancada";
    }

    public void Reativar()
    {
        Situacao = "Ativa";
    }

    public void ExibirInformacoes()
    {
        Console.WriteLine("Aluno: " + NomeDoAluno);
        Console.WriteLine("Curso: " + Curso);
        Console.WriteLine("Número: " + NumeroMatricula);
        Console.WriteLine("Situação: " + Situacao);
        Console.WriteLine("Data inicial: " + DataInicial);
    }
}

O que a questao pede

Criar os métodos Trancar(), Reativar() e ExibirInformacoes() para manipular e mostrar o estado da matrícula.

Conceito cobrado

Os métodos não existem para repetir texto; eles existem para alterar o atributo Situacao de forma controlada e depois revelar o estado do objeto.

Estrutura dos dados

Situacao é o centro do exercício, mas NomeDoAluno, Curso e DataInicial precisam aparecer na exibição para contextualizar a matrícula.

Como pensar

Comece pelo que muda. O enunciado quer duas transições simples de estado: ativa para trancada e trancada para ativa. Depois disso, crie um método de exibição que permita ver o estado atual junto com os demais dados do registro.

Como validar

Trancar() só está correto se realmente gravar "Trancada" em Situacao. Reativar() só está correto se sobrescrever esse mesmo campo com "Ativa". ExibirInformacoes() fecha o ciclo ao tornar a mudança observável.

Tabela de Evidencia

Método	Ação esperada	Estado depois da chamada	O que comprova
`Trancar()`	Alterar o vínculo para trancado	`Situacao = "Trancada"`	O método realmente muda o estado, em vez de só imprimir.
`Reativar()`	Retomar a matrícula	`Situacao = "Ativa"`	O estado pode ser revertido de forma controlada.
`ExibirInformacoes()`	Mostrar os dados principais	Console exibe aluno, curso, número, situação e data.	O leitor consegue verificar o estado atual da matrícula.

Variaveis-chave

Situacao é a variável-chave do comportamento; as demais aparecem para provar que a matrícula continua sendo o mesmo registro antes e depois da mudança.

Como explicar

Trancar() e Reativar() são métodos curtos porque a regra do negócio também é curta: trocar o valor do estado. Já ExibirInformacoes() não muda nada; ele serve para fotografar o estado atual da matrícula depois de cada ação.

Problema & Solucao

Problema: a matrícula precisava sair do estado puramente descritivo e ganhar operações administrativas básicas. Solução: criar métodos que mudem o atributo de situação e outro método que mostre o resultado dessas mudanças.

Erro comum: Fazer Trancar() imprimir "Trancada" sem alterar o atributo. Esquecer de mostrar Situacao na exibição.

▼

EX.09

Testando a classe Matricula

Montar um Main que mostre a situação antes, durante e depois das transições de estado da matrícula.

using System;

class Matricula
{
    public string NomeDoAluno;
    public string Curso;
    public int NumeroMatricula;
    public string Situacao;
    public string DataInicial;

    public void Trancar()
    {
        Situacao = "Trancada";
    }

    public void Reativar()
    {
        Situacao = "Ativa";
    }

    public void ExibirInformacoes()
    {
        Console.WriteLine("Aluno: " + NomeDoAluno);
        Console.WriteLine("Curso: " + Curso);
        Console.WriteLine("Número: " + NumeroMatricula);
        Console.WriteLine("Situação: " + Situacao);
        Console.WriteLine("Data inicial: " + DataInicial);
        Console.WriteLine();
    }
}

class Program
{
    static void Main()
    {
        Matricula m = new Matricula();

        m.NomeDoAluno = "Ana";
        m.Curso = "Análise e Desenvolvimento de Sistemas";
        m.NumeroMatricula = 12345;
        m.Situacao = "Ativa";
        m.DataInicial = "01/03/2026";

        m.ExibirInformacoes();

        m.Trancar();
        m.ExibirInformacoes();

        m.Reativar();
        m.ExibirInformacoes();
    }
}

O que a questao pede

Criar um Main que instancie Matricula, atribua valores e mostre a mudança da situação com chamadas a Trancar() e Reativar().

Conceito cobrado

O exercício avalia prova de funcionamento. O aluno precisa mostrar o antes e o depois das mudanças, não apenas chamar métodos em sequência.

Estrutura dos dados

m, Situacao, NomeDoAluno, Curso, NumeroMatricula e DataInicial.

Como pensar

Organize o teste em três momentos: estado inicial ativo, estado após trancamento e estado após reativação. Cada chamada de ExibirInformacoes() deve servir como uma foto desses três momentos.

Como validar

Se a primeira exibição mostra "Ativa", a segunda mostra "Trancada" e a terceira volta para "Ativa", então o Main comprovou corretamente o comportamento pedido.

Tabela de Evidencia

Momento	Trecho	Situação esperada	Leitura da evidência
Antes das mudanças	`m.ExibirInformacoes();`	`Ativa`	Mostra o estado inicial do vínculo.
Depois de `Trancar()`	`m.Trancar();` + `m.ExibirInformacoes();`	`Trancada`	Comprova que o método mudou o estado.
Depois de `Reativar()`	`m.Reativar();` + `m.ExibirInformacoes();`	`Ativa`	Mostra que o estado voltou ao valor anterior.

Variaveis-chave

m é o objeto testado; Situacao é o campo que precisa ser observado entre uma exibição e outra.

Como explicar

O código cria uma matrícula, preenche os dados básicos, imprime o estado inicial, tranca e imprime novamente, depois reativa e imprime mais uma vez. Essa repetição não é excesso; ela é justamente a evidência de que a mudança de estado aconteceu de verdade.

Problema & Solucao

Problema: sem um teste sequencial, os métodos poderiam existir mas não ficar comprovados. Solução: usar o Main como roteiro de execução e mostrar o estado da matrícula em cada etapa importante.

Erro comum: Não mostrar o antes e depois. Chamar Trancar() e Reativar() sem exibir a situação. Não deixar claro onde está o Main.

▼

EX.10

Classes Circulo e Esfera

Criar duas classes independentes com o atributo Raio e justificar por que essa medida é a base dos cálculos futuros.

class Circulo
{
    public double Raio;
}

class Esfera
{
    public double Raio;
}

O que a questao pede

Criar as classes Circulo e Esfera, cada uma com o atributo Raio, sem introduzir métodos de cálculo ainda.

Conceito cobrado

O foco não é fazer conta agora; é mostrar que o aluno reconhece qual dado precisa estar presente para que as fórmulas de área e volume possam existir depois.

Estrutura dos dados

Raio nas duas classes.

Como pensar

Pergunte qual medida controla o tamanho das duas figuras. Tanto no círculo quanto na esfera, o raio determina toda a escala geométrica. Por isso ele aparece sozinho nesta etapa.

Como validar

Se Circulo e Esfera foram criadas como classes separadas e cada uma guarda um Raio do tipo double, o exercício foi atendido sem antecipar herança ou métodos fora de hora.

Tabela de Evidencia

Classe	Atributo	Por que basta nesta etapa	Conexão com o próximo exercício
`Circulo`	`Raio`	A área do círculo depende diretamente do quadrado do raio.	Ele será usado em `CalcularArea()`.
`Esfera`	`Raio`	O volume da esfera depende diretamente do cubo do raio.	Ele será usado em `CalcularVolume()`.

Variaveis-chave

Raio é a variável-chave absoluta deste bloco, porque as duas figuras escalam a partir dela.

Como explicar

O atributo Raio é fundamental porque os cálculos de área e volume dependem diretamente dele. Sem o raio, não seria possível determinar a dimensão dessas figuras. O exercício quer justamente que o aluno perceba isso antes de sair escrevendo fórmulas.

Problema & Solucao

Problema: estruturar as figuras geométricas sem antecipar complexidade desnecessária. Solução: criar duas classes independentes e guardar nelas apenas o dado que realmente controla os cálculos futuros.

Erro comum: Criar métodos já nesta etapa, mesmo a questão dizendo que ainda não é necessário. Tentar usar herança, o que não foi pedido.

▼

EX.11

Métodos de cálculo

Adicionar os cálculos corretos de área e volume, com retorno em double e sem confundir retorno com impressão.

class Circulo
{
    public double Raio;

    public double CalcularArea()
    {
        return Math.PI * (Raio * Raio);
    }
}

class Esfera
{
    public double Raio;

    public double CalcularVolume()
    {
        return (4.0 / 3.0) * Math.PI * (Raio * Raio * Raio);
    }
}

O que a questao pede

Criar CalcularArea() na classe Circulo e CalcularVolume() na classe Esfera, retornando os resultados das fórmulas corretas.

Conceito cobrado

Aqui o método deve retornar o valor. O enunciado está testando se o aluno sabe diferenciar cálculo reutilizável de simples impressão no console.

Estrutura dos dados

Raio, CalcularArea() e CalcularVolume().

Como pensar

A sequência lógica é: pegar o valor já armazenado em Raio, aplicar a fórmula pedida pelo enunciado e devolver o número para quem chamou o método. O método não deve conversar com o console; ele deve devolver resultado.

Como validar

Com Raio = 3.0 no círculo, a área deve ficar próxima de 28.27. Com Raio = 5.0 na esfera, o volume deve ficar próximo de 523.60. Se os valores estiverem plausíveis e o método usar return, a implementação está no caminho certo.

Tabela de Evidencia

Método	Entrada	Resultado esperado	Ponto de atenção
`CalcularArea()`	`Raio = 3.0`	Aproximadamente `28.27`	Usar `Math.PI * (Raio * Raio)`.
`CalcularVolume()`	`Raio = 5.0`	Aproximadamente `523.60`	Usar `4.0 / 3.0`, não `4 / 3`.
Tipo de saída	Nenhuma leitura do console	`double` devolvido por `return`	O método precisa ser reutilizável.

Variaveis-chave

Raio é o dado de entrada; o valor devolvido por return é o produto final do método. No volume, 4.0 / 3.0 é um detalhe crítico para evitar divisão inteira.

Como explicar

CalcularArea() lê o raio do círculo e devolve a área usando a fórmula pedida. CalcularVolume() faz a mesma lógica para a esfera, mas precisa do cubo do raio e do fator 4.0 / 3.0. O ponto pedagógico mais importante é que ambos devolvem um número; quem decide imprimir esse número é o Main, não o método.

Problema & Solucao

Problema: calcular área e volume sem misturar lógica matemática com exibição. Solução: encapsular cada fórmula em um método simples, com retorno numérico e dependência apenas do atributo Raio.

Erro comum: Fazer Console.WriteLine() dentro do método em vez de return. Escrever 4 / 3 em vez de 4.0 / 3.0. Esquecer de usar Math.PI.

▼

EX.12

Testando Circulo e Esfera

Usar o Main para instanciar as figuras, definir raios, chamar os métodos e exibir resultados plausíveis.

using System;

class Circulo
{
    public double Raio;

    public double CalcularArea()
    {
        return Math.PI * (Raio * Raio);
    }
}

class Esfera
{
    public double Raio;

    public double CalcularVolume()
    {
        return (4.0 / 3.0) * Math.PI * (Raio * Raio * Raio);
    }
}

class Program
{
    static void Main()
    {
        Circulo c = new Circulo();
        c.Raio = 3.0;

        Esfera e = new Esfera();
        e.Raio = 5.0;

        Console.WriteLine("Área do círculo: " + c.CalcularArea());
        Console.WriteLine("Volume da esfera: " + e.CalcularVolume());
    }
}

O que a questao pede

Criar uma classe de teste com Main, instanciar um Circulo e uma Esfera, definir raios, chamar os métodos e mostrar os resultados.

Conceito cobrado

O exercício fecha o ciclo completo: modelar classe, preencher atributo, chamar método e validar se o número exibido faz sentido matemático.

Estrutura dos dados

c, e, Raio, CalcularArea() e CalcularVolume().

Como pensar

Separe o teste em duas trilhas curtas: uma para o círculo e outra para a esfera. Em cada trilha, o objeto é criado, recebe um raio, executa o método e gera um valor que o console apenas exibe.

Como validar

Com c.Raio = 3.0, a área exibida deve ficar perto de 28.27. Com e.Raio = 5.0, o volume deve ficar perto de 523.60. Se o número mostrado estiver muito distante disso, o problema está na fórmula ou no valor do raio.

Tabela de Evidencia

Objeto	Raio atribuído	Método chamado	Resultado plausível
`Circulo c`	`3.0`	`c.CalcularArea()`	Aproximadamente `28.27`
`Esfera e`	`5.0`	`e.CalcularVolume()`	Aproximadamente `523.60`
Console	N/A	`Console.WriteLine(...)`	Exibe os valores devolvidos pelos métodos.

Variaveis-chave

c e e são os objetos testados; Raio é a entrada; o retorno dos métodos é a saída que deve ser comparada com um valor plausível.

Como explicar

O Main cria um círculo e uma esfera, atribui um raio para cada um e só então chama os métodos de cálculo. O console não calcula nada por conta própria; ele apenas mostra os valores que os métodos devolveram. Isso prova que a responsabilidade matemática ficou dentro das classes e a responsabilidade de exibir ficou no teste.

Problema & Solucao

Problema: sem um teste final, as fórmulas podem estar escritas mas não comprovadas. Solução: usar o Main para instanciar, alimentar, executar e exibir resultados plausíveis para cada figura.

Erro comum: Não atribuir valor ao raio. Tentar imprimir o nome do método sem chamá-lo. Introduzir herança ou polimorfismo fora de escopo.

▼

CHECK

Checklist final de validacao

Conferencia final de modelagem, execucao e evidencias no console.

CHECK final do aluno

1) Cada classe tem atributos coerentes e metodos com responsabilidade clara.

2) O Main instancia objetos, altera estado e imprime evidencia de funcionamento.

3) Todo calculo tem validacao de entrada e explicacao do resultado observado.

Fechamento

Concluir o TP3 significa sair de resposta decorada e conseguir explicar o fluxo completo: modelagem, execucao e evidencia.