Exercício 3 da lista para estagiários Dev Comentado

/*
3) Crie uma classe chamada "ConversorDeTemperatura". Lembre-se que essa classe deverá obedecer às permissões do usuário que a estiver chamando. Crie métodos separados que façam as seguintes conversões: Celsius -> Fahrenheit, Fahrenheit -> Celsius, Celsius -> Kelvin, Kelvin -> Celsius, Fahrenheit -> Kelvin, Kelvin -> Fahrenheit. Todos esses métodos serão chamados por instâncias de classe, e portanto, as variáveis deverão ser definidas como variáveis de instância, que deverão ser privadas, e somente acessadas para atribuição de valores por meio da passagem dos argumentos pelo construtor, que atribuirá o valor das variáveis (que receberão uma temperatura de um determinado tipo) utilizando a palavra reservada "this", para fazer essa atribuição. No construtor, deverão ser passados 2 valores. Uma String e um valor Decimal. A String poderá ser "cf", que significa a conversão de Celsius para Fahrenheit, ou "fc", que significa a conversão de Fahrenheit para Celsius, e assim por diante, "cf" ou "fc", "ck", "kc", "fk", "kf". O valor do tipo Decimal, será o valor de temperatura, na unidade correspondente à String, ou seja, se você quer que a conversão de Celsius para Fahrenheit, passará "cf" como primeiro parâmetro do construtor e o valor Decimal será em Celsius, para que se tenha como retorno o valor calculado em Fahrenheit. E assim em todos os outros casos com suas devidas Strings e Conversões.
Ainda, dentro dessa classe, deverá existir um método, que utilizará o "switch on", que deverá ser chamado dentro do construtor para realizar a decisão de qual método deverá ser utilizado. O método que conterá o "switch on", deverá utilizar a variável de instância, que deverá ser "ck", "cf"... que foi previamente atribuída via construtor e chamará o método correspondente àquela conversão, que então retornará o valor correspondente à conversão solicitada, que será atribuído à um atributo (ou variável) de instância privada, que conterá o resultado da conversão. Portanto, teremos um método acessor, que será chamado pelo Anonymous, após instanciar-mos a classe e passarmos os parâmetros via construtor, que já conterá o resultado da conversão solicitada. Esse método será único, e acessará a variável de instância que conterá o resultado e acessará a variável de instância que contém a String da decisão de conversão, que também será única, já que a conversão sempre será realizada uma única vez, a cada vez que quisermos realizar uma conversão. O retorno do método deverá ser um Map, que terá como chave a String que determina a conversão, concatenada com um número, que pode ser a linha do Map, para tornar a chave única e o valor Decimal correspondente fruto do cálculo de conversão.
*/


public with sharing class TempConverter {
    //declaração do atributo que determina o tipo de conversão
    private String conversao;
    //declaração do atributo que corresponde à temperatura a ser convertida
    private Decimal temperatura;
    //declaração do atributo que conterá o valor do resultado de qq uma das conversões
    private Decimal resultado;
    //criação do construtor vazio em função da criação do construtor com parâmetros
    public TempConverter(){}
    //criação do construtor que recebe o tipo da conversão e a temperatura a ser convertida
    public TempConverter(String conversao, Decimal temperatura){
        //atribuição do tipo da conversão recebida pelo construtor para o atributo de instância
        this.conversao = conversao;
        //atribuição do valor da temperatura recebida pelo construtor para o atributo de instância
        this.temperatura = temperatura;
        //chamada do método que chama o método específico definido pelo tipo de conversão
        this.escolheConversao();
    }
    //método de faz a conversão de celsius para fahrenheit e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void CelsiusToFah(){
        this.resultado = (this.temperatura*9/5)+32;
    }
    //método de faz a conversão de fahrenheit para celsius e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void FahToCelsius(){
        this.resultado = (this.temperatura - 32)*5/9;
    }
    //método de faz a conversão de celsius para kelvin e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void CelsiusToKelvin(){
        this.resultado = this.temperatura + 273.15;
    }
    //método de faz a conversão de kelvin para celsius e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void KelvinToCelsius(){
        this.resultado = this.temperatura - 273.15;
    }
    //método de faz a conversão de fahrenheit para kelvin e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void FahToKelvin(){
        this.resultado = (this.temperatura - 32) * 5/9 + 273.15;
    }
    //método de faz a conversão de kelvin para fahrenheit e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void KelvinToFah(){
        this.resultado = (this.temperatura - 273.15)*9/5 + 32;
    }
    //método que faz o chaveamento para determinação da execução do método específico de conversão
    //em função do tipo da conversão
    private void escolheConversao(){
        switch on this.conversao{
            when 'cf'{
                //chamada do método que converte de celsius para fahrenheit
                this.CelsiusToFah();
            }
            when 'fc'{
                //chamada do método que converte de fahrenheit para celsius
                this.FahToCelsius();
            }
            when 'ck'{
                //chamada do método que converte de celsius para kelvin
                this.CelsiusToKelvin();
            }
            when 'kc'{
                //chamada do método que converte de kelvin para celsius
                this.KelvinToCelsius();
            }
            when 'fk'{
                //chamada do método que converte de fahrenheit para kelvin
                this.FahToKelvin();
            }
            when 'kf'{
                //chamada do método que converte de kelvin para fahrenheit
                this.KelvinToFah();
            }
            when else{
                //esse when atribui 0 para o valor de temperatura do resultado e n/a
                //(não aplicável) em função de ter sido escolhida uma sigla que não
                //pertence ao conjunto das que devem ser admitidas para a conversão
                this.resultado = 0;
                this.conversao = 'n/a';
            }
        }
    }
    //método que retorna um map que contém uma chave que corresponde ao tipo de conversão e
    //um valor, que é uma lista de dois valores decimais, que correspondem respectivamente
    //nas posições de índice [0] e [1], da temperatura que será convertida e da temperatura
    //que já foi convertida
    public Map<String, List<Decimal>> retornaTemp(){
        //O código comentado abaixo é uma opção para se enviar como valor no map
        //que é retornado para quem chama esse método
        /*
        Objeto obj = new Objeto();
        obj.tempEntrada = this.temperatura;
        obj.tempSaida = this.resultado;
        */
        //criação do map que será retornado
        Map<String, List<Decimal>> mapa = new Map<String, List<Decimal>>();
        //populando o map com o tipo de conversão e a lista com os dois valores
        //correspondentes as temperaturas de entrada e saída
        mapa.put(this.conversao, new List<Decimal>{this.temperatura, this.resultado});
        return mapa;
    }
}

