Vitor Ricardo

Entendendo o uso de Classes C# – Parte 2

Como visto no Entendo o uso de Classes C# – Parte 1, as classes são usadas para abstrair objetos. Nessas classes, tanto os parâmetros quanto os métodos podem possuir o estado de público ou privado. O estado público designa que o parâmetro/método pode ser acessado de fora da classe, enquanto o privado só pode ser manipulado pela mesma. Há outros estados que podemos usar, mas não será aplicado neste artigo.

Abra o projeto criado no artigo anterior, acesse o arquivo GuerreiroZ e substitua para o seguinte código:

public class GuerreiroZ
{
    //Usado para Instanciar a classe com parâmetros preenchidos
    public GuerreiroZ(string nome, Racas raca, int ki)
    {
        Nome = nome;
        Raca = raca;
        this.ki = ki;
    }

    //Usado para Instanciar a classe vazia
    public GuerreiroZ()
    {

    }

    //Restante do código...
}

Neste momento, a classe irá apresentar erros, mas isso será solucionado com o trecho a seguir, adicione os atributos a classe:

//Valores pré definidos e estáticos
public enum Racas
{
    Humano,
    Saiyajin,
    Androide,
    Namekuseijin
}

public string Nome;
public Racas Raca;
private int ki;

Acima criamos um Enum, o qual são valores estáticos pré definidos, isso nos auxilia em pré determinar quais valores o parâmetro Raca deve ter. Temos também um atributo público chamado Nome um privado chamado ki.

Agora, adicione o seguinte trecho:

/// <summary>
/// Método usado para aumentar o Ki
/// </summary>
/// <param name="ki"></param>
public void AumentarKi(int ki)
{
    this.ki += ki;
}

/// <summary>
/// Método usado obter o Ki
/// </summary>
/// <returns>Int</returns>
public int ObterKi()
{
    return this.ki;
}

Pelo fato do atributo ki ser privado, ele não pode ser acessado externamente da classe, portanto, criamos o método ObterKi para pegar o valor e o AumentarKi, para incrementar o valor (note que este último recebe um parâmetro), ambos métodos públicos.

Seguindo na codificação, adicione agora o trecho:

/// <summary>
/// Método usado para usar um poder
/// </summary>
/// <param name="raca"></param>
public void UsarPoder(Racas raca)
{
    int minUso;
    int maxUso;

    switch (raca)
    {
        case Racas.Androide:
            minUso = 500;
            maxUso = 1000;

            if (conferirSePodeUsarPoder( maxUso))
                diminuirKi(minUso, maxUso);
            break;
        case Racas.Humano:
            minUso = 200;
            maxUso = 800;

            if (conferirSePodeUsarPoder(maxUso))
                diminuirKi(minUso, maxUso);
            break;
        case Racas.Namekuseijin:
            minUso = 1000;
            maxUso = 2000;

            if (conferirSePodeUsarPoder( maxUso))
                diminuirKi(minUso, maxUso);
            break;
        case Racas.Saiyajin:
            minUso = 3000;
            maxUso = 5000;
            
            if (conferirSePodeUsarPoder(maxUso))
                diminuirKi(minUso, maxUso);
            break;
        default:
            Console.WriteLine("Raça não existe");
            break;
    }
}

Este é um método um pouco mais complexo, nele pedimos como parâmetro um valor do enum Racas e fazemos um Switch, de acordo com o valor passado, conferimos se o Guerreiro Z tem ki suficiente pra usar o poder.

Vamos implementar os 2 últimos métodos:

/// <summary>
/// Método usado para conferir se o guerreiro tem ki suficiente para usar o poder
/// </summary>
/// <param name="max"></param>
/// <returns>Bool</returns>
private bool conferirSePodeUsarPoder(int max)
{
    if (ki >= max)
        return true;

    return false;
}

/// <summary>
/// Método usado para diminuir randomicamente o ki
/// </summary>
/// <param name="min"></param>
/// <param name="max"></param>
private void diminuirKi(int min, int max)
{
    //Classe responsável por randomizar
    Random rnd = new Random();
    //Randomiza um número inteiro com base de um intervalo de números
    this.ki -= rnd.Next(min, max);
}

Foram adicionados 2 métodos privados, que são acessados pelo método público UsarPoder. O método conferirSePodeUsarPoder retorna um valor do tipo boolean, ao conferir se o guerreiro possui ou não Ki para usar o seu poder. Já o método diminuirKi, é responsável por randomizar um número inteiro entre um intervalo e decrementar do atributo ki este valor gerado.

Arquivo GuerreiroZ.cs completo:

public class GuerreiroZ
{
    //Usado para Instanciar a classe com parâmetros preenchidos
    public GuerreiroZ(string nome, Racas raca, int ki)
    {
        Nome = nome;
        Raca = raca;
        this.ki = ki;
    }

    //Usado para Instanciar a classe vazia
    public GuerreiroZ()
    {

    }

    //Valores pré definidos e estáticos
    public enum Racas
    {
        Humano,
        Saiyajin,
        Androide,
        Namekuseijin
    }