/* CÓDIGO DO ANONYMOUS
//atribuição do valor à ser convertido
Decimal tempParaConverter = 273.15;
//atribuição do tipo da conversão
String conversor = 'kc';
//declaração do texto correspondente aos tipos de temperaturas, da que será
//convertida e da que já foi convertida, respectivamente
String tempEntrada, tempSaida;
//criação do objeto e instância de classe, com a passagem das variáveis que contém
//os valores do tipo de conversão e da temperatura, respectivamente
TempConverter tc = new TempConverter(conversor, tempParaConverter);
//declaração do map que recebe a chave e valor pela execução do método de retorno
//do resultado, que pertence à classe, e atribuição do resultado ao objeto do tipo Map
//desses valores
Map<String, List<Decimal>> mapa = tc.retornaTemp();
//Exibição do map retornado por motivos didáticos
System.debug(mapa);
//declaração e inicialização da variável de maior escopo que conterá a chave do map, que corresponde
//ao tipo da conversão que será realizada, após a iteração das chaves do map (que conterá
//somente um único elemento)
String conversorRetornado = '';
//Iteração das chaves do map que foi retornado, e atribuição da chave para a variável declarada
//acima, para que seja acessada fora do escopo do loop
for(String key:mapa.keySet()){
    conversorRetornado = key;
}
//Declaração e atribuição de Lista, que contém os valores do map que recebeu o retorno com
//os resultados da operação
List<Decimal> listaRetornada = mapa.get(conversorRetornado);
//declaração e atribuição do conteúdo das duas posições da lista que recebeu as temperaturas
//de entrada para conversão e de saída que é o resultado da conversão
Decimal tempIn = listaRetornada[0];
Decimal tempOut = listaRetornada[1];
        //chaveamento para atribuição de string mais estética para apresentação de frase
        //com os tipos de temperaturas, de entrada e saída, correspondentes às temperaturas
        //sendo a primeira a ser convertida e a segunda já convertida
        switch on conversor{
            when 'cf'{
                tempEntrada = 'Celsius';
                tempSaida = 'Fahrenheit';
            }
            when 'fc'{
                tempEntrada = 'Fahrenheit';
                tempSaida = 'Celsius';
            }
            when 'ck'{
                tempEntrada = 'Celsius';
                tempSaida = 'Kelvin';
            }
            when 'kc'{
                tempEntrada = 'Kelvin';
                tempSaida = 'Celsius';
            }
            when 'fk'{
                tempEntrada = 'Fahrenheit';
                tempSaida = 'Kelvin';
            }
            when 'kf'{
                tempEntrada = 'Kelvin';
                tempSaida = 'Fahrenheit';
            }
        }
//Exibição da frase com o resultado final
System.debug(tempIn+'º '+tempEntrada+' equivale a '+tempOut+'º '+tempSaida);

*/