    public string Nome;
    public Racas Raca;
    private int ki;

    /// <summary>
    /// Método usado para aumentar o Ki
    /// </summary>
    /// <param name="ki"></param>
    public void AumentarKi(int ki)
    {
        this.ki += ki;
    }

    /// <summary>
    /// Método usado obter o Ki
    /// </summary>
    /// <returns>Int</returns>
    public int ObterKi()
    {
        return this.ki;
    }

    /// <summary>
    /// Método usado para usar um poder
    /// </summary>
    /// <param name="raca"></param>
    public void UsarPoder(Racas raca)
    {
        int minUso;
        int maxUso;

        switch (raca)
        {
            case Racas.Androide:
                minUso = 500;
                maxUso = 1000;

                if (conferirSePodeUsarPoder( maxUso))
                    diminuirKi(minUso, maxUso);
                break;
            case Racas.Humano:
                minUso = 200;
                maxUso = 800;

                if (conferirSePodeUsarPoder(maxUso))
                    diminuirKi(minUso, maxUso);
                break;
            case Racas.Namekuseijin:
                minUso = 1000;
                maxUso = 2000;

                if (conferirSePodeUsarPoder( maxUso))
                    diminuirKi(minUso, maxUso);
                break;
            case Racas.Saiyajin:
                minUso = 3000;
                maxUso = 5000;
                
                if (conferirSePodeUsarPoder(maxUso))
                    diminuirKi(minUso, maxUso);
                break;
            default:
                Console.WriteLine("Raça não existe");
                break;
        }
    }

    /// <summary>
    /// Método usado para conferir se o guerreiro tem ki suficiente para usar o poder
    /// </summary>
    /// <param name="max"></param>
    /// <returns>Bool</returns>
    private bool conferirSePodeUsarPoder(int max)
    {
        if (ki >= max)
            return true;

        return false;
    }

    /// <summary>
    /// Método usado para diminuir randomicamente o ki
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    private void diminuirKi(int min, int max)
    {
        Random rnd = new Random();
        this.ki -= rnd.Next(min, max);
    }
}

Agora que temos nossa classe completamente criada, vá até o arquivo Program.cs e cole o seguinte código:

static void Main(string[] args)
{
    GuerreiroZ Goku = new GuerreiroZ("Goku",GuerreiroZ.Racas.Saiyajin, 10000);
    GuerreiroZ Piccolo = new GuerreiroZ("Piccolo", GuerreiroZ.Racas.Namekuseijin, 5000);
    GuerreiroZ N18 = new GuerreiroZ("N18", GuerreiroZ.Racas.Androide, 3500);
    GuerreiroZ Kuririn = new GuerreiroZ("Kuririn", GuerreiroZ.Racas.Humano, 2500);

    Console.WriteLine($"Nome: {Goku.Nome}, Raça: {Goku.Raca}, Poder: { Goku.ObterKi() }");
    Console.WriteLine($"Nome: {Piccolo.Nome}, Raça: {Piccolo.Raca}, Poder: { Piccolo.ObterKi() }");
    Console.WriteLine($"Nome: {N18.Nome}, Raça: {N18.Raca}, Poder: { N18.ObterKi() }");
    Console.WriteLine($"Nome: {Kuririn.Nome}, Raça: {Kuririn.Raca}, Poder: { Kuririn.ObterKi() }");

    Goku.AumentarKi(15000);
    Console.WriteLine($"Novo poder do Goku: { Goku.ObterKi() }");
    Goku.UsarPoder(Goku.Raca);
    Console.WriteLine($"Goku usou poder: { Goku.ObterKi() }");
    Goku.UsarPoder(Goku.Raca);
    Console.WriteLine($"Goku usou poder: { Goku.ObterKi() }");
    Goku.AumentarKi(1000000);
    Goku.Nome = "Goku Super Saiyajin 1";
    Console.WriteLine($"Nome: {Goku.Nome}, Poder: { Goku.ObterKi() }");

    Console.ReadKey();
}

//Outputs:
// Nome: Goku, Raça: Saiyajin, Poder: 10000
// Nome: Piccolo, Raça: Namekuseijin, Poder: 5000
// Nome: N18, Raça: Androide, Poder: 3500
// Nome: Kuririn, Raça: Humano, Poder: 2500
// Novo poder do Goku: 25000
// Goku usou poder: 20028
// Goku usou poder: 16491
// Nome: Goku Super Saiyajin 1, Poder: 1016491

Como no artigo 1, criamos várias classes do GuerreiroZ, com valores diferentes. Apesar de todas terem a mesma origem, elas não são compartilhadas e podem ser manipuladas sem interferir em outra instância.

Dica: Neste exemplo manipulamos somente a classe do Goku, manipule os outros, altere valores, brinque com o código para assimilar o conteúdo.

Conclusão

O uso de classe facilita a organização de seu projeto e ajuda a colocar nomes em determinados objetos, devido a isso, use e abuse dela , criando e atribuindo os parâmetros/métodos de forma adequada a cada classe criada.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *